C++ Language

By Santosh Bhalke

Introduction To C++
Structure of a program

Comments
C++ supports two ways to insert comments:

Variables, Data Types.

Identifiers
asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while

Operators as Identifiers
and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor, xor_eq

Very important: The C++ language is a "case sensitive" language. Fundamental data types:
When programming, we store the variables in our computer's memory, but the computer has to know what kind of data we want to store in them, since it is not going to occupy the same amount of memory to store a simple number than to store a single letter or a large number, and they are not going to be interpreted the same way.

 Note: The values of the columns Sizeand Rangedepend on the system the
program is compiled for. The values shown above are those found on most 32bit systems.

Contd
Declaration of variables:
The syntax to declare a new variable is to write the specifier of the desired data type (like int, bool, float...) followed by a valid variable identifier. Eg:

Scope of variables:

Contd
Initialization of variables:
When declaring a regular local variable, its value is by default undetermined. But you may want a variable to store a concrete value at the same moment that it is declared. In order to do that, you can initialize the variable. There are two ways to do this in C++:
The first one, known as c-like, is done by appending an equal sign followed by the value to which the variable will be initialized: type identifier = initial_value; The other way to initialize variables, known as constructor initialization, is done by enclosing the initial value between parentheses (()): type identifier (initial_value);

Introduction to strings:
Variables that can store non-numerical values that are longer than one single character are known as strings. The C++ language library provides support for strings through the standard stringclass. This is not a fundamental type, but it behaves in a similar way as fundamental types do in its most basic usage.

Contd
A first difference with fundamental data types is that in order to declare and use objects (variables)of this type we need to include an additional header file in our source code: <string> and have access to the std namespace.

Contd
Character and string literals have certain peculiarities, like the escape codes. These are special characters that are difficult or impossible to express otherwise in thesource code of a program, like newline (\n) or tab (\t). All of them are preceded by a backslash (\). Here you have a list of some of such escape codes:

Operators
Once we know of the existence of variables and constants, we can begin to operate with them. Unlike other languages whose operators are mainly keywords, operators in C++are mostly made of signs that are not part of the alphabet but are available in all keyboards. This makes C++ code shorter. Assignment (=) Arithmetic operators ( +, -, *, /, % ) Compound assignment (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) Increase and decrease (++, --) Relational and equality operators ( ==, !=, >, <, >=, <= ) Logical operators ( !, &&, || ) Conditional operator ( ? ) Comma operator ( , ) Bitwise Operators ( &, |, ^, ~, <<, >> ) Explicit type casting operator sizeof()

Contd
Precedence of operators

Basic Input/Output
C++ uses a convenient abstraction called streams to perform input and output operations in sequential media such as the screen or the keyboard. A stream is an object where a program can either insert or extract characters to/from it. Standard Output (cout)
The << operator inserts the data that follows it into the stream preceding it.

Standard Input (cin)

Contd
cin and strings
We can use cinto get strings with the extraction operator (>>) as we do with fundamental data type variables:

Stringstream
The standard header file <sstream>defines a class called stringstream that allows a string-based object to be treated as a stream.

Control Structures
Conditional structure: if and else

Iteration structures (loops)

The while loop

Contd
The do-while loop

The for loop

Cntd
Jump statements
The break statement

The continue statement

Cntd
The goto statement

The exit function

The selective structure: switch

Functions (I)
Using functions we can structure our programs in a more modular way, accessing all the potential that structured programming can offer to us in C++. A function is a group of statements that is executed when it is called from some point of the program. The following is its format:

type name ( parameter1, parameter2, ...) { statements }

Cntd

Cntd
Functions with no type, The use of void.
Imagine that we want to make a function just to show a message on the screen. We do not need it to return any value. In this case we should use the void type specifier for the function. This is a special specifier that indicates absence of type.

Void can also be used in the function's parameter list to explicitly specify that we want the function to take no actual parameters when it is called. Although it is optional to specify voidin the parameter list.

Functions (II)
Arguments passed by value and by reference
When calling a function with parameters, what we have passed to the function were copies of their values but never the variables themselves. Some cases where you need to manipulate from inside a function the value of an external variable. For that purpose we can use arguments passed by reference.

The ampersand is what specifies that their corresponding arguments are to be passed by reference instead of by value. When a variable is passed by reference we are not passing a copy of its value, but we are somehow passing the variable itself to the function and any modification that we do to the local variables will have an effect in their counterpart variables passed as arguments in the call to the function.

 Passing by reference is also an effective way to allow a function to return more than one value. For example, here is a function that returns the previous and next numbers of the first parameter passed.

 Default values in parameters

When declaring a function we can specify a default value for each of the last parameters. This value will be used if the corresponding argument is left blank when calling to the function. We simply have to use the assignment operator and a value for the arguments in the function declaration. If a value for the parameter is not passed when the function is called, the default value is used, but if a value is specified this default value is ignored and the passed value is used instead.

 Overloaded functions
In C++ two different functions can have the same name if their parameter types or number are different. That means that you can give the same name to more than one function if they have either a different number of parameters or different types in their parameters.

 The compiler knows which one to call in each case by examining the types passed as arguments when the function is called. If it is called with two ints as its arguments it calls to the function that has two int parameters in its prototype and if it is called with two floats it will call to the one which has two float parameters in its prototype. This one has a different behavior: it divides one parameter by the other. So the behavior of a call to operate depends on the type of the arguments passed because the function has been overloaded. Notice that a function cannot be overloaded only by its return type. At least one of its parameters must have a different type.

Inline functions
The inline specifier indicates the compiler that inline substitution is preferred to the usual function call mechanism for a specific function. The behavior of a function will not change itself, but is used to suggest to the compiler that the code generated by the function body is inserted at each point the function is called, instead of being inserted only once and perform a regular call to it, which generally involves some additional overhead in running time.

inline type name ( arguments ... ) { instructions ... }

Most compilers already optimize code to generate inline functions when it is more convenient. This specifier only indicates the compiler that inline is preferred for this function

 Recursivity

Declaring functions

Arrays
An array is a series of elements of the same type placed in contiguous memory locations that can be individually referenced by adding an index to a unique identifier.

Initializing arrays

Accessing the values of an array

 Multidimensional arrays
Multidimensional arrays can be described as "arraysof arrays".

int jimmy [3][5];

The amount of memory needed for an array rapidly increases with each dimension.

 Arrays as parameters
At some moment we may need to pass an array to a function as a parameter. In C++ it is not possible to pass a complete block of memory by value as a parameter toa function, but we are allowed to pass its address. In practice this has almost the same effect and it is a much faster and more efficient operation.

Pointers
The memory of your computer can be imagined as a succession of memory cells, each one of the minimal size that computers manage (one byte).

Reference operator (&)

The address that locates a variable within memory is what we call a reference to that variable. This reference to a variable can be obtained by preceding the identifier of a variable with an ampersand sign (&), known as reference operator, and which can be literally translated as "address of".

Dereference operator (*)