A general view of C++: Main Features

S,B - enlarge/reduce font
A - view all/single slide
F - enable/disable status bar
Left button, PgDn, Space - next slide
Right button, PgUp, left arrow - prev slide

C++: Main Features

Comments
Input and Output
Variable declaration
Constant declaration
User-defined types
Function overloading
Default arguments
Memory allocation
Reference declaration

Comments

C++ supports C-style comments:

/*
    This is a comment made of
    many lines
*/

But also supports single line comments:

int main()
{
	int i;
	for(i=0;i<20;++i)
	  printf("%d\n",i); // Write number on screen
	puts("Done");
}

Input and Output

C++ introduces a powerful and easy to use I/O system - iostream

Example of output commands:

int i = 5;
cout << "The value of i is " << i << endl;

Example of input commands:
```
int i;
cin >> i;
```

Variable declaration

In C++ variables can be declared anywhere within the program:

int main()
{
  int x = 0;
  ...
  for (int c=0; c<20; c++)
    cout << c << endl;
  ...
  int v = x + c;
  ...
}

Note that the c variable only exists inside the for command!

Constant declaration

In C constants are declared through pre-processing directives (#define):
```
#define MAX   100
```
C++ introduces the use of the const keyword:
```
const int MAX = 100;
```
const has a number of uses...

E.g.: to make sure that a variable won't be changed within a function

void calc(const int x)
{
   x++;   // Compilation error: x has been declared as "const"
   ...
}

User-defined types

In C types are declared using typedef:
```
typedef struct
{
   int x,y;
} Point;
```
In C++ typedef is no longer needed and we can write:
```
struct Point
{
  int x,y;
};
```

Function overloading

In C++ the same function name may be associated to many implementations:

void func(float x)
{
  cout << "Float parameter: " << x << endl;
  ...
}

void func(int x)
{
  cout << "Int parameter: " << x << endl;
  ...
}

void func(char* x)
{
  cout << "Pointer to char parameter: " << x << endl;
}

The compiler figures out which version to call according to the parameter type.

Default arguments

C++ allows the definition of default function arguments, i.e., they define the parameter value if the user doesn't inform it:
```
void calc(int a, int b, int c=5)
{
   ...
}
```
In this case, the function may be called passing 2 or 3 parameters:calc(5, 6); // Or: calc(5, 6, 2);

Memory allocation

In C memory allocation is performed by the malloc/calloc/free functions:

// Allocating a 100-element int array
int* v;
v = malloc(sizeof(int)*100));
...
// Freeing memory
free(v);

In C++ we use the new and delete commands, which are easier:

// Allocating a 100-element int array
int *v;
v = new int[100];
...
// Freeing memory
delete [] v;

Reference declaration

In C we use the & and * operators:

void swap(int *x, int *y)
{
   int tmp = *y;
   *x = *y;
   *y = tmp;
}

...
int a,b;
swap(&a, &b);

C++ uses only the & operator to indicate that the variable is a reference:

void swap(int &x, int &y)
{
   int tmp = y;
   x = y;
   y = tmp;
}

...
int a,b;
swap(a, b);