A C program is divided into multiple functions where each function acts like a separate building block. To identify the starting point of a C program, one function is always designated as the main function. A simple C program looks like this:

main()
{
  printf ("This is a simple C program.
");
}

Large C programs consist of multiple functions where each additional function appears defined separate from the main function. In the following example, the separate function is printme as follows:

main()
{
  printme;
}

printme ()
{
  printf ("This is a simple C program.
");
}

Oftentimes a C program needs to use a feature defined in a separate library, so you may see programs that define a library to add, such as

#include <stdio.h>
main()
{
  printf("This is a simple C program.
");
}

The structure of a typical C++ program looks similar. The following C++ example includes a C++ library called iostream and uses elements defined in a standard C++ library called std:

#include <iostream>
using namespace std;

int main ()
{
  cout << "This is a simple C++ program.";
  return 0;
}

Despite minor differences, C and C++ programs basically consist of a single main function and zero or more additional functions.

To write a comment in C/C++, you have two choices. First, you can use the double slash character so that anything that appears to the right is a comment, such as

#include <iostream>
using namespace std;

// This is a comment at the beginning of the program
int main ()
{
  cout << "This is a simple C++ program.";
  return 0;
}

The double slash character is handy for adding a comment to a single line. If you want to write a comment over multiple lines, you can use the /* and */ characters, such as

/* This C program was written as a simple example
   to show people how easy C can be to learn. */

#include <stdio.h>
main()
{
  printf("This is a simple C program.
");
}

When declaring variables in C/C++, you first declare the data type and then the variable name, such as

datatype VariableName;

VariableName can be any descriptive name. Because C/C++ is a case-sensitive language, it treats SalesTax as a completely different variable than salestax. Some programmers use uppercase letters to make variable names easier to find whereas others use all lowercase. To declare multiple variables, cram them all on a single line, separated by a comma, such as

datatype VariableName1, VariableName2, VariableName3;

char variablename;

char arrayname[arraylength];

char firstname[20];

#include <string>
using namespace std;
string stringvariable;

int variablename;

short int smallvariable;
short smallvariable;

unsigned int variablename;

signed long variablename;

long variablename;

#define FALSE 0
#define TRUE 1
int flag = FALSE;

bool variablename;

The three types of operators used are mathematical, relational, and logical. Mathematical operators calculate numeric results such as adding, multiplying, or dividing numbers, as shown in Table 1-3.

Relational operators compare two values and return a True or False value. The six comparison operators available are shown in Table 1-4.

Logical operators compare two Boolean values (True or False) and return a single True or False value, as shown in Table 1-5.

j = 5;
i = j + 1;

j = 5;
i = ++j;

j = 5;
i = j++;

j = 5;
i = --j;

j = 5;
i = j--;

i = 59;

The simplest branching statement is an IF statement that only runs one or more commands if a Boolean condition is True, such as

if (condition) {
  Command;
}

To make the computer choose between two mutually exclusive sets of commands, you can use an IF-ELSE statement, such as

if (condition) {
  Command;
  }
else {
  Command;
}

Unlike C, C++ includes an IF-ELSEIF statement, which uses two or more Boolean conditions to choose which of two or more groups of commands to run, such as

if (condition1) {
  Command;
  }
else if (condition2) {
  Command;
  }

Although the IF-ELSE statement can only give the computer a choice of two groups of commands to run, the IF-ELSEIF statement can offer the computer multiple groups of commands to run, such as

if (condition1) {
  Command;
  }
else if (condition2) {
  Command;
  }
else if (condition3) {
  Command;
  }

As an alternative to the IF-ELSEIF statement, you can also use the SWITCH statement, such as

switch (expression) {
case value1:
  Command;
  break;
case value2:
  Command;
  break;
default:
  Command;
}

The preceding SWITCH statement is equivalent to the following IF-THEN-ELSEIF statement:

if (expression = value1) {
  Command;
  }
else if (expression = value2) {
  Command;
  }
else {
  Command;
}

To check if a variable matches multiple values, you can stack multiple case statements, such as

switch (expression) {
case value1:
case value2:
  Command;
  break;
case value3:
case value4;
  Command;
  break;
default:
  Command;
}

The preceding SWITCH statement is equivalent to the following IF-ELSEIF statement in C++:

if (expression = value1) || (expression = value2) {
  Command;
  }
else if (expression = value3) || (expression = value4) {
  Command;
  }
else {
  Command;
  }

A looping statement repeats one or more commands for a fixed number of times or until a certain Boolean condition becomes True. To create a loop that repeats for a fixed number of times, use the FOR loop, which looks like this:

for (startvalue; endvalue; increment) {
  Command;
  }

If you wanted the FOR loop to run five times, you could set the Start value to 1 and the End value to 5, such as

for (i = 1; i <= 5; i++) {
  Command;
  }

If you don't know how many times you need to repeat commands, you'll have to use a WHILE loop, which looks like this:

while (condition) {
  Command;
}

If the condition is True, the loop runs at least once. If this condition is False, the loop does not run.

A variation of the WHILE loop is the DO-WHILE loop, which looks like this:

do {
  Command;
} while (condition);

The main difference between the two loops is that the WHILE loop may run zero or more times, but the DO-WHILE loop always runs at least once.

In C/C++, every subprogram is a function that can return a value. The format of a typical function looks like this:

Datatype functionname (Parameter list)
  {
  Commands;
  Return value;
}

The three parts of a C/C++ function are

If a function doesn't return a value or require any data, it might look like this:

void myfunction ()
  {
  Command;
  }

If the function needs to return an integer value, it might look like this:

int myfunction ()
  {
  Command;
  return value;
  }

In the preceding example, value represents any integer value.

To accept data, a function needs a parameter list, which simply lists a variable to hold data along with its specific data type, such as an integer or character. To create a function that accepts an integer and a character, you could do something like this:

int myfunction (int mynumber, char myletter)
  {
  Command;
  return value;
  }

The preceding function accepts two values by value, so the function can change the values of variables in its parameter list, but those changed values won't appear outside that function.

If you want a function to change the values of its parameters, you need to define a parameter list by identifying which variables accept values by reference. To identify values passed by reference, use the & sign, such as

int myfunction (int& mynumber, char myletter)
  {
  Command;
  return value;
  }

Many C/C++ compilers include libraries that offer data structures, such as stacks or collections. However, three built-in data structures of C/C++ are the structure (sometimes called a record in other programming languages), enumerated variables, and the array.

struct name {
  datatype variable;
};

struct MyGrades {
  char grade;
  int class_number;
};

struct MyGrades chemistry;

struct MyGrades {
  char grade;
  int class_number;
} chemistry;

enum name {item1, item2, item3};

enum weekend {saturday, sunday};

enum weekend timeoff;

enum {saturday, sunday} timeoff;

datatype arrayname[size];

int mynumbers[10];

int mynumbers[4] = {23, 8, 94, 102};

int mynumbers[4];
mynumber[0] = 23;
mynumber[1] = 8;
mynumber[2] = 94;
mynumber[3] = 102;

Before C++, object-oriented programming was more of an academic exercise that required special programming languages. After C++ appeared, ordinary programmers could use their knowledge of C to use object-oriented programming for practical purposes.

To create an object, you must create a separate class stored in a class file. A typical class looks like this:

class className
  {
  public:
    datatype propertyname;

    void methodname();
  };

The class lists one or more properties and the type of data that property can hold, such as an integer or floating point number. A class also lists one or more method names, which contains code for manipulating an object in some way. The class defines the method name and its parameter list, but the actual code for that method appears outside the class definition, such as

class className
  {
  public:
    datatype propertyname;

    void methodname();
  };
void classname::methodname()
  {
  Commands;
  }

After you define a class, you can create an object from that class by declaring a variable as a new class type, such as

className objectname;

So if you created an animal class, you could create an object (things_at_the_zoo) from that class as follows:

animal things_at_the_zoo;

The C++ language allows both single and multiple inheritance. With single inheritance, you can declare a class name and state the class to inherit from with a colon, such as

class className : public classtoinheritfrom
  {
  // Code goes here
  };

To inherit from multiple classes, name each class as follows:

class className : public class1, public class2
  {
  // Code goes here
  };