C++ Programming

Programming Paradigms · logically constant

bool
const
inline
//
inline
for
//
// 'Hello World!' program 

#include <iostream>

int main()
{
  std::cout << "Hello World!" << std::endl;
  return 0;
}

extern
extern "C" void LibraryFunction();

static_cast
dynamic_cast
const_cast
reinterpret_cast
dynamic_cast
std::vector
sizeof
register
namespace
int main()
private
goto
goto
for
return
#include<iostream.h>
#include<math.h>
 void main()
 {
	int choose;
	double Area,Length,Width,Radius,Base,Height;
	cout<<"circle(1)";
	cout<<"Square(2)";
	cout<<"Rectangle(3)";
	cout<<"Triangle(4)";
	cout<<"select 1,2,3,4:";
 loop:
	cin>>choose;
 if(choose=='1')
  {
		double Radius;
		const double pi=3.142;
		cout<<"Enter Radius";
		cin>>Radius;
		Area=pi*pow(Radius,2);
  }
  else if(choose=='2')
  {
		double Length;
		cout<<"Enter Length:";
		cin>>Length;
		Area= pow(1,2);
  }
  else if (choose=='3')
  {
		double Length,Width;
		cout<<"Enter Length:";
		cin>>Length;
		cout<<"Enter Width:";
		cin>>Width;
		Area=Length*Width;
  }
  else if(choose=='4')
  {
		double Base,Height;
		cout<<"Enter Base:";
		cin>>Base;
		cout<<"Enter Height:";
		cin>>Height;
		Area=Height*Base/2;
  }
  else
  {
		cout<<"Select only 1,2,3,4:";
		goto loop;
  }
  cout<<"Area:"<<Area;
 }

int[] array; //declare empty array variable
array ~= 42; //append 42 to the array; array.equals([ 42 ]) == true
array.length = 5; //set the length to 5; will reallocate if needed
int[] other = new int[5]; // declare an array of five elements
other[] = 18; // fill the array with 18; other.equals([18, 18, 18, 18, 18]) == true
array[] = array[] * other[]; //array[i] becomes array[i] * other[i]
array[$ - 1] = -273; // set the last element to -273; when indexing an array the $ context variable is translated to array.length
int[] s = array[2 .. $]; // s points to the last 3 elements of array (no copying occurs).

string s1 = "Hello "; // array of immutable UTF8 chars
immutable(char)[] s2 = "World "; // `s2` has the same type as `s1`
string s3 = s1 ~ s2; // set `s3` to point to the result of concatenating `s1` with `s2`
char[] s4 = s3.dup; // `s4` points to the mutable array "Hello World "
s4[$-1] = '!'; // change the last character in the string
s4 ~= "<-> Здравей, свят!"; // append Cyrillic characters that don't fit in a single UTF-8 code-unit

import std.conv : to;
wstring ws = s4.to!wstring; //convert s4 to an array of immutable UTF16 chars

foreach (dchar character; ws) // iterate over ws; 'character' is an automatically transcoded UTF32 code-point
{
    import std.stdio : writeln; // scoped selective imports	
    character.writeln(); //write each character on a new line
}

struct Point { uint x; uint y; } // toHash is automatically generated by the compiler, if not user provided
Point[string] table; // hashtable string -> Data
table["Zero"] = Point(0, 0);
table["BottomRight"] = Point(uint.max, uint.max);

const_cast
dynamic_cast
enum
extern
for
goto
inline
namespace
register
reinterpret_cast
return
sizeof
static
static_cast
typedef
typeid
union
unsigned
const_cast
dynamic_cast
namespace
reinterpret_cast
static_cast
typeid
namespace
 1 #include "light.h"
 2 
 3 Light::Light () : on(false) {
 4 }
 5 
 6 void Light::toggle() {
 7   on = (!on);
 8 }
 9 
10 bool Light::isOn() const {
11   return on;
12 }

// Inside sample.h
#ifndef SAMPLE_H
#define SAMPLE_H

// Contents of the header file are placed here.

#endif /* SAMPLE_H */

// Inside light.h
#ifndef LIGHT_H
#define LIGHT_H

// A light which may be on or off.
class Light {
  private:
    bool on;

  public:
    Light ();       // Makes a new light.
    void toggle (); // If light is on, turn it off, if off, turn it on
    bool isOn();    // Is the light on?
};

#endif /* LIGHT_H - comment indicating which if this goes with */

// Example of a single statement
cout << "Hi there!";

cout << "Hi there!";                   // a statement
cout << "Strange things are afoot..."; // another statement

cout << "Hi there!"; cout << "Strange things are afoot...";

Hi there!
Hi there!Strange things are afoot...
cout << "Hi there!";

{ }
// Example of a compound statement
{
  int a = 10;
  int b = 20;
  int result = a + b;
}

if
    fprintf(stdout,"The quick brown fox jumps over the lazy dog. "
                   "The quick brown fox jumps over the lazy dog.\n"
                   "The quick brown fox jumps over the lazy dog - %d", 2);

// Using an indentation size of 2
if ( a > 5 )  { b=a; a++; }

// Using an indentation size of 2
if ( a > 5 )  {
  b = a;
  a++;
}

// Using an indentation size of 4
if ( a > 5 )
{
    b = a;
    a++;
}

if (a > 5) {
  // This is K&R style
}

if (a > 5) 
{
  // This is ANSI C++ style
}

if (a > 5) 
  {
    // This is GNU style
  }

/*void EventLoop(); /**/

/*
void EventLoop();
void EventLoop();
/**/

void EventLoop(); /**/

void EventLoop();
void EventLoop();
/**/

// This is a single one line comment

if (expression) // This needs a comment
{
  statements;   
}
else
{
  statements;
}

/* This is a single line comment */

/*
   This is a multiple line comment
*/

/*
void EventLoop();
void EventLoop();
void EventLoop();
void EventLoop();
void EventLoop();
//*/

//*
void EventLoop();
void EventLoop();
void EventLoop();
void EventLoop();
void EventLoop();
//*/

#if(0)   // Change this to 1 to uncomments.
void EventLoop();
#endif

#if (FEATURE_1 == 1)
do_something;
#endif //FEATURE_1 == 1

inline
inline do_test()
  {
    #if (Feature_1 == 1)
      do_something
    #endif  //FEATURE_1 == 1
  }

do_test();

enum
inline
inline
return
return
typedef
typedef
// C code style
int *z;

// C++ code style
int* z;

// C code style
int *ptrA, *ptrB;

// C++ code style
int* ptrC, ptrD;

// C++ code style
int* ptrC;
int D;

/*
get timepunch algorithm - this algorithm gets a time punch for use later
1. user enters their number and selects "in" or "out"
2. time is retrieved from the computer
3. time punch is assigned to user
*/

GetPunch(user_id, time, punch); //this function gets the time punch

/*
Chris Seedyk
BORD Technologies
29 December 2006
Test
*/
int main()
{
 cout << "Hello world!" << endl; //predefined cout prints stuff in " " to screen
 return 0;
}

// Returns the area of a triangle cast as an int
int area_ftoi(float a, float b) { return (int) a * b / 2; }

int iTriangleArea(float fBase, float fHeight)
{
   return (int) fBase * fHeight / 2;
}

namespace
    namespace name {
    declaration-list;
    }

namespace foo {
  int bar;
}

    namespace {
    declaration-list;
    }

   namespace identifier = namespace-specifier;

using namespace std;

using
namespace
namespace
using
using foo::bar;

bar
namespace
foo::bar
namespace foo {
  int bar;
  double pi;
}

using namespace foo;

int* pi;
pi = &bar;  // ambiguity: pi or foo::pi?

using foo::bar;
foo::bar
pi
foo::pi
using
using
namespace
namespace foo {
  namespace bar {
   double pi;
  }

  using bar::pi;
  // bar::pi can be abbreviated as pi
}

// here, pi is no longer an abbreviation. Instead, foo::bar::pi must be used.

namespace
food::fruit
orange
food::fruit::orange
food::orange
orange
namespace
namespace
namespace
namespace
namespace foo {
  int bar;
}

// ...

namespace foo {
  double pi;
}

namespace
std
namespace
namespace ultra_cool_library_for_image_processing_version_1_0 {
  int foo;
}

namespace improc1 = ultra_cool_library_for_image_processing_version_1_0;
// from here, the above foo can be accessed as improc1::foo

namespace
namespace
namespace
namespace {
  int some_private_variable;
}
// can use some_private_variable here

::
namespace
namespace $$$ {
  // ...
}
using namespace $$$;

$$$
namespace
namespace {

  namespace {
    // ok
  }

}

namespace
// Namespaces Program, an example to illustrate the use of namespaces
#include <iostream>

namespace first {
  int first1;
  int x;
}

namespace second {
  int second1;
  int x;
}

namespace first {
  int first2;
}

int main(){
  //first1 = 1;
  first::first1 = 1;
  using namespace first;
  first1 = 1;
  x = 1;
  second::x = 1;
  using namespace second;

  //x = 1;
  first::x = 1;
  second::x = 1;
  first2 = 1;

  //cout << 'X';
  std::cout << 'X';
  using namespace std;
  cout << 'X';
  return 0;
}

#include <iostream>

std::cout
namespace first {
  int first1;
  int x;
}

namespace second {
  int second1;
  int x;
}

namespace first {
  int first2;
}

namespace
namespace
  main(){
1  //first1 = 1;
2  first::first1 = 1;

namespace
namespace
3  using namespace first;
4  first1 = 1;
5  x = 1;
6  second::x = 1;

namespace
namespace
7  using namespace second;
8  //x = 1;
9  first::x = 1;
10 second::x = 1;

namespace
11 first2 = 1;

namespace
namespace
namespace
namespace
12 //cout << 'X';
13 std::cout << 'X';
14 using namespace std;
15 cout << 'X';
}

namespace
namespace
namespace
namespace
int main()
{
    std::cout << "hello world" << std::endl;
    return 0;
}

1 = string "int"
2 = string "main"
3 = opening parenthesis
4 = closing parenthesis
5 = opening brace
6 = string "std"
7 = namespace operator
8 = string "cout"
9 = << operator
10 = string ""hello world""
11 = string "endl"
12 = semicolon
13 = string "return"
14 = number 0
15 = closing brace

1 2 3 4 5 6 7 8 9 10 9 6 7 11 12 13 14 12 15

int main()
{
    std::cout << "hello world" << std::endl;
    return 0;
}

namespace
namespace
namespace
namespace
return
rpm -ivh gcc-c++-version-release.arch.rpm
dnf install gcc-c++
urpmi gcc-c++
apt-get install g++
 sudo apt-get install g++
zypper in gcc-c++
#include <iostream>
#include "other.h"

<>
" "
#include
iostream
std::cout
algorithm
array^{[c++11 1]}
atomic^{[c++11 1]}
bitset
chrono^{[c++11 1]}
codecvt^{[c++11 1]}
complex
condition_variable^{[c++11 1]}
deque
exception
forward_list^{[c++11 1]}
fstream
functional
future^{[c++11 1]}
initializer_list^{[c++11 1]}
iomanip
ios
iosfwd
iostream
istream
iterator
limits
list
locale
map
memory
mutex^{[c++11 1]}
new
numeric
ostream
queue
random
ratio^{[c++11 1]}
regex^{[c++11 1]}
set
sstream
stack
stdexcept
streambuf
string
strstream
system_error
thread^{[c++11 1]}
tuple^{[c++11 1]}
type_traits^{[c++11 1]}
typeinfo
typeindex^{[c++11 1]}
unordered_map^{[c++11 1]}
unordered_set^{[c++11 1]}
utility
valarray
vector
cassert
ccomplex
cctype
cerrno
cfenv^{[c++11 1]}
cfloat
cinttypes
ciso646
climits
clocale
cmath
csetjmp
csignal
cstdalign^{[c++11 1]}
cstdarg
cstdbool^{[c++11 1]}
cstddef
cstdint
cstdio
cstdlib
cstring
ctgmath^{[c++11 1]}
ctime
cuchar^{[c++11 1]}
cwchar
cwctype
cwstring
std::
.h
<iostream.h>
<iostream>
std::
stdiostream.h^[1]
stream.h^[2]
strstream.h^[3]
#pragma token(s)

#define USER_MAX (1000)

#undef USER_MAX

#define MULTIPLELINEMACRO \
        will use what you write here \
        and here etc...
#define MULTIPLELINEMACRO will use what you write here and here etc...

int ma\
in//ma/
()/*ma/
in/*/{}

#define ABSOLUTE_VALUE( x ) ( ((x) < 0) ? -(x) : (x) )
// ...
int x = -1;
while( ABSOLUTE_VALUE( x ) ) {
// ...
}

int z = -10;
int y = ABSOLUTE_VALUE( z++ );

// ABSOLUTE_VALUE( z++ ); expanded
( ((z++) < 0 ) ? -(z++) : (z++) );

// An example on how to use a macro correctly

#include <iostream>

#define SLICES 8
#define PART(x) ( (x) / SLICES ) // Note the extra parentheses around '''x'''

int main() {
   int b = 10, c = 6;

   int a = PART(b + c);
   std::cout << a;

   return 0;
}

#define
#define as_string( s ) # s
std::cout << as_string( Hello  World! ) << std::endl;
std::cout << "Hello World!" << std::endl;
#define concatenate( x, y ) x ## y
...
int xy = 10;
...
std::cout << concatenate( x, y ) << std::endl;
std::cout << xy << std::endl;
10
#define MAX(a,b) a>b?a:b

i = MAX(2,3)+5;
j = MAX(3,2)+5;

int i = 2>3?2:3+5;
int j = 3>2?3:2+5;

i=8
j=3
i=j=8
a,b
a,b
#define MAX(a,b) ((a)>(b)?(a):(b))

a,b

 i = 2;
 j = 3;
 k = MAX(i++, j++);

k=4
i=3
j=5
MAX()
inline int max(int a, int b) { return a>b?a:b }

template<typename T> inline max(const T& a, const T& b) { return a>b?a:b }

std::max(3,4);
MAX("hello","world")

std::cout << "Hello " "World!\n";

std::cout << "Hello World!\n";

 function_name("This is a very long string literal, which would not fit "
               "onto a single line very nicely -- but with string literal "
               "concatenation, we can split it across multiple lines and "
               "the preprocessor will glue the pieces together");
 L"this " L"and " L"that"
 L"this and that".
#if condition
  statement(s)
#elif condition2
  statement(s)
...
#elif condition
  statement(s)
#else
  statement(s)
#endif

#ifdef defined-value
  statement(s)
#else
  statement(s)
#endif

#ifndef defined-value
  statement(s)
#else
  statement(s)
#endif
 #if defined(__BSD__) || defined(__LINUX__)
 #include <unistd.h>
 #endif

 #ifndef FOO_HPP
 #define FOO_HPP

  // code here...

 #endif // FOO_HPP

 #include "foo.h"

  // code here...

 #include "foo.hpp"
 #include "bar.hpp"

  // code here

 #warning message
 #error message

 #if defined(__BSD___)
 #warning Support for BSD is new and may not be stable yet
 #endif

 #if defined(__WIN95__)
 #error Windows 95 is not supported
 #endif

static
extern
static int apples = 15;

apples
static int bananas;

bananas
int g_fruit;

g_fruit
static const int muffins_per_pan=12;

muffins_per_pan
const int hours_per_day=24;

hours_per_day
static const int hours_per_day=24;

static void f();

f
static void f(){;}

f()
extern
extern int i;

i of type int
extern int j = 0;

j
extern void f();

f
extern void f() {;}

f()
extern const int k = 1;

int k
1
extern
const
unsigned
unsigned
unsigned
unsigned
unsigned
unsigned
unsigned
unsigned
unsigned
unsigned
unsigned
unsigned
unsigned
unsigned
unsigned
namespace
{
  int i; /*'i' is now in scope */
  i = 5;
  i = i + 1;
  cout << i;
}/* 'i' is now no longer in scope */

// Example of a compound statement defining a local scope
{

  {
    int i = 10; //inside a statement block
  }

 i = 2; //error, variable does not exist outside of the above compound statement 
}

namespace
"Hello, Wikipedia"/1
char
char
signed char
char
char
unsigned
char
char
char
short
char
int
short int
signed short
signed short int
unsigned
short
short
int
unsigned
short int
int
short
signed
signed int
unsigned
int
int
unsigned
long
int
long int
signed long
signed long int
unsigned
long
long
unsigned
long int
bool
char
long
true
false
wchar_t
char
long
char
wchar_t
int
unsigned
int
float
char
unsigned
double
float
unsigned
long double
double
unsigned
struct
class
struct
public
class
private
struct
union
public
enum
char
int
int
enum
enum
typedef
static
register
extern
template
char
type&
char
type*
char
0
0
type [integer]
integer
type
[]
type []
type*
type (comma-delimited list of types/declarations)
()
int (* fptr) (int arg1, int arg2)
extern
type aggregate_type::*
char
0
[]
()
&
*
::*
bool
int
char
float
double
float
double
inline
    int an_integer;                                 // defines an_integer
    extern const int a = 1;                         // defines a
    int function( int b ) { return b+an_integer; }  // defines function and defines b
    struct a_struct { int a; int b; };              // defines a_struct, a_struct::a, and a_struct::b
    struct another_struct {                         // defines another_struct
      int a;                                        // defines nonstatic data member a
      static int b;                                 // declares static data member b
      another_struct(): a(0) { } };                 // defines a constructor of another_struct
    int another_struct::b = 1;                      // defines another_struct::b
    enum { right, left };                           // defines right and left 
    namespace FirstNamespace { int a; }             // defines FirstNamespace  and FirstNamespace::a
    namespace NextNamespace = FirstNamespace ;      // defines NextNamespace 
    another_struct MySruct;                         // defines MySruct
    extern int b;                                   // declares b
    extern const int c;                             // declares c
    int another_function( int );                    // declares another_function
    struct aStruct;                                 // declares aStruct
    typedef int MyInt;                              // declares MyInt
    extern another_struct yet_another_struct;       // declares yet_another_struct
    using NextNamespace::a;                         // declares NextNamespace::a

[specifier(s)] type variable_name [ = initial_value];
int sum;

sum
int
sum
char firstLetter; 
char lastLetter; 
int hour, minute;

int a = 123;
int b (456);

iostream
int sum;
sum = a + b;

int sum = a + b;

int sum (a + b);

float f = 1.5 ;

double a = 5 / 2;

double a = 5.0 / 2.0;

double a = 5e-2;

// This program adds two numbers and prints their sum.
#include <iostream>

int main()
{
  int a;
  int b;
  int sum;

  sum = a + b;

  std::cout << "The sum of " << a << " and " << b << " is " << sum << "\n";

  return 0;
}

// This program adds two numbers and prints their sum, variation 1
#include <iostream>
#include <ostream>

using namespace std;

int main()
{
  int a = 123, b (456), sum = a + b;

  cout << "The sum of " << a << " and " << b << " is " << sum << endl;

  return 0;
}

register
register int x=99;

const
const
const
const unsigned int DAYS_IN_WEEK = 7 ;

DAYS_IN_WEEK
int main(){
  const int i = 10;

  i = 3;            // ERROR - we can't change "i"

  int &j = i;       // ERROR - we promised not to
                    // change "i" so we can't
                    // create a non-const reference
                    // to it

  const int &x = i; // fine - "x" is a const
                    // reference to "i"

  return 0;
}

const
const
const
#define
T const *p;                     // p is a pointer to a const T
T *const p;                     // p is a const pointer to T
T const *const p;               // p is a const pointer to a const T

const
const T *p;

T const *p;

volatile
volatile
mutable volatile
class image {
 public:
   // construct an image by loading from disk
   image(const char* const filename); 

   // get the image data
   char const * data() const;
 private:
   // The image data
   char* m_data;
}

class scrolling_images {
   image const* images[1000];
};

class image_proxy {
  public:
   image_proxy( char const * const filename )
      : m_filename( filename ),
        m_image( 0 ) 
   {}
   ~image_proxy() { delete m_image; }
   char const * data() const {
      if ( !m_image ) {
         m_image = new image( m_filename );
      }
      return m_image->data();
   }
  private:
   char const* m_filename;
   mutable image* m_image;
};

class scrolling_images {
   image_proxy const* images[1000];
};

data()
m_image
data()
m_image
image_proxy::data()
m_image
short
int
short int
int
short
int
short a;

short int a;

long
int
double
long int
int
long double
long
int
long a;

long int a;

int
long
int
long int
unsigned
signed
char
int
long
signed
int
long
static
static
void foo() {
  static int counter = 0;
  cout << "foo has been called " << ++counter << " times\n";
}

int main() {
  for( int i = 0; i < 10; ++i ) foo();
}

const int Clubs=0;
const int Diamonds=1;
const int Hearts=2;
const int Spades=3;

int current_card_suit=Diamonds;

int current_card_suit=1;

current_card_suit=11;

enum
    enum name {name-list} var-list;

enum card_suit {Clubs,Diamonds,Hearts,Spades};
card_suit first_cards_suit=Diamonds;
card_suit second_cards_suit=Hearts;
card_suit third_cards_suit=0; //Would cause an error, 0 is an "integer" not a "card_suit" 
card_suit forth_cards_suit=first_cards_suit; //OK, they both have the same type.

enum new_type_name { possible_value_1,
                     possible_value_1,
                     /* ..., */
                     possible_value_n
} Optional_Variable_With_This_Type;

enum apples { Fuji, Macintosh, GrannySmith };
enum oranges { Blood, Navel, Persian };
apples pie_filling = Navel; //error can't make an apple pie with oranges.
apples my_fav_apple = Macintosh;
oranges my_fav_orange = Navel; //This has the same internal integer value as my_favorite_apple

//Many compilers will produce an error or warning letting you know your comparing two different quantities.
if(my_fav_apple == my_fav_orange) 
  std::cout << "You shouldn't compare apples and oranges" << std::endl;

enum color {Red, Green, Blue};
color hair=Red;
color eyes=Blue;
color skin=Green;
std::cout << "My hair color is " << hair << std::endl;
std::cout << "My eye color is " << eyes << std::endl;
std::cout << "My skin color is " << skin << std::endl;
if (skin==Green)
  std::cout << "I am seasick!" << std::endl;

My hair color is 0
My eye color is 2
My skin color is 1
I am seasick!

std::string color_names[3]={"Red", "Green", "Blue"};
enum color {Red, Green, Blue};
color hair=Red;
color eyes=Blue;
color skin=Green;
std::cout << "My hair color is " << color_names[hair] << std::endl;
std::cout << "My eye color is " << color_names[eyes] << std::endl;
std::cout << "My skin color is " << color_names[skin] << std::endl;

enum color {Red=2, Green=4, Blue=6};

enum colour {Red=2, Green, Blue=6, Orange};

enum screen_width {SMALL=800, MEDIUM=1280};
enum screen_height {SMALL=600, MEDIUM=768};
screen_width MyScreenW=SMALL;
screen_height MyScreenH=SMALL;
std::cout << "The number of pixels on my screen is " << MyScreenW*MyScreenH << std::endl;

enum month { JANUARY=1, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER};

for( month cur_month = JANUARY; cur_month <= DECEMBER; cur_month=cur_month+1)
{
  std::cout << cur_month << std::endl;
}

for
for
for( int monthcount = JANUARY; monthcount <= DECEMBER; monthcount++)
{
  std::cout << monthcount  << std::endl;
}

typedef
   typedef existing-type new-alias;
 typedef int Apples;
 typedef int Oranges;
 Apples coxes;
 Oranges jaffa;

 typedef char (*pa)[3]; // "pa" is now a type for a pointer to an array of 3 chars
 typedef int (*pf)(float); // "pf" is now a type for a pointer to a function which
                           // takes 1 float argument and returns an int

double  d;
long    l;
int     i; 

if (d > i)      d = i;
if (i > l)      l = i;
if (d == l)     d *= 2;

double d = 1.0;

printf ("%d\n", (int)d);

sizeof
new
delete
std::cout << 17 * 3;

std::cout << hour * 60 + minute << std::endl;

int percentage; 
percentage = ( minute * 100 ) / 60;

 minute+1 = hour;

std::cout << "The sum of " << a << " and " << b << " is " << sum << "\n";

std::cout
"The sum of "
std::cout << a
a
std::cout
std::cout << " and "
std::cout << b
std::cout << " is "
std::cout << " sum "
std::cout << "\n"
::
::NUM_ELEMENTS
::
namespace
std::cout
()
swap (x, y)
[]
arr [i]
.
obj.member
->
ptr->member
++ --
num++
typeid()
typeid (std::cout)
typeid (std::iostream)
static_cast
<>()
dynamic_cast
<>()
const_cast
<>()
reinterpret_cast
<>()
static_cast
<float> (i)
dynamic_cast<std::istream> (stream)
const_cast
<char*> ("Hello, World!")
reinterpret_cast
<const long*> ("C++")
type()
static_cast
float (i)
std::string ("Hello, world!", 0, 5)
!
!eof_reached
~
~mask
+ -
-num
++ --
++num
&
&data
*
*ptr
new
new[]
new()
new()[]
new std::string (5, '*')
new int [100]
new (raw_mem) int
new (arg1, arg2) int [100]
delete
delete[]
delete ptr
delete[] arr
sizeof
sizeof()
sizeof
sizeof
sizeof
(type)
(float)i
.*
obj.*memptr
->*
ptr->*memptr
* / %
celsius_diff * 9 / 5
+ -
end - start + 1
<<
>>
bits << shift_len
bits >> shift_len
< > <= >=
i < num_elements
== !=
choice != 'n'
&
bits & clear_mask_complement
^
bits ^ invert_mask
|
bits | set_mask
&&
arr != 0 && arr->len != 0
||
arr == 0 || arr->len == 0
?:
size >= 0 ? size : 0
=
i = 0
+= -= *= /= %=
&=
^=
<<= >>=
foo op= bar
foo = foo op bar
num /= 10
throw
throw "Array index out of bounds"
,
i = 0, j = i + 1, k = 0
x = 3
x
y = x
x
y
//Example to demonstrate default "=" operator behavior.

struct A
 {
  int i;
  float f;
  A * next_a;
 };

//Inside some function
 {
  A a1, a2;              // Create two A objects.

  a1.i = 3;              // Assign 3 to i of a1.
  a1.f = 4.5;            // Assign the value of 4.5 to f in a1
  a1.next_a = &a2;       // a1.next_a now points to a2

  a2.next_a = NULL;      // a2.next_a is guaranteed to point at nothing now.
  a2.i = a1.i;           // Copy over a1.i, so that a2.i is now 3.
  a1.next_a = a2.next_a; // Now a1.next_a is NULL

  a2 = a1;               // Copy a1 to a2, so that now a2.f is 4.5. The other two are unchanged, since they were the same.
 }

z
y
=
x
x = y = z;

class A { /* ... */ };
A foo () { /* ... */ };

// In some function
 {
  A a;
  a = foo();

  A a2 = foo();
 }

a
a2
foo()
foo()
a2
#include<iostream>

using namespace std;
int main()
{
    int a = 3, b = 5;
    cout << a << '+' << b << '=' << (a+b);
    return 0;
}

+
a
b
a
b
+
a + b
+
int hour, minute; 
hour = 11; 
minute = 59; 
std::cout << "Number of minutes since midnight: "; 
std::cout << hour*60 + minute << std::endl; 
std::cout << "Fraction of the hour that has passed: "; 
std::cout << minute/60 << std::endl;

Number of minutes since midnight: 719
Fraction of the hour that has passed: 0
std::cout << "Percentage of the hour that has passed: "; 
std::cout << minute*100/60 << std::endl;

Percentage of the hour that has passed: 98
#include<iostream>

using namespace std;
int main()
{
    int a = 33, b = 5;
    cout << "Quotient = " << a / b << endl;
    cout << "Remainder = "<< a % b << endl;
    return 0;
}

Quotient = 6
Remainder = 3
*
/
%
+
-
(
)
deg_f = deg_c * 9 / 5 + 32;
deg_c = ( deg_f - 32 ) * 5 / 9;

a = a + 1;
b = b * 2;
c = c / 4;

a += 1;  // Equivalent to (a = a + 1)
b *= 2;  // Equivalent to (b = b * 2)
c /= 4;  // Equivalent to (c = c / 4)

char letter; 
letter = 'a' + 1; 
std::cout << letter << std::endl;

int number; 
number = 'a'; 
std::cout << number << std::endl;

*
&
[]
->
.*
->*
const
operator new[]
int numbers[30]; // creates an array of 30 integers

char letters[4]; // create an array of 4 characters

int vector[6]={0,0,1,0,0,0};

int vector[6]={0,0,1}; // this is the same as the example above

int vector[]={0,0,1,0,0,0};  // the compiler can see that there are 6 elements

List[2] = 200;

std::cout << List[2] << std::endl;

int x;
x = vector[2];

x
vector
vector[0]
char y;
int z = 9;
char vector[6] = { 1, 2, 3, 4, 5, 6 };

// examples of accessing outside the array. A compile error is not raised
y = vector[15];
y = vector[-4];
y = vector[z];

vector[-1]
sizeof
int ix;
short anArray[]= { 3, 6, 9, 12, 15 };

for (ix=0; ix< (sizeof(anArray)/sizeof(short)); ++ix) {
  DoSomethingWith( anArray[ix] );
}

sizeof
for
char two_d[3][5];

char ch;
ch = two_d[2][4];

two_d[0][0] = 'x';

int a[100];
int i = 0;
if (a[i]==i[a])
  printf("Hello World!\n");

a[i]
i[a]
array
realloc
malloc
memcpy
std::vector
at()
&
&sometype
sometype
int tZoo = 3;       // tZoo == 3
int &refZoo = tZoo; // tZoo == 3
refZoo = 5;         // tZoo == 5

refZoo
tZoo
refZoo
tZoo
void swap(int &a, int &b){
  int temp = a; 
  a = b; 
  b = temp;
}

int main(){
   int x = 5; 
   int y = 6; 
   int &refx = x; 
   int &refy = y; 
   swap(refx, refy); // now x = 6 and y = 5
   swap(x, y); // and now x = 5 and y = 6 again
}

int main(){
   int x = 5;
   int y = 6;
   int &refx = x;
   &refx = y; // won't compile
}

*
int* x;  // pointer to int.
int * y; // pointer to int. (legal, but rarely used)
int *z;  // pointer to int.
int*i;   // pointer to int. (legal, but rarely used)

int* i, j;  // CAUTION! i is pointer to int, j is int.
int *i, *j; // i and j are both pointer to int.

int **i;  // Pointer to pointer to int.
int ***i; // Pointer to pointer to pointer to int (rarely used).

double vValue = 25.0;// declares and initializes a vValue as type double
double* pValue = &vValue;
cout << *pValue << endl;

char pArray[20] = {"Name1"};
char* pValue(pArray);// or 0 in old compilers, nullptr is a part of C++0X
pValue = "Value1";
cout << pValue  << endl ;// this will return the Value1;

char* pValue("String1");
pValue = "String2";
cout << pValue << endl ;

*
#include <iostream>

int main()
{
  int i;
  int * p = &i;
  i = 3;

  std::cout<<*p<<std::endl; // prints "3"

  return 0;
}

&
*&i
*
.
struct A { int num; };

A a;
int i;
A * p;

p = &a;
a.num = 2;

i = *p.num; // Error! "p" isn't a class, so you can't use "."
i = (*p).num;

(*p).num
(*(*(*(*MyPointer).Member).SubMember).Value).WhatIWant
->
(*p).num
p->num
MyPointer->Member->SubMember->Value->WhatIWant
*
->
int i;
int *p;

p = 0; //Null pointer.
p = &i; //Not the null pointer.

int i = 0;
int *p = i; //Error: 0 only evaluates to null if it's a pointer

NULL
#include <iostream>

void IsNull (int * p)
{
  if (p)
    std::cout<<"Pointer is not NULL"<<std::endl;
  else
    std::cout<<"Pointer is NULL"<<std::endl;
}

int main()
{
  int * p;
  int i;

  p = NULL;
  IsNull(p);
  p = &i;
  IsNull(&i);
  IsNull(p);
  IsNull(NULL);

  return 0;
}

double (*pDVal)[2] = {{1,2},{1,2}};

double ArrayVal[5][5] = {
{1,2,3,4,5},
{1,2,3,4,5},
{1,2,3,4,5},
{1,2,3,4,5},
{1,2,3,4,5},
};

double(*pArray)[5] = ArrayVal;
*(*(pArray+0)+0) = 10;
*(*(pArray+0)+1) = 20;
*(*(pArray+0)+2) = 30;
*(*(pArray+0)+3) = 40;
*(*(pArray+0)+4) = 50;
*(*(pArray+1)+0) = 60;
*(*(pArray+1)+1) = 70;
*(*(pArray+1)+2) = 80;
*(*(pArray+1)+3) = 90;
*(*(pArray+1)+4) = 100;
*(*(pArray+2)+0) = 110;
*(*(pArray+2)+1) = 120;
*(*(pArray+2)+2) = 130;
*(*(pArray+2)+3) = 140;
*(*(pArray+2)+4) = 150;
*(*(pArray+3)+0) = 160;
*(*(pArray+3)+1) = 170;
*(*(pArray+3)+2) = 180;
*(*(pArray+3)+3) = 190;
*(*(pArray+3)+4) = 200;
*(*(pArray+4)+0) = 210;
*(*(pArray+4)+1) = 220;
*(*(pArray+4)+2) = 230;
*(*(pArray+4)+3) = 240;
*(*(pArray+4)+4) = 250;

*(*(pArray+0)+0)

*(pArray[0]+0)

char* pVar[5] = { "Name1" , "Name2" , "Name3", "Name4", "Name5" }

pVar[0] = "XName01";
cout << pVar[0] << endl ; //this will return the XName01 instead Name1 which was replaced with Name1.

double* pVal = new double[5];
//or double* pVal = new double; // this line leaves out the necessary memory allocation
*(pVal+0) = 10;
*(pVal+1) = 20;
*(pVal+2) = 30;
*(pVal+3) = 40;
*(pVal+4) = 50;

cout << *(pVal+0) << endl;

char* pVal = new char;
pVal = "Name1";
cout << pVal << endl;
delete pVal; //this will delete the allocated space
pVal = nullptr //null the pointer

char* pVal("Name1");

double (*pVal2)[2]= new double[2][2]; //this will add 2x2 memory blocks to type double pointer
*(*(pVal2+0)+0) = 10;
*(*(pVal2+0)+1) = 10;
*(*(pVal2+0)+2) = 10;
*(*(pVal2+0)+3) = 10;
*(*(pVal2+0)+4) = 10;
*(*(pVal2+1)+0) = 10;
*(*(pVal2+1)+1) = 10;
*(*(pVal2+1)+2) = 10;
*(*(pVal2+1)+3) = 10;
*(*(pVal2+1)+4) = 10;

delete [] pVal; //the dimension does not matter; you only need to mention []
pVal = nullptr

sizeof
//Examples of sizeof use
int int_size( sizeof( int ) );// Might give 1, 2, 4, 8 or other values.

// or

int answer( 42 );
int answer_size( sizeof( answer ) );// Same value as sizeof( int )
int answer_size( sizeof answer);    // Equivalent syntax

    struct EmployeeRecord {
      int ID;
      int age;
      double salary;
      EmployeeRecord* boss;
    };

    //...

    cout << "sizeof(int): " << sizeof(int) << endl
         << "sizeof(float): " << sizeof(float) << endl
         << "sizeof(double): " << sizeof(double) << endl
         << "sizeof(char): " << sizeof(char) << endl
         << "sizeof(EmployeeRecord): " << sizeof(EmployeeRecord) << endl;

    int i;
    float f;
    double d;
    char c;
    EmployeeRecord er;

    cout << "sizeof(i): " << sizeof(i) << endl
         << "sizeof(f): " << sizeof(f) << endl
         << "sizeof(d): " << sizeof(d) << endl
         << "sizeof(c): " << sizeof(c) << endl
         << "sizeof(er): " << sizeof(er) << endl;

    sizeof(int): 4
    sizeof(float): 4
    sizeof(double): 8
    sizeof(char): 1
    sizeof(EmployeeRecord): 20
    sizeof(i): 4
    sizeof(f): 4
    sizeof(d): 8
    sizeof(c): 1
    sizeof(er): 20

    #include <cstdio>

    short func( short x )
    {
      printf( "%d", x );
      return x;
    }

    int main()
    {
      printf( "%d", sizeof( sizeof( func(256) ) ) );
    }

std::strlen
std::string::length
int n = 10; 
SOMETYPE *parray, *pS; 
int *pint; 

parray = new SOMETYPE[n]; 
pS = new SOMETYPE; 
pint = new int;

delete [] parray;// note the use of [] when destroying an array allocated with new
delete pint;

new T
new T()
T
// Example of a dynamic array

const int b = 5;
int *a = new int[b];

//to delete
delete[] a;

const int b = 5;
std::vector<int> a;
a.resize(b);

//to delete
a.clear();

int new_number = 99;
a.push_back( new_number );//expands the vector to fit the 6th element

const int d = 5;
int (*two_d_array)[4] = new int[d][4];

//to delete
delete[] two_d_array;

const int d1 = 5, d2 = 4;
int **two_d_array = new int*[d1];
for( int i = 0; i < d1; ++i)
  two_d_array[i] = new int[d2];

//to delete
for( int i = 0; i < d1; ++i)
  delete[] two_d_array[i];

delete[] two_d_array;

and
or
and
or
and
or
and
or
not
condition1 and condition2
condition1 or condition2
not condition
if ((x > 5) and not (x == 10)) // if (x greater than 5) and ( not (x equal to 10) ) 
{
  //...code...
}

if (x > 10 and x < 20) // if x greater than 10 and x less than 20
{
  //....code...
}

if (x == 5 or x == 10 or x < 2) // if x equal to 5 or x equal to 10 or x less than 2
{
  //...code...
}

if ((x >= 10 and x <= 20) or (x >= 30 and x <= 40)) // >= -> greater or equal etc...
{
  //...code...
}

x > 10
x < 20
<
and
x
x
x
x
if ((var1 > var2) and (var2 > var3))
{
  std::cout << var1 " is bigger than " << var2 << " and " << var3 << std::endl;
}

if ((var1 > var2) or (var1 > var3))
{
  std::cout << var1 " is either bigger than " << var2 << " or " << var3 << std::endl;
}

not x > 10

 condition-expression ? expression-if-true : expression-if-false
int foo = 8;
std::cout << "foo is " << (foo < 10 ? "smaller than" : "greater than or equal to") << " 10." << std::endl;
int a = 5.6;
float b = 7;

// promoting short to int
short left = 12;
short right = 23;

short total = left + right;

void do_something(short arg)
{
    cout << "Doing something with a short" << endl;
}

void do_something(int arg)
{
    cout << "Doing something with an int" << endl;
}

int main(int argc, char **argv)
{
    short val = 12;

    do_something(val); // Prints "Doing something with a short"
    do_something(val * val); // Prints "Doing something with an int"
}

double a = 12.5;
int b = a;

cout << b; // Prints "12"

static_cast<target type>(expression)

int a = static_cast<int>(7.5);

static_cast
static_cast
    TYPE static_cast<TYPE> (object);

BaseClass* a = new DerivedClass();
static_cast<DerivedClass*>(a)->derivedClassMethod();

float a = 5 / 2;

float a = static_cast<float>(5) / static_cast<float>(2);

float a = 5f / 2f;

const_cast
    TYPE* const_cast<TYPE*> (object);
    TYPE& const_cast<TYPE&> (object);

class Foo {
public:
  void func() {} // a non-const member function
};

void someFunction( const Foo& f )  {
  f.func();      // compile error: cannot call a non-const 
                 // function on a const reference 
  Foo &fRef = const_cast<Foo&>(f);
  fRef.func();   // okay
}

dynamic_cast
static_cast
    TYPE& dynamic_cast<TYPE&> (object);
    TYPE* dynamic_cast<TYPE*> (object);

  struct A {
    virtual void f() { }
  };
  struct B : public A { };
  struct C { };

  void f () {
    A a;
    B b;

    A* ap = &b;
    B* b1 = dynamic_cast<B*> (&a);  // NULL, because 'a' is not a 'B'
    B* b2 = dynamic_cast<B*> (ap);  // 'b'
    C* c = dynamic_cast<C*> (ap);   // NULL.

    A& ar = dynamic_cast<A&> (*ap); // Ok.
    B& br = dynamic_cast<B&> (*ap); // Ok.
    C& cr = dynamic_cast<C&> (*ap); // std::bad_cast
  }

reinterpret_cast
    TYPE reinterpret_cast<TYPE> (object);

int a = 0xffe38024;
int* b = reinterpret_cast<int*>(a);

type(expression)
(type)expression
(type)expression
int i = 10;
long l;

l = (long)i; //C programming style cast
l = long(i); //C programming style cast in functional form (preferred by some C++ programmers) 
             //note: initializes a new long to i, this is not an explicit cast as in the example above
             //however an implicit cast does occur. i = long((long)i);

const char string[]="1234";
function( (unsigned char*) string ); //remove const, add unsigned

dynamic_cast
goto
label:
  statement(s);

goto label;

for (int i = 0; i < 30; ++i) {
  for (int j = 0; j < 30; ++j) {
    if (a[i][j] != 0) {
       a[i][j] = 0;
       goto done;
     }
  }
}
done:
/* rest of program */

// snarled mess of gotos

int i = 0;
  goto test_it;
body:
  a[i++] = 0;
test_it:
  if (a[i]) 
    goto body;
/* rest of program */

for (int i = 0; a[i]; ++i) {
  a[i] = 0;
}
/* rest of program */

#include <new>
#include <iostream>

...

int *my_allocated_1 = NULL;
char *my_allocated_2 = NULL, *my_allocated_3 = NULL;
my_allocated_1 = new (std::nothrow) int[500];

if (my_allocated_1 == NULL)
{  
  std::cerr << "error in allocated_1" << std::endl;
  goto error;
}

my_allocated_2 = new (std::nothrow) char[1000];

if (my_allocated_2 == NULL)
{  
  std::cerr << "error in allocated_2" << std::endl;
  goto error;
}

my_allocated_3 = new (std::nothrow) char[1000];

if (my_allocated_3 == NULL)
{  
  std::cerr << "error in allocated_3" <<std::endl;
  goto error;
}
return 0;

error:
  delete [] my_allocated_1;
  delete [] my_allocated_2;
  delete [] my_allocated_3;
  return 1;

if (condition)
{
  statement;
}

if(condition)
{
  int x; // Valid code
  for(x = 0; x < 10; ++x) // Also valid.
    {
      statement;
    }
}

if (user_age < 18)
{
    std::cout << "People under the age of 18 are not allowed." << std::endl;
}
else
{
    std::cout << "Welcome to Caesar's Casino!" << std::endl;
}

if (user_age < 18)
{
  std::cout << "People under the age of 18 are not allowed." << std::endl;
}
else if (user_age > 64)
{
  std::cout << "Welcome to Caesar's Casino! Senior Citizens get 50% off." << std::endl;
}
else
{
  std::cout << "Welcome to Caesar's Casino!" << std::endl;
}

switch (integer expression) {
    case label1:
         statement(s)
         break;
    case label2:
         statement(s)
         break;
    /* ... */
    default:
         statement(s)
}
 char ch = cin.get(); //get the character
 switch (ch) {
     case '0': 
          // do nothing fall into case 1
     case '1': 
         // do nothing fall into case 2
     case '2': 
        // do nothing fall into case 3
     /* ... */
     case '8': 
        // do nothing fall into case 9
     case '9':  
          std::cout << "Digit" << endl; //print into stream out
          break;
     default:
          std::cout << "Non digit" << endl; //print into stream out
 }

// as we will see, these are infinite loops...
while (1) { }

// or

for (;;) { }

while (''condition'') ''statement''; ''statement2'';

#include <iostream>
using namespace std;

int main() 
{
  int i=0;
  while (i<10) {
    cout << "The value of i is " << i << endl;
    i++;
  }
  cout << "The final value of i is : " << i << endl;
  return 0;
}

 The value of i is 0
 The value of i is 1
 The value of i is 2
 The value of i is 3
 The value of i is 4
 The value of i is 5
 The value of i is 6
 The value of i is 7
 The value of i is 8
 The value of i is 9
 The final value of i is 10
// validation of an input
#include <iostream>
using namespace std;

int main() 
{
  int a;
  bool ok=false;
  while (!ok) {
    cout << "Type an integer from 0 to 20 : ";
    cin >> a;
    ok = ((a>=0) && (a<=20));
    if (!ok) cout << "ERROR - ";
  }
  return 0;
}

 Type an integer from 0 to 20 : 30
 ERROR - Type an integer from 0 to 20 : 40
 ERROR - Type an integer from 0 to 20 : -6
 ERROR - Type an integer from 0 to 20 : 14
do {
  statement(s)
} while (condition);

statement2;

#include <iostream>

using namespace std;

int main() 
{
  int i=0;

  do {
    cout << "The value of i is " << i << endl;
    i++;
  } while (i<10);

  cout << "The final value of i is : " << i << endl;
  return 0;
}

The value of i is 0
The value of i is 1
The value of i is 2
The value of i is 3
The value of i is 4
The value of i is 5
The value of i is 6
The value of i is 7
The value of i is 8
The value of i is 9
The final value of i is 10
for
for (initialization ; condition; step-expression)
  statement(s);

 initialization
 while( condition )
 {
   statement(s);
   step-expression;
 }

// a unbounded loop structure
for (;;)
{
  statement(s);
  if( statement(s) )
    break;
}

// calls doSomethingWith() for 0,1,2,..9
for (int i = 0; i != 10; ++i)
{                  
  doSomethingWith(i); 
}

// calls doSomethingWith() for 0,1,2,..9
int i = 0;
while(i != 10)
{
  doSomethingWith(i);
  ++i;
}

for (variable-declaration : range-expression)
  statement(s);

std::string s = "Hello, world";
for (char c : s) 
{
  std::cout << c << ' ';
}

H e l l o ,   w o r l d
int main()
{
  // code
  return 0;
}

inline
inline swap( int& a, int& b) { int const tmp(b); b=a; a=tmp; }

struct length
{
  explicit length(int metres) : m_metres(metres) {}
  operator int&() { return m_metres; }
  private:
  int m_metres;
};

inline
inline
inline
inline
//Global functions declaration
int subtraction_function( int parameter1, int parameter2 ) { return ( parameter1 - parameter2 ); }

//Call to the above function using 2 extra variables so the relation becomes more evident
int argument1 = 4;
int argument2 = 3; 
int result = subtraction_function( argument1, argument2 );
// will have the same result as
int result = subtraction_function( 4, 3 );

//Global functions with no parameters
void function() { /*...*/ }
//empty parameter declaration equivalent the use of void
void function( void ) { /*...*/ }

// Example - function using two int parameters by value
void printTime (int hour, int minute) { 
  std::cout << hour; 
  std::cout << ":"; 
  std::cout << minute; 
}

int main ( void ) {
    int hour = 11; 
    int minute = 59; 
    printTime( int hour, int minute ); // WRONG!
    printTime( hour, minute ); // Right!
}

#include <iostream>

void MyFunc( int *x ) 
{ 
  std::cout << *x << std::endl; // See next section for explanation
} 

int main() 
{ 
  int i; 
  MyFunc( &i ); 

  return 0; 
}

#include <iostream>

void ComparePointers (int * a, int * b)
{
  if (a == b)
    std::cout<<"Pointers are the same!"<<std::endl;
  else
    std::cout<<"Pointers are different!"<<std::endl;
}

int main()
{
  int i, j;
  int& r = i;

  ComparePointers(&i, &i);
  ComparePointers(&i, &j);
  ComparePointers(&i, &r);
  ComparePointers(&j, &r);

  return 0;
}

int my_array[5];

my_array
my_array[2]
my_array[2]
my_array
my_array
my_array[2]
#include <iostream>

void printInt(int printable){
  std::cout << "The int you passed in has value " << printable << std::endl;
}
int main(){
  int my_array[5];

  // Reminder: always initialize your array values!
  for(int i = 0; i < 5; i++)
    my_array[i] = i * 2;

  for(int i = 0; i < 5; i++)
    printInt(my_array[i]); // <-- We pass in a dereferenced array element
}

The int you passed in has value 0
The int you passed in has value 2
The int you passed in has value 4
The int you passed in has value 6
The int you passed in has value 8
my_array[2]
#include <iostream>

void printIntArr(int *array_arg, int array_len){
  std::cout << "The length of the array is " << array_len << std::endl;
  for(int i = 0; i < array_len; i++)
    std::cout << "Array[" << i << "] = " << array_arg[i] << std::endl;
}

int main(){
  int my_array[5];

  // Reminder: always initialize your array values!
  for(int i = 0; i < 5; i++)
    my_array[i] = i * 2;

  printIntArr(my_array, 5);
}

The length of the array is 5
Array[0] = 0
Array[1] = 2
Array[2] = 4
Array[3] = 6
Array[4] = 8
my_array
array_arg
my_array
array_arg
array_arg
array_arg
my_array
void foo( int &i )
{
  ++i;
}

int main()
{
  int bar = 5;   // bar == 5
  foo( bar );    // increments bar
  std::cout << bar << std::endl   // 6

  return 0;
}

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

int i = 7; 
int j = 9; 
swap (i, j); 
cout << i << ' ' << j << endl;

int i = 7; 
int j = 9; 
swap (i, j+1); // WRONG!!

j+1
void foo( const std::string & s ) // const reference, explained below
{
  std::cout << s << std::endl;
}

void bar( std::string s )
{
  std::cout << s << std::endl;
}

int main()
{
  std::string const text = "This is a test.";

  foo( text ); // doesn't make a copy of "text"
  bar( text ); // makes a copy of "text"

  return 0;
}

text
void func(int(&para)[4]);

template<int n>void func(int(&para)[n]);

// WRONG
void foo(int**matrix,int n,int m);
int main(){
	int data[10][5];
	// do something on data
	foo(data,10,5);
}

// BAD
void foo(int(*matrix)[5],int n,int m);
int main(){
	int data[10][5];
	// do something on data
	foo(data,10,5);
}

// GOOD
template<int junk,int rubbish>void foo(int(&matrix)[junk][rubbish],int n,int m);
void foo(int**matrix,int n,int m);
int main(){
	int data[10][5];
	// do something on data
	foo(data,10,5);
}

int add(int num1, int num2)
{
 num1 += num2; // change of value of "num1"
 return num1;
}

int main()
{
 int a = 10, b = 20, ans;
 ans = add(a, b);
 std::cout << a << " + " << b << " = " << ans << std::endl;
 return 0;
}

10 + 20 = 30
const
const
void foo(const std::string &s)
{
 s.append("blah"); // ERROR -- we can't modify the string

 std::cout << s.length() << std::endl; // fine
}

void bar(const Widget *w)
{
 w->rotate(); // ERROR - rotate wouldn't be const

 std::cout << w->name() << std::endl; // fine
}

append()
const
rotate()
const
int foo (int a, int b = 5, int c = 3);

foo(6, 1)

foo(6, 1, 3)

return
return
int MyFunc(); // returns an int
SOMETYPE MyFunc(); // returns a SOMETYPE

int* MyFunc(); // returns a pointer to an int
SOMETYPE *MyFunc(); // returns a pointer to a SOMETYPE
SOMETYPE &MyFunc(); // returns a reference to a SOMETYPE

SOMETYPE *MyFunc(int *p) 
{ 
  //... 

  return p; 
} 

SOMETYPE &MyFunc(int &r) 
{ 
  //... 

  return r; 
}

return
return;
return value;

SOMETYPE *MyFunc()  //returning a pointer that has a dynamically 
{           //allocated memory address is valid code 
  int *p = new int[5]; 

  //... 

  return p; 
}

const SOMETYPE *MyFunc(int *p) 
{
  //... 

  return p; 
}

 bool bOK;
 if (my_function1())
 {
     // block of instruction 1
     if (my_function2())
     {
         // block of instruction 2
         if (my_function3())
         {
              // block of instruction 3
              // Everything worked
              error_code = NO_ERROR;
              bOK = true;
         }
         else
         {
              //error handler for function 3 errors
              error_code = FUNCTION_3_FAILED;
              bOK = false;
         }
     }
     else
     {
         //error handler for function 2 errors
         error_code = FUNCTION_2_FAILED;
         bOK = false;
     }
 }
 else
 {
     //error handler for function 1 errors
     error_code = FUNCTION_1_FAILED;
     bOK = false;
 }
 return bOK;

 if (!my_function1()) // or if (my_function1() == false) 
 {
     //error handler for function 1 errors

     //...

 if (0 != my_function1())
 {
     //error handler for function 1 errors
     return FUNCTION_1_FAILED;
 }
 // block of instruction 1
 if (0 != my_function2())
 {
     //error handler for function 2 errors
     return FUNCTION_2_FAILED;
 }
 // block of instruction 2
 if (0 != my_function3())
 {
     //error handler for function 3 errors
     return FUNCTION_3_FAILED;
 }
 // block of instruction 3
 // Everything worked
 return 0; // NO_ERROR

double x = cos (angle + pi/2);

double x = exp (log (10.0));

  void func(){
     func();
  }

  double power(double x, int n)
  {
   if (n < 0)
   {
      std::cout << std::endl
                << "Negative index, program terminated.";
      exit(1);
   }
   if (n)
      return x * power(x, n-1);
   else
      return 1.0;
  }

  x = power(x, static_cast<int>(power(2.0, 2)));

 unsigned factorial(unsigned n)
 {
   if (n != 0) 
   {
     return n * factorial(n-1);
   } 
   else 
   {
     return 1;
   }
 }

 unsigned factorial2(unsigned n)
 {
   int a = 1;
   while(n > 0)
   {
     a = a*n;
     n = n-1;
   }
   return a;
 }

 unsigned factorial(unsigned n)
 {
   if(n != 0) 
   {
     return n * factorial(n-1);
   } 
   else
   {
     return 1;
   }
 }

0 1 1 2 3 5 8 13 21 34 ...
main
main
main
main
main()
main
cstdlib
EXIT_SUCCESS
EXIT_FAILURE
int main(int argc, char **argv){
  // code
}

main
main
argv[0]
#include <iostream>

int main(int argc, char **argv){
  std::cout << "Number of arguments: " << argc << std::endl;
  for(size_t i = 0; i < argc; i++)
    std::cout << "  Argument " << i << " = '" << argv[i] << "'" << std::endl;
}

arguments
$ ./arguments I love chocolate cake
C:\>arguments I love chocolate cake
Number of arguments: 5
  Argument 0 = './arguments'
  Argument 1 = 'I'
  Argument 2 = 'love'
  Argument 3 = 'chocolate'
  Argument 4 = 'cake'
argv
argc
int (*ptof)(int arg);

int (*ptof)(int arg);
int func(int arg){
    //function body
}
ptof = &func; // get a pointer to func
ptof = func;  // same effect as ptof = &func
(*ptof)(5);   // calls func
ptof(5);      // same thing.

float
double
int
signed
typedef
*
typedef int (*int_to_int_function)(int);
int_to_int_function ptof;

int *func (int);   // WRONG: Declares a function taking an int returning pointer-to-int.
int (*func) (int); // RIGHT: Defines a pointer to a function taking an int returning int.

typedef
typedef int ifunc (int);    // now "ifunc" means "function taking an int returning int"
typedef int (*pfunc) (int); // now "pfunc" means "pointer to function taking an int returning int"

typedef
typdef
&
int f (int, int);
int f (int, double);
int g (int, int = 4);
double h (int);
int i (int);

int (*p) (int) = &g; // ERROR: The default parameter needs to be included in the pointer type.
p = &h;              // ERROR: The return type needs to match exactly.
p = &i;              // Correct.
p = i;               // Also correct.

int (*p2) (int, double);
p2 = f;              // Correct: The compiler automatically picks "int f (int, double)".

*
#include <iostream>

int f (int i) { return 2 * i; }

int main ()
 {
  int (*g) (int) = f;
  std::cout<<"g(4) is "<<g(4)<<std::endl;    // Will output "g(4) is 8"
  std::cout<<"(*g)(5) is "<<g(5)<<std::endl; // Will output "g(5) is 10"
  return 0;
 }

// Overloading Example

// (1)
double geometric_mean( int, int );

// (2)
double geometric_mean( double, double );

// (3)
double geometric_mean( double, double, double );

// ...

// Will call (1):
geometric_mean( 10, 25 );
// Will call (2):
geometric_mean( 22.1, 421.77 );
// Will call (3):
geometric_mean( 11.1, 0.4, 2.224 );

// This is an error, because (1) could be called and the second
// argument casted to an int, and (2) could be called with the first
// argument casted to a double. None of the two functions is
// unambiguously a better match.
geometric_mean(7, 13.21);
// This will call (3) too, despite its last argument being an int,
// Because (3) is the only function which can be called with 3
// arguments
geometric_mean(1.1, 2.2, 3);
operator short toShort();
void*
void foo(void*, bool);
void foo(int*, int);

int main() {
 int a;
 foo(&a, true); // ambiguous 
}

template<typename T> void foo(T);  //1
template<typename T> void foo(T*); //2

int main() {
 int a;
 foo(&a); // Calls 2, since 2 is more specialized.
}

void foo(int);
int foo(float);

int main() { 
 // This will fail since foo(int) is best match, and void cannot be converted to int.
 return foo(5); 
}

namespace
unsigned
#include <cstdio>
void clearerr( FILE *stream );

#include <cstdio>
int fclose( FILE *stream );

#include <cstdio>
int feof( FILE *stream );

#include <cstdio>
int ferror( FILE *stream );

#include <cstdio>
int fflush( FILE *stream );

printf( "Before first call\n" );
fflush( stdout );
shady_function();
printf( "Before second call\n" );
fflush( stdout );
dangerous_dereference();

#include <cstdio>
int fgetc( FILE *stream );

#include <cstdio>
int fgetpos( FILE *stream, fpos_t *position );

#include <cstdio>
char *fgets( char *str, int num, FILE *stream );

#include <cstdio>
FILE *fopen( const char *fname, const char *mode );

int ch;
FILE *input = fopen( "stuff", "r" );
ch = getc( input );

#include <cstdio>
int fprintf( FILE *stream, const char *format, ... );

char name[20] = "Mary";
FILE *out;
out = fopen( "output.txt", "w" );
if( out != NULL )
  fprintf( out, "Hello %s\n", name );

#include <cstdio>
int fputc( int ch, FILE *stream );

#include <cstdio>
int fputs( const char *str, FILE *stream );

#include <cstdio>
int fread( void *buffer, size_t size, size_t num, FILE *stream );

#include <cstdio>
FILE *freopen( const char *fname, const char *mode, FILE *stream );

#include <cstdio>
int fscanf( FILE *stream, const char *format, ... );

#include <cstdio>
int fseek( FILE *stream, long offset, int origin );

#include <cstdio>
int fsetpos( FILE *stream, const fpos_t *position );

#include <cstdio>
long ftell( FILE *stream );

#include <cstdio>
int fwrite( const void *buffer, size_t size, size_t count, FILE *stream );

#include <cstdio>
int getc( FILE *stream );

int ch;
FILE *input = fopen( "stuff", "r" );             

ch = getc( input );
while( ch != EOF ) {
  printf( "%c", ch );
  ch = getc( input );
}

#include <cstdio>
int getchar( void );

#include <cstdio>
char *gets( char *str );

#include <cstdio>
void perror( const char *str );

char* input_filename = "not_found.txt";
FILE* input = fopen( input_filename, "r" );
if( input == NULL ) {
  char error_msg[255];
  sprintf( error_msg, "Error opening file '%s'", input_filename );
  perror( error_msg );
  exit( -1 );
}

 Error opening file 'not_found.txt': No such file or directory
#include <cstdio>
int printf( const char *format, ... );
cout<<printf;

char name[20] = "Bob";
int age = 21;
printf( "Hello %s, you are %d years old\n", name, age );

 Hello Bob, you are 21 years old
unsigned
unsigned
unsigned
  %012d
 %012.4d
 %-12.4f 
#include <cstdio>
int putc( int ch, FILE *stream );

int ch;
FILE *input, *output;
input = fopen( "tmp.c", "r" );
output = fopen( "tmpCopy.c", "w" );
ch = getc( input );
while( ch != EOF ) {
  putc( ch, output );
  ch = getc( input );
}
fclose( input );
fclose( output );

#include <cstdio>
int putchar( int ch );

putchar( ch );

putc( ch, stdout );

#include <cstdio>
int puts( char *str );

#include <cstdio>
int remove( const char *fname );

#include <cstdio>
int rename( const char *oldfname, const char *newfname );

#include <cstdio>
void rewind( FILE *stream );

#include <cstdio>
int scanf( const char *format, ... );

unsigned
int i;
float f;               
double d;

printf( "Enter an integer: " );
scanf( "%d", &i );             

printf( "Enter a float: " );
scanf( "%f", &f );             

printf( "Enter a double: " );
scanf( "%lf", &d );             

printf( "You entered %d, %f, and %f\n", i, f, d );

#include <cstdio>
void setbuf( FILE *stream, char *buffer );

#include <cstdio>
int setvbuf( FILE *stream, char *buffer, int mode, size_t size );

#include <cstdio>
int sprintf( char *buffer, const char *format, ... );

char string[50];
int file_number = 0;         

sprintf( string, "file.%d", file_number );
file_number++;
output_file = fopen( string, "w" );

char result[100];
int num = 24;
sprintf( result, "%d", num );

char result[100];
float fnum = 3.14159;
sprintf( result, "%f", fnum );

#include <cstdio>
int sscanf( const char *buffer, const char *format, ... );

#include <cstdio>
FILE *tmpfile( void );

#include <cstdio>
char *tmpnam( char *name );

#include <cstdio>
int ungetc( int ch, FILE *stream );

#include <cstdarg>
#include <cstdio>
int vprintf( char *format, va_list arg_ptr );
int vfprintf( FILE *stream, const char *format, va_list arg_ptr );
int vsprintf( char *buffer, char *format, va_list arg_ptr );

void error( char *fmt, ... ) {
  va_list args;
  va_start( args, fmt );
  fprintf( stderr, "Error: " );
  vfprintf( stderr, fmt, args );
  fprintf( stderr, "\n" );
  va_end( args );
  exit( 1 );
}

/* "Hello" is stored in a character array */
char note[SIZE];
note[0] = 'H'; note[1] = 'e'; note[2] = 'l'; note[3] = 'l'; note[4] = 'o'; note[5] = '\0';

#include <cstdlib>
double atof( const char *str );

x = atof( "42.0is_the_answer" );

#include <cstdlib>
int atoi( const char *str );

int i;
i = atoi( "512" );
i = atoi( "512.035" );
i = atoi( "   512.035" );
i = atoi( "   512+34" );
i = atoi( "   512 bottles of beer on the wall" );

int i = atoi( " does not work: 512" );  // results in i == 0

/*
    Description:
    Program to convert a c-style string into decimal, octal and hex integers.
    Copyright (C) <2015>  <AM>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// Standard IOSTREAM
#include "iostream"

// Convert a string of Numbers to integer 
long int atoifunc(const char* str);

// Function to convert a string of Numbers into an integer 
long int atoioct(const char* str);

// Function to convert a string of Numbers into a hexadecimal integer 
long long int atoiHex(const char* str);

// Find length of a string 
static int strlength(const char *str);

// Get digit from character in input string 
static int getDecDigit(const char str);

// Get a digit from corresponding character in input string
static int getOctDigit(const char str);

// Get a hexadecimal digit from corresponding character in input string
static int getHexDigit(const char str);

using namespace std;

// Application program 
int main(void)
{
    char decstr[8] = "";
    char octstr[8] = "";
    char Hexstr[8] = "";
    long int IntNumber=0;
    long int OctNumber=0;
    long long int HexNumber=0;

    cout << "Enter a string of 8 characters in decimal digit form: ";
    cin >> decstr;

    cout << "Enter a string of 8 characters is octal form: ";
    cin >> octstr;

    IntNumber = atoifunc(decstr);
    cout <<"\nYou entered decimal number: " << IntNumber;

    cout << oct;
    OctNumber= atoioct(octstr);

    // Displaying octal number should be done in digits 0-7
    cout <<"\nYou entered octal number: " << OctNumber;

    cout << dec;
    // Displaying octal number should be done in digits 0-7
    cout <<"\nYou entered an oct which is decimal number: " << OctNumber;

    cout << "\nEnter a string of 7 characters in Hex form: ";
    cin >> Hexstr;

    HexNumber=atoiHex(Hexstr);
    cout << hex;
    // Displaying octal number should be done in digits 0-9, A-F
    cout <<"\nYou entered a Hexadecimal number: " << HexNumber;

    cout << dec;

    // Displaying octal number should be done in digits 0-9, A-F
    cout <<"\nYou entered a Hexadecimal which is decimal number: " << HexNumber;

    return 0;
}

/* Function to convert a string of Numbers into an integer */

/* Get the Number of digits entered as a string.

For each digit, place it in appropriate place of an integer such as
digit x 1000 or digit x10000 depending on integer size and input range.
The multiple of the the first and subsequent digits would be selected depending
on the Number of digits.

For example, 123 would be calculated as an integer in the following steps:

1* 100
2* 10
3* 1

The calculated value is then returned by the function.

For example, if the digits entered are 12345
Then,the multipliers are:
str[0] * 10000
str[1] * 1000
str[2] * 100
str[3] * 10
str[4] * 1
Check your machine endianness for correct order of bytes.
*/

long int atoifunc(const char* str)
{

  int declength =strlength(str);
  long int Number =0;
   switch(declength)
    {
          case 0:
          Number += getDecDigit(str[0])*0;
          break;

          // Convert characters to digits with another function.
          case 1:
          Number += getDecDigit(str[0])*1;
          break;

          case 2:

          Number+=getDecDigit(str[0])*10;
          Number+=getDecDigit(str[1])*1;
          break;

          case 3:
          Number+=getDecDigit(str[0])*100;
          Number+=getDecDigit(str[1])*10;
          Number+=getDecDigit(str[2])*1;
          break;

          case 4:
          Number+=getDecDigit(str[0])*1000;
          Number+=getDecDigit(str[1])*100;
          Number+=getDecDigit(str[2])*10;
          Number+=getDecDigit(str[3])*1;
          break;

          case 5:
          Number+=getDecDigit(str[0])*10000;
          Number+=getDecDigit(str[1])*1000;
          Number+=getDecDigit(str[2])*100;
          Number+=getDecDigit(str[3])*10;
          Number+=getDecDigit(str[4])*1;
          break;

          case 6:
          Number+=getDecDigit(str[0])*100000;
          Number+=getDecDigit(str[1])*10000;
          Number+=getDecDigit(str[2])*1000;
          Number+=getDecDigit(str[3])*100;
          Number+=getDecDigit(str[4])*10;
          Number+=getDecDigit(str[5])*1;
          break;

          case 7:
          Number+=getDecDigit(str[0])*1000000;
          Number+=getDecDigit(str[1])*100000;
          Number+=getDecDigit(str[2])*10000;
          Number+=getDecDigit(str[3])*1000;
          Number+=getDecDigit(str[4])*100;
          Number+=getDecDigit(str[5])*10;
          Number+=getDecDigit(str[6])*1;
          break;

          case 8:
          Number+=getDecDigit(str[0])*10000000;
          Number+=getDecDigit(str[1])*1000000;
          Number+=getDecDigit(str[2])*100000;
          Number+=getDecDigit(str[3])*10000;
          Number+=getDecDigit(str[4])*1000;
          Number+=getDecDigit(str[5])*100;
          Number+=getDecDigit(str[6])*10;
          Number+=getDecDigit(str[7])*1;
          break;

          default:
          Number =0;
          break;
  }

  return Number;
}

// Find length of a string
static int strlength(const char *str)
{
    int count=0;
    while(str[count]!='\0')
    {
        count++;
    }
    return count;
}

// get a digit from corresponding character in input string
static int getDecDigit(const char str)
{
    int digit =0;
    switch (str)
    {
        case '0':
        digit = 0;
        break;

        case '1':
        digit = 1;
        break;

        case '2':
        digit = 2;
        break;

        case '3':
        digit = 3;
        break;

        case '4':
        digit = 4;
        break;

        case '5':
        digit = 5;
        break;

        case '6':
        digit = 6;
        break;

        case '7':
        digit = 7;
        break;

        case '8':
        digit = 8;
        break;

        case '9':
        digit = 9;
        break;

        default:
        digit =0;
        break;
    }
    return digit;
}

/* Function to convert a string of Numbers into an integer */

long int atoioct(const char* str)
{
  long int Number =0;
  int stroctlength =strlength(str);
   switch(stroctlength)
    {
          case 0:
          Number += getOctDigit(str[0])*0;
          break;

          // Convert characters to digits with another function.
          case 1:
          Number += getOctDigit(str[0])*1;
          break;

          case 2:

          Number+=getOctDigit(str[0])*8;
          Number+=getOctDigit(str[1])*1;
          break;

          case 3:

          Number+=getOctDigit(str[0])*64;
          Number+=getOctDigit(str[1])*8;
          Number+=getOctDigit(str[2])*1;

          break;

          case 4:
          Number+=getOctDigit(str[0])*512;
          Number+=getOctDigit(str[1])*64;
          Number+=getOctDigit(str[2])*8;
          Number+=getOctDigit(str[3])*1;

          break;

          case 5:
          Number+=getOctDigit(str[0])*4096;
          Number+=getOctDigit(str[1])*512;
          Number+=getOctDigit(str[2])*64;
          Number+=getOctDigit(str[3])*8;
          Number+=getOctDigit(str[4])*1;
          break;

          case 6:
          Number+=getOctDigit(str[0])*32768;
          Number+=getOctDigit(str[1])*4096;
          Number+=getOctDigit(str[2])*512;
          Number+=getOctDigit(str[3])*64;
          Number+=getOctDigit(str[4])*8;
          Number+=getOctDigit(str[5])*1;
          break;

          case 7:
          Number+=getOctDigit(str[0])*262144;
          Number+=getOctDigit(str[1])*32768;
          Number+=getOctDigit(str[2])*4096;
          Number+=getOctDigit(str[3])*512;
          Number+=getOctDigit(str[4])*64;
          Number+=getOctDigit(str[5])*8;
          Number+=getOctDigit(str[6])*1;
          break;

          default:
          Number =0;
          break;
  }

  return Number;

}

// Get a digit from character input in input string
static int getOctDigit(const char str)
{
    int digit =0;
    switch (str)
    {
        case '0':
        digit = 0;
        break;

        case '1':
        digit = 1;
        break;

        case '2':
        digit = 2;
        break;

        case '3':
        digit = 3;
        break;

        case '4':
        digit = 4;
        break;

        case '5':
        digit = 5;
        break;

        case '6':
        digit = 6;
        break;

        case '7':
        digit = 7;
        break;

        default:
        digit =0;
        break;
    }
    return digit;
}

// Get a hexadecimal digit from corresponding character in input string
static int getHexDigit(const char str)
{
    int digit =0;
    switch (str)
    {
        case '0':
        digit = 0;
        break;

        case '1':
        digit = 1;
        break;

        case '2':
        digit = 2;
        break;

        case '3':
        digit = 3;
        break;

        case '4':
        digit = 4;
        break;

        case '5':
        digit = 5;
        break;

        case '6':
        digit = 6;
        break;

        case '7':
        digit = 7;
        break;

        case '8':
        digit = 8;
        break;

        case '9':
        digit = 9;
        break;

        case 'A' :
        case 'a':
        digit =10;
        break;

        case 'B' :
        case 'b':
        digit = 11;
        break;

        case 'C' :
        case 'c':
        digit =12;
        break;

        case 'D' :
        case 'd':
        digit =13;
        break;

        case 'E' :
        case 'e':
        digit = 14;
        break;

        case 'F' :
        case 'f':
        digit = 15;
        break;

        default:
        digit =0;
        break;
    }
    return digit;
}

// Function to convert a string of Numbers into a hexadecimal integer
long long int atoiHex(const char* str)
{
  long long int Number =0;
  int strHexlength =strlength(str);
  switch(strHexlength)
    {
          case 0:
          Number += getHexDigit(str[0])*0;
          break;

          // Convert characters to digits with another function.
          // Implicit type conversion from int to long int.
          case 1:
          Number += getHexDigit(str[0])*1;
          break;

          case 2:
          Number+=getHexDigit(str[0])*16;
          Number+=getHexDigit(str[1])*1;
          break;

          case 3:
          Number+=getHexDigit(str[0])*256;
          Number+=getHexDigit(str[1])*16;
          Number+=getHexDigit(str[2])*1;
          break;

          case 4:
          Number+=getHexDigit(str[0])*4096;
          Number+=getHexDigit(str[1])*256;
          Number+=getHexDigit(str[2])*16;
          Number+=getHexDigit(str[3])*1;
          break;

          case 5:
          Number+=getHexDigit(str[0])*65536;
          Number+=getHexDigit(str[1])*4096;
          Number+=getHexDigit(str[2])*256;
          Number+=getHexDigit(str[3])*16;
          Number+=getHexDigit(str[4])*1;
          break;

          case 6:
          Number+=getHexDigit(str[0])*1048576;
          Number+=getHexDigit(str[1])*65536;
          Number+=getHexDigit(str[2])*4096;
          Number+=getHexDigit(str[3])*256;
          Number+=getHexDigit(str[4])*16;
          Number+=getHexDigit(str[5])*1;
          break;

          case 7:
          Number+=getHexDigit(str[0])*16777216;
          Number+=getHexDigit(str[1])*1048576;
          Number+=getHexDigit(str[2])*65536;
          Number+=getHexDigit(str[3])*4096;
          Number+=getHexDigit(str[4])*256;
          Number+=getHexDigit(str[5])*16;
          Number+=getHexDigit(str[6])*1;
          break;

          default:
          Number =0;
          break;
  }

  return Number;

}

#include <cstdlib>
long atol( const char *str );

x = atol( "1024.0001" );

#include <cctype>
int isalnum( int ch );

char c;
scanf( "%c", &c );
if( isalnum(c) )
  printf( "You entered the alphanumeric character %c\n", c );

#include <cctype>
int isalpha( int ch );

char c;
scanf( "%c", &c );
if( isalpha(c) )
  printf( "You entered a letter of the alphabet\n" );

#include <cctype>
int iscntrl( int ch );

#include <cctype>
int isdigit( int ch );

char c;
scanf( "%c", &c );
if( isdigit(c) )
  printf( "You entered the digit %c\n", c );

#include <cctype>
int isgraph( int ch );

#include <cctype>
int islower( int ch );

#include <cctype>
int isprint( int ch );

#include <cctype>
int ispunct( int ch );

#include <cctype>
int isspace( int ch );

#include <cctype>
int isupper( int ch );

#include <cctype>
int isxdigit( int ch );

#include <cstring>
void *memchr( const void *buffer, int ch, size_t count );

char names[] = "Alan Bob Chris X Dave";
if( memchr(names,'X',strlen(names)) == NULL )
  printf( "Didn't find an X\n" );
else
  printf( "Found an X\n" );

#include <cstring>
int memcmp( const void *buffer1, const void *buffer2, size_t count );

#include <cstring>
void *memcpy( void *to, const void *from, size_t count );

#include <cstring>
void *memmove( void *to, const void *from, size_t count );

#include <cstring>
void* memset( void* buffer, int ch, size_t count );

const int ARRAY_LENGTH;
char the_array[ARRAY_LENGTH];
...
// zero out the contents of the_array
memset( the_array, '\0', ARRAY_LENGTH );

for
for
#include <cstring>
char *strcat( char *str1, const char *str2 );

printf( "Enter your name: " );
scanf( "%s", name );
title = strcat( name, " the Great" );
printf( "Hello, %s\n", title );  ;

#include <cstring>
char *strchr( const char *str, int ch );

#include <cstring>
int strcmp( const char *str1, const char *str2 );

printf( "Enter your name: " );
scanf( "%s", name );
if( strcmp( name, "Mary" ) == 0 ) {
  printf( "Hello, Dr. Mary!\n" );
}

#include <cstring>
int strcoll( const char *str1, const char *str2 );

#include <cstring>
char *strcpy( char *to, const char *from );

#include <cstring>
size_t strcspn( const char *str1, const char *str2 );

#include <cstring>
char *strerror( int num );

#include <cstring>
size_t strlen( char *str );

#include <cstring>
char *strncat( char *str1, const char *str2, size_t count );

#include <cstring>
int strncmp( const char *str1, const char *str2, size_t count );

#include <cstring>
char *strncpy( char *to, const char *from, size_t count );

#include <cstring>
char * strpbrk( const char *str, const char *ch );

#include <cstring>
char *strrchr( const char *str, int ch );

#include <cstring>
size_t strspn( const char *str1, const char *str2 );

#include <cstring>
char *strstr( const char *str1, const char *str2 );

char* str1 = "this is a string of characters";
char* str2 = "a string";
char* result = strstr( str1, str2 );
if( result == NULL ) printf( "Could not find '%s' in '%s'\n", str2, str1 );
  else printf( "Found a substring: '%s'\n", result );

 Found a substring: 'a string of characters'
#include <cstdlib>
double strtod( const char *start, char **end );

x = atof( "42.0is_the_answer" );

#include <cstring>
char *strtok( char *str1, const char *str2 );

char str[] = "now # is the time for all # good men to come to the # aid of their country";
char delims[] = "#";
char *result = NULL;
result = strtok( str, delims );
while( result != NULL ) {
  printf( "result is \"%s\"\n", result );
  result = strtok( NULL, delims );
}

 result is "now "
 result is " is the time for all "
 result is " good men to come to the "
 result is " aid of their country" 
#include <cstdlib>
long strtol( const char *start, char **end, int base );

#include <cstdlib>
unsigned long strtoul( const char *start, char **end, int base );

unsigned
#include <cstring>
size_t strxfrm( char *str1, const char *str2, size_t num );

#include <cctype>
int tolower( int ch );

#include <cctype>
int toupper( int ch );

#include <cstdlib>
int abs( int num );

int magic_number = 10;
cout << "Enter a guess: ";
cin >> x;
cout << "Your guess was " << abs( magic_number - x ) << " away from the magic number." << endl;

#include <cmath>
double acos( double arg );

#include <cmath>
double asin( double arg );

#include <cmath>
double atan( double arg );

#include <cmath>
double atan2( double y, double x );

#include <cmath>
double ceil( double num );

y = 6.04;
x = ceil( y );

#include <cmath>
float cos( float arg );
double cos( double arg );
long double cos( long double arg );

#include <cmath>
float cosh( float arg );
double cosh( double arg );
long double cosh( long double arg );

#include <cstdlib>
div_t div( int numerator, int denominator );

int quot;   // The quotient
int rem;    // The remainder

div_t temp;
temp = div( x, y );
printf( "%d divided by %d yields %d with a remainder of %d\n",
  x, y, temp.quot, temp.rem );

#attrid <cmath>
double exp( double arg );

#include <cmath>
double fabs( double arg );

#include <cmath>
double floor( double arg );

// Example for positive numbers
y = 6.04;
x = floor( y );

// Example for negative numbers
y = -6.04;
x = floor( y );

#include <cmath>
double fmod( double x, double y );

#include <cmath>
double frexp( double num, int* exp );

num = mantissa * (2 ^ exp)

#include <cstdlib>
long labs( long num );

#include <cmath>
double ldexp( double num, int exp );

#include <cstdlib>
ldiv_t ldiv( long numerator, long denominator );

long quot;  // the quotient
long rem;   // the remainder

#include <cmath>
double log( double num );

double answer = log(x) / log(b);

#include <cmath>
double log10( double num );

#include <cmath>
double modf( double num, double *i );

#include <cmath>
double pow( double base, double exp );

#include <cmath>
double sin( double arg );

   double a;
   cin>>a;

                                                           cout<<"sin("<<a<<")="<<sin(a*(3.14159/180.))<<endl;
#include <cmath>
double sinh( double arg );

#include <cmath>
double sqrt( double num );

#include <cmath>
double tan( double arg );

#include <cmath>
double tanh( double arg );

/*example*/
#include <stdio.h>
#include <math.h>
int main (){
	double c, p;
	c = log(2.0);
	p = tanh (c);
	printf ("The hyperbolic tangent of %lf is %lf.\n", c, p );
return 0;
}

#include <ctime>
char *asctime( const struct tm *ptr );

day month date hours:minutes:seconds year
Mon Jun 26 12:03:53 2000
#include <ctime>
clock_t clock( void );

#include <ctime>
char *ctime( const time_t *time );

day month date hours:minutes:seconds year            
asctime( localtime( tp ) );

#include <ctime>
double difftime( time_t time2, time_t time1 );

#include <ctime>
struct tm *gmtime( const time_t *time );

#include <ctime>
struct tm *localtime( const time_t *time );

#include <ctime>
time_t mktime( struct tm *time );

#include <clocale>
char *setlocale( int category, const char * locale );

#include <ctime>
size_t strftime( char *str, size_t maxsize, const char *fmt, struct tm *time );

#include <ctime>
time_t time( time_t *time );

#include <cstdlib>
void *calloc( size_t num, size_t size);

     ptr = (float*)calloc(25, sizeof(float));
     /* It would create an array of 25 cells, each one with a size of 4 bytes
        “(sizeof(float))”, all the cells initialized with value 0 */

#include <cstdlib>
void free( void *p);

#include <cstdlib>
void *malloc( size_t s );

#include <cstdlib>
void *realloc( void *p, size_t s);

#include <cstdlib>
void abort( void );

#include <cassert>
assert( exp );

#include <cstdlib>
int atexit( void (*func)(void) );

#include <cstdlib>
void* bsearch( const void *key, const void *base, size_t num, size_t size, int (*compare)(const void *, const void *));

#include <cstdlib>
void exit( int exit_code );

#include <cstdlib>
char *getenv( const char *name );

#include <csetjmp>
void longjmp( jmp_buf env, int val );

goto
#include <cstdlib>
void* qsort( const void *base, size_t num, size_t size, int (*compare)(const void *, const void *));

#include <csignal>
int raise(int)

#include <cstdlib>
int rand( void );

srand( time(NULL) );
for( i = 0; i < 10; i++ )
  printf( "Random number #%d: %d\n", i, rand() );

#include <csetjmp>
int setjmp( jmp_buf env );

#include <csignal>
void (*signal( int sig, void (*handler)(int)) )(int)

#include <cstdlib>
void srand( unsigned seed );

srand( time(NULL) );
for( i = 0; i < 10; i++ )
  printf( "Random number #%d: %d\n", i, rand() );

#include <cstdlib>
int system( const char *command );

#include <cstdarg>
type va_arg( va_list argptr, type );
void va_end( va_list argptr );
void va_start( va_list argptr, last_parm );

int sum( int num, ... ) {
  int answer = 0;
  va_list argptr;            

  va_start( argptr, num );            

  for( ; num > 0; num-- ) {
    answer += va_arg( argptr, int );
  }           

  va_end( argptr );           

  return( answer );
}             

int main( void ) {            

  int answer = sum( 4, 4, 3, 2, 1 );
  printf( "The answer is %d\n", answer );           

  return( 0 );
}

void my_printf( char *format, ... ) {
  va_list argptr;             

  va_start( argptr, format );          

  while( *format != '\0' ) {
    // string
    if( *format == 's' ) {
      char* s = va_arg( argptr, char * );
      printf( "Printing a string: %s\n", s );
    }
    // character
    else if( *format == 'c' ) {
      char c = (char) va_arg( argptr, int );
      printf( "Printing a character: %c\n", c );
      break;
    }
    // integer
    else if( *format == 'd' ) {
      int d = va_arg( argptr, int );
      printf( "Printing an integer: %d\n", d );
    }          

    *format++;
  }            

  va_end( argptr );
}              

int main( void ) {             

  my_printf( "sdc", "This is a string", 29, 'X' );         

  return( 0 );
}

Printing a string: This is a string
Printing an integer: 29
Printing a character: X

// unsafe
p->doStuff(); 

// much better!
if (p) 
{
   p->doStuff(); 
}

// Example of an assignment of a number in an if statement when a comparison was meant.
if ( x = 143 ) // should be: if ( x == 143)

if (x==3)
cout << x;
flag++;

pdb
myProgram
pdb myProgram
for
MAIN
    A
     B
      C
       statement S
sizeof
for
goto
struct
class
struct
struct myStructType /*: inheritances */ {
public: 
 // declare public members here
protected:
 // declare protected members here
private:
 // declare private members here
};

 /* struct */ myStructType obj1 /* , obj2, ... */;

 struct { /*members*/ } obj1 /*, obj2, .. */ ;

struct
public
struct
public
class
struct
// A struct definition:
 struct Point { 
   double x, y; };

x
y
struct Point blank; 
blank.x = 3.0; 
blank.y = 4.0;

fruit.length()
double x = blank.x;

blank.x
x
x
x
cout << blank.x << ", " << blank.y << endl; 
double distance = sqrt(blank.x * blank.x + blank.y * blank.y);

+
%
==
>
Point blank = { 3.0, 4.0 };

x
Point blank; 
blank = { 3.0, 4.0 }; // WRONG !!

Point p1 = { 3.0, 4.0 }; 
Point p2 = p1; 
cout << p2.x << ", " <<  p2.y << endl;

struct Rectangle {
  Point corner;
  double width, height;
};

Point findCenter (const Rectangle& box) 
{ 
  double x = box.corner.x + box.width/2; 
  double y = box.corner.y + box.height/2; 
  Point result = {x, y}; 
  return result; 
}

Rectangle mybox = { {10.0, 0.0}, 100, 200 }; 
Point center = findCenter (mybox); 
printPoint (center);

//of course you have to define the Point struct first!

struct Rectangle {
 Point upper_left; 
 Point upper_right;
 Point lower_left;
 Point lower_right;
};

union
    union union-name 
    {
        public-members-list;
    private:
        private-members-list;
    } object-list;

     union Data {
       int i;
       char c;
     };

union item 
{
  // The item is 16-bits
  short theItem;

  // In little-endian lo accesses the low 8-bits -
  // hi, the upper 8-bits
  struct { char lo; char hi; } portions;
};

  item tItem;
  tItem.theItem = 0xBEAD;
  tItem.portions.lo = 0xEF; // The item now equals 0xBEEF

// primary event structure in SDL

typedef union 
{
  Uint8 type;
  SDL_ActiveEvent active;
  SDL_KeyboardEvent key;
  SDL_MouseMotionEvent motion;
  SDL_MouseButtonEvent button;
  SDL_JoyAxisEvent jaxis;
  SDL_JoyBallEvent jball;
  SDL_JoyHatEvent jhat;
  SDL_JoyButtonEvent jbutton;
  SDL_ResizeEvent resize;
  SDL_ExposeEvent expose;
  SDL_QuitEvent quit;
  SDL_UserEvent user;
  SDL_SysWMEvent syswm;
} SDL_Event;

Uint8
unsigned
// SDL_MouseButtonEvent

typedef struct
{
  Uint8 type;
  Uint8 button;
  Uint8 state;
  Uint16 x, y;
} SDL_MouseButtonEvent;

SDL_Event ev
if (ev.type == SDL_MOUSEBUTTONUP && ev.button.button == SDL_BUTTON_RIGHT) 
{
  cout << "You have right-clicked at coordinates (" << ev.button.x << ", "
       << ev.button.y << ")." << endl;
}

class MyClass
{
 /* public, protected and private
 variables, constants, and functions */
};

MyClass object;

/* Bottle - Class and Object Example */
#include <iostream>
#include <iomanip>

using namespace std;

class Bottle
{
  private:      // variables are modified by member functions of class
  int iFill;    // dl of liquid

  public:
    Bottle()    // Default Constructor
    : iFill(3)  // They start with 3 dl of liquid
      {
        // More constructor code would go here if needed.
      }

     bool sip() // return true if liquid was available
     {

       if (iFill > 0)
       {
         --iFill;
         return true;
       }
       else
       {
         return false;
       }

     }

     int level() const  // return level of liquid dl
     {
         return iFill;
     }
 };  // Class declaration has a trailing semicolon

int main()
{
  // terosbottle object is an instance of class Bottle
  Bottle terosbottle;
  cout << "In the beginning, mybottle has "
       << terosbottle.level()
       << "  dl of liquid"
       << endl;

  while (terosbottle.sip())
  {
     cout << "Mybottle has "
          << terosbottle.level()
          << " dl of liquid"
          << endl;
  }

  return 0;
}

class Foo
{
 public:
   Foo(const Foo &f)
   {
     m_iValue = f.m_iValue; // perfectly legal
   }

 private:
   int m_iValue;
};

class PlayerCar {
   private:
     int color;

   public:
     void driveAtFullSpeed(int mph){
       // code for moving the car ahead
     }
};

class PoliceCar {
private:
  int color;
  bool sirenOn;  // identifies whether the siren is on or not
  bool inAction; // identifies whether the police is in action (following the player) or not

public:
  bool isInAction(){
    return this->inAction;
  }

  void driveAtFullSpeed(int mph){
    // code for moving the car ahead
  }

};

PlayerCar player1;
PoliceCar policemen1;

class MyClass {
  protected:
         int age;
  public:
         void sayAge(){
             this->age = 20;
             cout << age;
         }
};

class MyNewClass : public MyClass {

};

int main() {

  MyNewClass *a = new MyNewClass();
  a->sayAge();

  return 0;

}

class Car {
  protected:
         int color;
         int currentSpeed;
         int maxSpeed;
  public:
         void applyHandBrake(){
             this->currentSpeed = 0;
         }
         void pressHorn(){
             cout << "Teeeeeeeeeeeeent"; // funny noise for a horn
         }
         void driveAtFullSpeed(int mph){
              // code for moving the car ahead;
         }
};

class PlayerCar : public Car {

};

class PoliceCar : public Car {
  private:
         bool sirenOn;  // identifies whether the siren is on or not
         bool inAction; // identifies whether the police is in action (following the player) or not
  public:
         bool isInAction(){
             return this->inAction;
         }
};

class Form {
private:
  double area;

public:
  int color;

  double getArea(){
    return this->area;
  }

  void setArea(double area){
    this->area = area;
  }

};

class Circle : public Form {
public:
  double getRatio() {
    double a;
    a = getArea();
    return sqrt(a / 2 * 3.14);
  }

  void setRatio(double diameter) {
    setArea( pow(diameter * 0.5, 2) * 3.14 );
  }

  bool isDark() {
    return (color > 10);
  }

};

ChildClass::ChildClass(int a, int b) : ParentClass(a, b)
{
  //Child constructor here
}

class One
{
  // class internals
};

class Two
{
  // class internals
};

class MultipleInheritance : public One, public Two
{
  // class internals
};

class Foo
{
private:
    int iX;
public:
    Foo(){ iX = 5; };

    int getData() 
    {   
        return this->iX;  // this is provided by the compiler at compile time
    }
};

int main()
{
    Foo Example;
    int iTemp;

    iTemp = Example.getData(&Example);  // compiler adds the &Example reference at compile time

    return 0;
}

class Foo
{
private:
    int iX;
public:
    Foo() { iX = 5; };

    int getData()          
    {                            
        return iX;  
    }

    Foo& operator=(const Foo &RHS);
};

Foo& Foo::operator=(const Foo &RHS)
{
    if(this != &RHS)
    {    // the if this test prevents an object from copying to itself (ie. RHS = RHS;)
        this->iX = RHS.iX;     // this is suitable for this class, but can be more complex when
                               // copying an object in a different much larger class
    }

    return (*this);            // returning an object allows chaining, like a = b = c; statements
}

static
class Foo {
public:
  Foo() {
    ++iNumFoos;
    cout << "We have now created " << iNumFoos << " instances of the Foo class\n";
  }
private:
  static int iNumFoos;
};

int Foo::iNumFoos = 0;  // allocate memory for numFoos, and initialize it

int main() {
  Foo f1;
  Foo f2;
  Foo f3;
}

// the header file named the same as the class helps locate classes within a project
// one class per header file makes it easier to keep the 
// header file readable (some classes can become large)
// each programmer should determine what style works for them or what programming standards their
// teacher/professor/employer has

#ifndef FOO_H
#define FOO_H

class Foo{
public:
  Foo();                  // function called the default constructor
  Foo( int a, int b );    // function called the overloaded constructor
  int Manipulate( int g, int h );

private:
  int x;
  int y;
};

#endif

#include "Foo.h"

/* these constructors should really show use of initialization lists
Foo::Foo() : x(5), y(10)
{
}
Foo::Foo(int a, int b) : x(a), y(b)
{
}
*/
Foo::Foo(){
  x = 5;
  y = 10;
}
Foo::Foo( int a, int b ){
  x = a;
  y = b;
}

int Foo::Manipulate( int g, int h ){
  x = h + g*x;
  y = g + h*y;
}

Foo myTest;                 // essentially what happens is:  Foo myTest = Foo();
Foo myTest( 3, 54 );        // accessing the overloaded constructor
Foo myTest = Foo( 20, 45 ); // although a new object is created, there are some extra function calls involved
                            // with more complex classes, an assignment operator should
                            // be defined to ensure a proper copy (includes ''deep copy'')
                            // myTest would be constructed with the default constructor, and then the
                            // assignment operator copies the unnamed Foo( 20, 45 ) object to myTest

Foo* myTest = new Foo();           // this defines a pointer to a dynamically allocated object
Foo* myTest = new Foo( 40, 34 );   // constructed with Foo( 40, 34 )
// be sure to use delete to avoid memory leaks

myFoo(); // default constructor, the user has no control over initial values
         // overloaded constructors

myFoo( int a, int b=0 ); // allows construction with a certain 'a' value, but accepts 'b' as 0
                         // or allows the user to provide both 'a' and 'b' values
 // or

myFoo( int a, int b ); // overloaded constructor, the user must specify both values

class myFoo {
private:
  int Useful1;
  int Useful2;

public:
  myFoo(){                     // default constructor
           Useful1 = 5;
           Useful2 = 10;  
          };

  myFoo( int a, int b = 0 ) { // two possible cases when invoked
         Useful1 = a;
         Useful2 = b;
  };

};

myFoo Find;           // default constructor, private member values Useful1 = 5, Useful2 = 10
myFoo Find( 8 );      // overloaded constructor case 1, private member values Useful1 = 8, Useful2 = 0
myFoo Find( 8, 256 ); // overloaded constructor case 2, private member values Useful1 = 8, Useful2 = 256

// Using the initialization list for myComplexMember_ 
MyClass::MyClass(int mySimpleMember, MyComplexClass myComplexMember)
: myComplexMember_(myComplexMember) // only 1 call, to the copy constructor
{
 mySimpleMember_=mySimpleMember; // uses 2 calls, one for the constructor of the mySimpleMember class
                                 // and a second for the assignment operator of the MyComplexClass class
}

MyClass::MyClass() : myComplexMember(0)_ { }

class MyClass : public MyBaseClassA, public MyBaseClassB {
  private:
    int c;
    void *pointerMember;
  public:
    MyClass(int,int,int);
};
/*...*/
MyClass::MyClass(int a, int b, int c):
 MyBaseClassA(a)
,MyBaseClassB(b)
,c(c)
,pointerMember(NULL)
,referenceMember()
{
 //logic
}

inline
static
this
class Foo {
public:
  Foo() {
    ++numFoos;
    cout << "We have now created " << numFoos << " instances of the Foo class\n";
  }
  static int getNumFoos() {
    return numFoos;
  }
private:
  static int numFoos;
};

int Foo::numFoos = 0;  // allocate memory for numFoos, and initialize it

int main() {
  Foo f1;
  Foo f2;
  Foo f3;
  cout << "So far, we've made " << Foo::getNumFoos() << " instances of the Foo class\n";
}

class Temperature
{
    public:
        static Temperature Fahrenheit (double f);
        static Temperature Celsius (double c);
        static Temperature Kelvin (double k);
    private:
        Temperature (double temp);
        double _temp;
};

Temperature::Temperature (double temp):_temp (temp) {}

Temperature Temperature::Fahrenheit (double f)
{
    return Temperature ((f + 459.67) / 1.8);
}

Temperature Temperature::Celsius (double c)
{
    return Temperature (c + 273.15);
}

Temperature Temperature::Kelvin (double k)
{
    return Temperature (k);
}

mutable
 class Foo
 {
  public:
    int value() const
    {
      return m_value;
    }

    void setValue( int i )
    {
      m_value = i;
    }

  private:
    int m_value;
 };

value()
setValue()
const
const
const
const
 class Foo
 {
 public:
    /*
     * Modifies m_widget and the user
     * may modify the returned widget.
     */
    Widget *widget();

    /*
     * Does not modify m_widget but the
     * user may modify the returned widget.
     */
    Widget *widget() const;

    /*
     * Modifies m_widget, but the user
     * may not modify the returned widget.
     */
    const Widget *cWidget();

    /*
     * Does not modify m_widget and the user
     * may not modify the returned widget.
     */
    const Widget *cWidget() const;

 private:
    Widget *m_widget;
 };

GetSize() ) of that type of member functions.

What is a modifier?
A modifier, also called a modifying function, is a member function that changes the value of at least one data member. In other words, an operation that modifies the state of an object. Modifiers are also known as ‘mutators’.

Setter is another common definition of a modifier due to the naming ( SetSize( int a_Size ) ) of that type of member functions.

 Dynamic polymorphism (Overrides)
So far, we have learned that we can add new data and functions to a class through inheritance. But what about if we want our derived class to inherit a method from the base class, but to have a different implementation for it? That is when we are talking about polymorphism, a fundamental concept in OOP programming.

As seen previously in the Programming Paradigms Section, Polymorphism is subdivided in two concepts static polymorphism and dynamic polymorphism. This section concentrates on dynamic polymorphism, which applies in C++ when a derived class overrides a function declared in a base class.

We implement this concept redefining the method in the derived class. However, we need to have some considerations when we do this, so now we must introduce the concepts of dynamic binding, static binding and virtual methods.

Suppose that we have two classes, A and B. B derives from A and redefines the implementation of a method c() that resides in class A. Now suppose that we have an object b of class B. How should the instruction b.c() be interpreted?

If b is declared in the stack (not declared as a pointer or a reference) the compiler applies static binding, this means it interprets (at compile time) that we refer to the implementation of c() that resides in B.

However, if we declare b as a pointer or a reference of class A, the compiler could not know which method to call at compile time, because b can be of type A or B. If this is resolved at run time, the method that resides in B will be called. This is called dynamic binding. If this is resolved at compile time, the method that resides in A will be called. This is again, static binding.

 Virtual member functions 
The virtual member functions is relatively simple, but often misunderstood. The concept is an essential part of designing a class hierarchy in regards to sub-classing classes as it determines the behavior of overridden methods in certain contexts.

Virtual member functions are class member functions, that can be overridden in any class derived from the one where they were declared. The member function body is then replaced with a new set of implementation in the derived class.

By placing the keyword virtual before a method declaration we are indicating that when the compiler has to decide between applying static binding or dynamic binding it will apply dynamic binding. Otherwise, static binding will be applied.

Again, this should be clearer with an example:

class Foo
{
public:
  void f()
  {
    std::cout << "Foo::f()" << std::endl;
  }
  virtual void g()
  {
    std::cout << "Foo::g()" << std::endl;
  }
};

class Bar : public Foo
{
public:
  void f()
  {
    std::cout << "Bar::f()" << std::endl;
  }
  virtual void g()
  {
    std::cout << "Bar::g()" << std::endl;
  }
};

int main()
{
  Foo foo;
  Bar bar;

  Foo *baz = &bar;
  Bar *quux = &bar;

  foo.f(); // "Foo::f()"
  foo.g(); // "Foo::g()"

  bar.f(); // "Bar::f()"
  bar.g(); // "Bar::g()"

  // So far everything we would expect...

  baz->f();  // "Foo::f()"
  baz->g();  // "Bar::g()"

  quux->f(); // "Bar::f()"
  quux->g(); // "Bar::g()"

  return 0;
}

Our first calls to f() and g() on the two objects are straightforward. However things get interesting with our baz pointer which is a pointer to the Foo type.

f() is not virtual and as such a call to f() will always invoke the implementation associated with the pointer type -- in this case the implementation from Foo.

Virtual function calls are computationally more expensive than regular function calls. Virtual functions use pointer indirection, invocation and will require a few extra instructions than normal member functions. They also require that the constructor of any class/structure containing virtual functions to initialize a table of pointers to its virtual member functions. 

All this characteristics will signify a trade-off between performance and design. One should avoid preemptively declaring functions virtual without an existing structural need. Keep in mind that virtual functions that are only resolved at run-time cannot be inlined.

 Pure virtual member function 
There is one additional interesting possibility. Sometimes we don't want to provide an implementation of our function at all, but want to require people sub-classing our class to provide an implementation on their own. This is the case for pure virtuals.

To indicate a pure virtual function instead of an implementation we simply add an "= 0" after the function declaration.

Again -- an example:

class Widget
{
public:
   virtual void paint() = 0;
};

class Button : public Widget
{
public:
   void paint() // is virtual because it is an override
   {
       // do some stuff to draw a button
   }
};

Because paint() is a pure virtual function in the Widget class we are required to provide an implementation in all concrete subclasses. If we don't the compiler will give us an error at build time.

This is helpful for providing interfaces -- things that we expect from all of the objects based on a certain hierarchy, but when we want to ignore the implementation details.

So why is this useful?
Let's take our example from above where we had a pure virtual for painting. There are a lot of cases where we want to be able to do things with widgets without worrying about what kind of widget it is. Painting is an easy example.

Imagine that we have something in our application that repaints widgets when they become active. It would just work with pointers to widgets -- i.e. Widget *activeWidget() const might be a possible function signature. So we might do something like:

Widget *w = window->activeWidget();
w->paint();

We want to actually call the appropriate paint member function for the "real" widget type -- not Widget::paint() (which is a "pure" virtual and will cause the program to crash if called using virtual dispatch). By using a virtual function we insure that the member function implementation for our subclass -- Button::paint() in this case -- will be called.

 Covariant return types 
Covariant return types is the ability for a virtual function in a derived class to return a pointer or reference to an instance of itself if the version of the method in the base class does so. e.g.

class base
{
public:
  virtual base* create() const;
};

class derived : public base
{
public:
  virtual derived* create() const;
};

This allows casting to be avoided.

 virtual Constructors 
There is a hierarchy of classes with base class Foo. Given an object bar belonging in the hierarchy, it is desired to be able to do the following:
Create an object baz of the same class as bar (say, class Bar) initialized using the default constructor of the class. The syntax normally used is:
Bar* baz = bar.create();
Create an object baz of the same class as bar which is a copy of bar. The syntax normally used is:
Bar* baz = bar.clone();

In the class Foo, the methods Foo::create() and Foo::clone() are declared as follows:

class Foo
{
    // ...

    public:
        // Virtual default constructor
        virtual Foo* create() const;

        // Virtual copy constructor
        virtual Foo* clone() const;
};

If Foo is to be used as an abstract class, the functions may be made pure virtual:

class Foo
{
   // ...

    public:
        virtual Foo* create() const = 0;
        virtual Foo* clone() const = 0;
};

In order to support the creation of a default-initialized object, and the creation of a copy object, each class Bar in the hierarchy must have public default and copy constructors. The virtual constructors of Bar are defined as follows:

class Bar : ... // Bar is a descendant of Foo
{
    // ...

    public:
    // Non-virtual default constructor
    Bar ();
    // Non-virtual copy constructor
    Bar (const Bar&);

    // Virtual default constructor, inline implementation
    Bar* create() const { return new Foo (); }
    // Virtual copy constructor, inline implementation
    Bar* clone() const { return new Foo (*this); }
};

The above code uses covariant return types. If your compiler doesn't support Bar* Bar::create(), use Foo* Bar::create() instead, and similarly for clone().

While using these virtual constructors, you must manually deallocate the object created by calling delete baz;. This hassle could be avoided if a smart pointer (e.g. std::unique_ptr<Foo>) is used in the return type instead of the plain old Foo*.

Remember that whether or not Foo uses dynamically allocated memory, you must define the destructor virtual ~Foo () and make it virtual to take care of deallocation of objects using pointers to an ancestral type.

 virtual Destructor 
It is of special importance to remember to define a virtual destructor even if empty in any base class, since failing to do so will create problems with the default compiler generated destructor that will not be virtual.

A virtual destructor is not overridden when redefined in a derived class, the definitions to each destructor are cumulative and they start from the last derivate class toward the first base class.

 Pure virtual Destructor 
Every abstract class should contain the declaration of a pure virtual destructor. 

Pure virtual destructors are a special case of pure virtual functions (meant to be overridden in a derived class). They must always be defined and that definition should always be empty.

class Interface {
public:
  virtual ~Interface() = 0; //declaration of a pure virtual destructor 
};

Interface::~Interface(){} //pure virtual destructor definition (should always be empty)

 Law of three 
The "law of three" is not really a law, but rather a guideline: if a class needs an explicitly declared copy constructor, copy assignment operator, or destructor, then it usually needs all three.

There are exceptions to this rule (or, to look at it another way, refinements).  For example, sometimes a destructor is explicitly declared just in order to make it virtual; in that case there's not necessarily a need to declare or implement the copy constructor and copy assignment operator.

Most classes should not declare any of the "big three" operations; classes that manage resources generally need all three.

 Subsumption property 
Subsumption is a property that all objects that reside in a class hierarchy must fulfill: an object of the base class can be substituted by an object that derives from it (directly or indirectly). All mammals are animals (they derive from them), and all cats are mammals. Therefore, because of the subsumption property we can "treat" any mammal as an animal and any cat as a mammal. This implies abstraction, because when we are "treating" a mammal as an animal, the only information we should know about it is that it lives, it grows, etc, but nothing related to mammals.

This property is applied in C++, whenever we are using pointers or references to objects that reside in a class hierarchy. In other words, a pointer of class animal can point to an object of class animal, mammal or cat.

Let's continue with our example:

 //needs to be corrected
  enum AnimalType {
       Herbivore,
       Carnivore,
       Omnivore,
  };

  class Animal {
        public:
               AnimalType Type;
               bool bIsAlive;
               int iNumberOfChildren;
  };

  class Mammal : public Animal{
        public:
               int iNumberOfTeats;
  };

  class Cat : public Mammal{
        public:
              bool bLikesFish;  // probably true
  };

  int main() {
      Animal* pA1 = new Animal;
      Animal* pA2 = new Mammal;
      Animal* pA3 = new Cat;
      Mammal* pM  = new Cat;

      pA2->bIsAlive = true;     // Correct
      pA2->Type = Herbivore;    // Correct
      pM->iNumberOfTeats = 2;   // Correct

      pA2->iNumberOfTeats = 6;  // Incorrect
      pA3->bLikesFish = true;   // Incorrect

      Cat* pC = (Cat*)pA3;      // Downcast, correct (but very poor practice, see later)
      pC->bLikesFish = false;   // Correct (although it is a very awkward cat)
   }

In the last lines of the example there is cast of a pointer to Animal, to a pointer to Cat. This is called "Downcast". Downcasts are useful and should be used, but first we must ensure that the object we are casting is really of the type we are casting to it. Downcasting a base class to an unrelated class is an error. To resolve this issue, the casting operators dynamic_cast<>, or static_cast<> should be used. 
These correctly cast an object from one class to another, and will throw an exception if the class types are not related. eg. If you try:

Cat* pC = new Cat;

motorbike* pM = dynamic_cast<motorbike*>(pC);

Then, the app will throw an exception, as a cat is not a motorbike. Static_cast is very similar, only it will perform the type checking at compile time. If you have an object where you are not sure of its type then you should use dynamic_cast, and be prepared to handle errors when casting. If you are downcasting objects where you know the types, then you should use static_cast. Do not use old-style C casts as these will simply give you an access violation if the types cast are unrelated.

 Local classes 
A local class is any class that is defined inside a specific statement block, in a local scope, for instance inside a function. This is done like defining any other class, but local classes can not however access non-static local variables or be used to define static data members. These type of classes are useful especially in template functions, as we will see later. 

void MyFunction()
{
   class LocalClass
   {
   // ... members definitions ...
   };

   // ... any code that needs the class ...

}

 User defined automatic type conversion 
We already covered automatic type conversions (implicit conversion) and mentioned that some can be user-defined.

A user-defined conversion from a class to another class can be done by providing a constructor in the target class that takes the source class as an argument, Target(const Source& a_Class) or by providing the target class with a conversion operator, as operator Source().

 Ensuring objects of a class are never copied 
This is required e.g. to prevent memory-related problems that would result in case the default copy-constructor or the default assignment operator is unintentionally applied to a class C which uses dynamically allocated memory, where a copy-constructor and an assignment operator are probably an overkill as they won't be used frequently.

Some style guidelines suggest making all classes non-copyable by default, and only enabling copying if it makes sense. Other (bad) guidelines say that you should always explicitly write the copy constructor and copy assignment operators; that's actually a bad idea, as it adds to the maintenance effort, adds to the work to read a class, is more likely to introduce errors than using the implicitly declared ones, and doesn't make sense for most object types. A sensible guideline is to think about whether copying makes sense for a type; if it does, then first prefer to arrange that the compiler-generated copy operations will do the right thing (e.g., by holding all resources via resource management classes rather than via raw pointers or handles), and if that's not reasonable then obey the law of three. If copying doesn't make sense, you can disallow it in either of two idiomatic ways as shown below.

Just declare the copy-constructor and assignment operator, and make them private. Do not define them. As they are not protected or public, they are inaccessible outside the class. Using them within the class would give a linker error since they are not defined.

class C
{
  ...

  private:
    // Not defined anywhere
    C (const C&);
    C& operator= (const C&);
};

Remember that if the class uses dynamically allocated memory for data members, you must define the memory release procedures in destructor ~C () to release the allocated memory.

A class which only declares these two functions can be used as a private base class, so that all classes which privately inherits such a class will disallow copying.

 Container class 
A class that is used to hold objects in memory or external storage is often called a container class. A container class acts as a generic holder and has a predefined behavior and a well-known interface. It is also a supporting class whose purpose is to hide the topology used for maintaining the list of objects in memory. When it contains a group of mixed objects, the container is called a heterogeneous container; when the container is holding a group of objects that are all the same, the container is called a homogeneous container.

 Interface class 

 Singleton class 
A Singleton class is a class that can only be instantiated once (similar to the use of static variables or functions). It is one of the possible implementations of a creational pattern, which is fully covered in the Design Patterns Section of the book. 

 Abstract Classes 
An abstract class is, conceptually, a class that cannot be instantiated and is usually implemented as a class that has one or more pure virtual (abstract) functions.

A pure virtual function is one which must be overridden by any concrete (i.e., non-abstract) derived class.  This is indicated in the declaration with the syntax " = 0" in the member function's declaration.

 Example

class AbstractClass {
public:
  virtual void AbstractMemberFunction() = 0; // Pure virtual function makes
                                             // this class Abstract class.
  virtual void NonAbstractMemberFunction1(); // Virtual function.

  void NonAbstractMemberFunction2();
};

In general an abstract class is used to define an implementation and is intended to be inherited from by concrete classes. It's a way of forcing a contract between the class designer and the users of that class. If we wish to create a concrete class (a class that can be instantiated) from an abstract class we must declare and define a matching member function for each abstract member function of the base class. Otherwise, if any member function of the base class is left undefined, we will create a new abstract class (this could be useful sometimes).

Sometimes we use the phrase "pure abstract class," meaning a class that exclusively has pure virtual functions (and no data). The concept of interface is mapped to pure abstract classes in C++, as there is no construction "interface" in C++ the same way that there is in Java.

 Example

 class Vehicle {
 public:
     explicit
     Vehicle( int topSpeed )
     : m_topSpeed( topSpeed )
     {}
     int TopSpeed() const {
        return m_topSpeed;
     }

     virtual void Save( std::ostream& ) const = 0;

 private:
     int m_topSpeed;
 };

 class WheeledLandVehicle : public Vehicle {
 public:
     WheeledLandVehicle( int topSpeed, int numberOfWheels )
     : Vehicle( topSpeed ), m_numberOfWheels( numberOfWheels )
     {}
     int NumberOfWheels() const {
       return m_numberOfWheels;
     }

     void Save( std::ostream& ) const; // is implicitly virtual

 private:
     int m_numberOfWheels;
 };

 class TrackedLandVehicle : public Vehicle {
 public:
    TrackedLandVehicle ( int topSpeed, int numberOfTracks )
    : Vehicle( topSpeed ), m_numberOfTracks ( numberOfTracks )
    {}
    int NumberOfTracks() const {
       return m_numberOfTracks;
    }
    void Save( std::ostream& ) const; // is implicitly virtual

  private:
    int m_numberOfTracks;
  };

In this example the Vehicle is an abstract base class as it has an abstract member function.The class WheeledLandVehicle is derived from the base class. It also holds data which is common to all wheeled land vehicles, namely the number of wheels. The class TrackedLandVehicle is another variation of the Vehicle class.

This is something of a contrived example but it does show how that you can share implementation details among a hierarchy of classes. Each class further refines a concept. This is not always the best way to implement an interface but in some cases it works very well. As a guideline, for ease of maintenance and understanding you should try to limit the inheritance to no more than 3 levels. Often the best set of classes to use is a pure virtual abstract base class to define a common interface. Then use an abstract class to further refine an implementation for a set of concrete classes and lastly define the set of concrete classes.

An abstract class is a class that is designed to be specifically used as a base class. An abstract class contains at least one pure virtual function. You declare a pure virtual function by using a pure specifier (= 0) in the declaration of a virtual member function in the class declaration.

The following is an example of an abstract class:

class AB {
public:
  virtual void f() = 0;
};

Function AB::f is a pure virtual function. A function declaration cannot have both a pure specifier and a definition.

Abstract class cannot be used as a parameter type, a function return type, or the type of an explicit conversion, and not to declare an object of an abstract class. It can be used to declare pointers and references to an abstract class.

 Pure Abstract Classes 
An abstract class is one in which there is a declaration but no definition for a member function. The way this concept is expressed in C++ is to have the member function declaration assigned to zero.

 Example

class PureAbstractClass 
{
public:
  virtual void AbstractMemberFunction() = 0;
};

A pure Abstract class has only abstract member functions and no data or concrete member functions. In general, a pure abstract class is used to define an interface and is intended to be inherited by concrete classes. It's a way of forcing a contract between the class designer and the users of that class. The users of this class must declare a matching member function for the class to compile.

 Example of usage for a pure Abstract Class

 class DrawableObject 
 {
  public:
    virtual void Draw(GraphicalDrawingBoard&) const = 0; //draw to GraphicalDrawingBoard
 };

 class Triangle : public DrawableObject
 {
 public:
   void Draw(GraphicalDrawingBoard&) const; //draw a triangle
 };

 class Rectangle : public DrawableObject
 {
 public:
   void Draw(GraphicalDrawingBoard&) const; //draw a rectangle
 };

 class Circle : public DrawableObject
 {
 public:
   void Draw(GraphicalDrawingBoard&) const; //draw a circle
 };

 typedef std::list<DrawableObject*> DrawableList;

 DrawableList drawableList;
 GraphicalDrawingBoard drawingBoard;

 drawableList.pushback(new Triangle());
 drawableList.pushback(new Rectangle());
 drawableList.pushback(new Circle());

 for(DrawableList::const_iterator iter = drawableList.begin(), 
    endIter = drawableList.end();
    iter != endIter;
    ++iter)
 { 
   DrawableObject *object = *iter;
   object->Draw(drawingBoard);
 }

Note that this is a bit of a contrived example and that the drawable objects are not fully defined (no constructors or data) but it should give you the general idea of the power of defining an interface. Once the objects are constructed, the code that calls the interface does not know any of the implementation details of the called objects, only that of the interface. The object GraphicalDrawingBoard is a placeholder meant to represent the thing onto which the object will be drawn, i.e. the video memory, drawing buffer, printer.

Note that there is a great temptation to add concrete member functions and data to pure abstract base classes. This must be resisted, in general it is a sign that the interface is not well factored. Data and concrete member functions tend to imply a particular implementation and as such can inherit from the interface but should not be that interface. Instead if there is some commonality between concrete classes, creation of abstract class which inherits its interface from the pure abstract class and defines the common data and member functions of the concrete classes works well. Some care should be taken to decide whether inheritance or aggregation should be used. Too many layers of inheritance can make the maintenance and usage of a class difficult. Generally, the maximum accepted layers of inheritance is about 3, above that and refactoring of the classes is generally called for. A general test is the "is a" vs "has a", as in a Square is a Rectangle, but a Square has a set of sides.

 What is a "nice" (container safe) class? 

A "nice" class takes into consideration the use of the following functions:

1.  The copy constructor.

2.  The assignment operator.

3.  The equality operator.

4.  The inequality operator.

 Class Declaration 

class Nice
{
public:
    Nice(const Nice &Copy);
    Nice &operator= (const Nice &Copy);
    bool operator== (const Nice &param) const;
    bool operator!= (const Nice &param) const;
};

 Description 
A "nice" class could also be called a container safe class.  Many containers such as those in the Standard Template Library (STL), that we'll see later, use copy construction and the assignment operator when interacting with the objects of your class.  The assignment operator and copy constructor only need to be declared and defined if the default behavior, which is a member-wise (not binary) copy, is undesirable or insufficient to properly copy/construct your object.

A general rule of thumb is that if the default, member-wise copy operations do not work for your objects then you should define a suitable copy constructor and assignment operator.  They are both needed if either is defined.

Copy Constructor

The purpose of the copy constructor is to allow the programmer to perform the same instructions as the assignment operator with the special case of knowing that the caller is initializing/constructing rather than an copying.

It is also good practice to use the explicit keyword when using a copy constructor to prevent unintended implicit type conversion.

Example

class Nice
{
public:
  explicit Nice(int _a) : a(_a)
  {
    return;
  }
private:
  int a;
};

class NotNice
{
public:
  NotNice(int _a) :  a(_a)
  {
    return;
  }
private:
  int a;
};

int main()
{
  Nice proper = Nice(10); //this is ok
  Nice notproper = 10; //this will result in an error
  NotNice eg = 10; //this WILL compile, you may not have intended this conversion
  return 0;
}

Equality Operator
The equality operator says, "Is this object equal to that object?".  What constitutes equal is up to the programmer.  This is a requirement if you ever want to use the equality operator with objects of your class.

However, in most applications (e.g. mathematics), it is usually the case that coding the inequality is easier than coding the equality.  In which case the following code can be written for the equality.

inline bool Nice::operator== (const Nice& param) const
{
    return !(*this != param);
}

Inequality Operator
The inequality operator says, "Is this object not equal to that object?".  What constitutes not equal is up to the programmer.  This is a requirement if you ever want to use the inequality operator with objects of your class.

However, in some applications, coding the equality is easier than coding the inequality.  In which case the following code can be written for the inequality.

inline bool Nice::operator!= (const Nice& param) const
{
    return !(*this == param);
}

If the statement about the (in)equality operators having different efficiency (whatever kind) seems complete nonsense to you, consider that typically, all object attributes must match for two objects to be considered equal.
  Typically, only one object attribute must differ for two objects to be considered unequal.  For equality and inequality operators, that doesn't mean one is faster than the other.

Note, however, that using both the above equality and inequality functions as defined will result in an infinite recursive loop and care must be taken to use only one or the other.  Also, there are some situations where neither applies and therefore neither of the above can be used.

Given two objects A and B (with class attributes x and y), an equality operator could be written as

  if (A.x != B.x) return false;
  if (A.y != B.y) return false;
  return true;

while an inequality operator could be written as

  if (A.x != B.x) return true;
  if (A.y != B.y) return true;
  return false;

So yes, the equality operator can certainly be written ...!(a!=b)..., but it isn't any faster.  In fact, there's the additional overhead of a method call and a negation operation.

So the question becomes, is a little execution overhead worth the smaller code and improved maintainability?  There is no simple answer to this it all depend on how the programmer is using them. If your class is composed of, say, an array of 1 billion elements, the overhead is negligible.

 Operator overloading 
Operator overloading (less commonly known as ad-hoc polymorphism) is a specific case of polymorphism (part of the OO nature of the language) in which some or all operators like +, = or == are treated as polymorphic functions and as such have different behaviors depending on the types of its arguments.
Operator overloading is usually only syntactic sugar. It can easily be emulated using function calls.

Consider this operation:

add (a, multiply (b,c))

Using operator overloading permits a more concise way of writing it, like this:
a + b * c

(Assuming the * operator has higher precedence than +.)

Operator overloading can provide more than an aesthetic benefit, since the language allows operators to be invoked implicitly in some circumstances. Problems, and critics, to the use of operator overloading arise because it allows programmers to give operators completely free functionality, without an imposition of coherency that permits to consistently satisfy user/reader expectations. Usage of the << operator is an example of this problem.

// The expression
a << 1;

Will return twice the value of a if a is an integer variable, but if a is an output stream instead this will write "1" to it. Because operator overloading allows the programmer to change the usual semantics of an operator, it is usually considered good practice to use operator overloading with care.

To overload an operator is to provide it with a new meaning for user-defined types. This is done in the same fashion as defining a function. The basic syntax follows (where @ represents a valid operator):

return_type operator@(argument_list)
{
    // ... definition
}

Not all operators may be overloaded, new operators cannot be created, and the precedence, associativity or arity of operators cannot be changed (for example ! cannot be overloaded as a binary operator). Most operators may be overloaded as either a member function or non-member function, some, however, must be defined as member functions. Operators should only be overloaded where their use would be natural and unambiguous, and they should perform as expected. For example, overloading + to add two complex numbers is a good use, whereas overloading * to push an object onto a vector would not be considered good style.

 A simple Message Header

// sample of Operator Overloading

#include <string>

class PlMessageHeader
{
    std::string m_ThreadSender;
    std::string m_ThreadReceiver;

    //return true if the messages are equal, false otherwise
    inline bool operator == (const PlMessageHeader &b) const
    {
        return ( (b.m_ThreadSender==m_ThreadSender) &&
                (b.m_ThreadReceiver==m_ThreadReceiver) );
    }

    //return true if the message is for name
    inline bool isFor (const std::string &name) const
    {
        return (m_ThreadReceiver==name);
    }

    //return true if the message is for name
    inline bool isFor (const char *name) const
    {
        return (m_ThreadReceiver==name);// since name type is std::string, it becomes unsafe if name == NULL
    }
};

 Operators as member functions 
Aside from the operators which must be members, operators may be overloaded as member or non-member functions. The choice of whether or not to overload as a member is up to the programmer. Operators are generally overloaded as members when they:

 change the left-hand operand, or
 require direct access to the non-public parts of an object.

When an operator is defined as a member, the number of explicit parameters is reduced by one, as the calling object is implicitly supplied as an operand. Thus, binary operators take one explicit parameter and unary operators none. In the case of binary operators, the left hand operand is the calling object, and no type coercion will be done upon it. This is in contrast to non-member operators, where the left hand operand may be coerced.

    // binary operator as member function
    Vector2D Vector2D::operator+(const Vector2D& right)const {...}

    // binary operator as non-member function
    Vector2D operator+(const Vector2D& left, const Vector2D& right) {...}

    // binary operator as non-member function with 2 arguments 
    friend Vector2D operator+(const Vector2D& left, const Vector2D& right) {...}

    // unary operator as member function
    Vector2D Vector2D::operator-()const {...}

    // unary operator as non-member function
    Vector2D operator-(const Vector2D& vec) {...}

 Overloadable operators 

 Arithmetic operators 
+ (addition)
- (subtraction)
* (multiplication)
/ (division)
% (modulus)

As binary operators, these involve two arguments which do not have to be the same type. These operators may be defined as member or non-member functions. An example illustrating overloading for the addition of a 2D mathematical vector type follows.

Vector2D Vector2D::operator+(const Vector2D& right)
{
    Vector2D result;
    result.set_x(x() + right.x());
    result.set_y(y() + right.y());
    return result;
}

It is good style to only overload these operators to perform their customary arithmetic operation.
Because operator has been overloaded as member function, it can access private fields.

 Bitwise operators 
^ (XOR)
| (OR)
& (AND)
~ (complement)
<< (shift left, insertion to stream)
>> (shift right, extraction from stream)

All of the bitwise operators are binary, except complement, which is unary. It should be noted that these operators have a lower precedence than the arithmetic operators, so if ^ were to be overloaded for exponentiation, x ^ y + z may not work as intended. Of special mention are the shift operators, << and >>. These have been overloaded in the standard library for interaction with streams.  When overloading these operators to work with streams the rules below should be followed:

overload << and >> as friends (so that it can access the private variables with the stream be passed in by references 
(input/output modifies the stream, and copying is not allowed)
the operator should return a reference to the stream it receives (to allow chaining, cout << 3 << 4 << 5)

 An example using a 2D vector

friend ostream& operator<<(ostream& out, const Vector2D& vec) // output
{
    out << "(" << vec.x() << ", " << vec.y() << ")";
    return out;
}

friend istream& operator>>(istream& in, Vector2D& vec) // input
{
    double x, y;
    // skip opening paranthesis
    in.ignore(1);

    // read x
    in >> x;
    vec.set_x(x);

    // skip delimiter
    in.ignore(2);

    // read y
    in >> y;
    vec.set_y(y);

    // skip closing paranthesis
    in.ignore(1);

    return in;
}

 Assignment operator 
The assignment operator, =, must be a member function, and is given default behavior for user-defined classes by the compiler, performing an assignment of every member using its assignment operator. This behavior is generally acceptable for simple classes which only contain variables. However, where a class contains references or pointers to outside resources, the assignment operator should be overloaded (as general rule, whenever a destructor and copy constructor are needed so is the assignment operator), otherwise, for example, two strings would share the same buffer and changing one would change the other.

In this case, an assignment operator should perform two duties:

 clean up the old contents of the object
 copy the resources of the other object

For classes which contain raw pointers, before doing the assignment, the assignment operator should check for self-assignment, which generally will not work (as when  the old contents of the object are erased, they cannot be copied to refill the object). Self assignment is generally a sign of a coding error, and thus for classes without raw pointers, this check is often omitted, as while the action is wasteful of cpu cycles, it has no other effect on the code.

 Example

class BuggyRawPointer { // example of super-common mistake
    T *m_ptr;
    public:
    BuggyRawPointer(T *ptr) : m_ptr(ptr) {}
    BuggyRawPointer& operator=(BuggyRawPointer const &rhs) {
        delete m_ptr; // free resource; // Problem here!
        m_ptr = 0;
        m_ptr = rhs.m_ptr;
        return *this;
    };
};

BuggyRawPointer x(new T);
x = x; // We might expect this to keep x the same. This sets x.m_ptr == 0. Oops!

// The above problem can be fixed like so:
class WithRawPointer2 {
    T *m_ptr;
    public:
    WithRawPointer2(T *ptr) : m_ptr(ptr) {}
    WithRawPointer2& operator=(WithRawPointer2 const &rhs) {
        if (this != &rhs) {
            delete m_ptr; // free resource;
            m_ptr = 0;
            m_ptr = rhs.m_ptr;
        }
        return *this;
    };
};

WithRawPointer2 x2(new T);
x2 = x2; // x2.m_ptr unchanged.

Another common use of overloading the assignment operator is to declare the overload in the private part of the class and not define it. Thus any code which attempts to do an assignment will fail on two accounts, first by referencing a private member function and second fail to link by not having a valid definition. This is done for classes where copying is to be prevented, and generally done with the addition of a privately declared copy constructor

 Example

class DoNotCopyOrAssign {
    public:
        DoNotCopyOrAssign() {};
    private:
        DoNotCopyOrAssign(DoNotCopyOrAssign const&);
        DoNotCopyOrAssign &operator=(DoNotCopyOrAssign const &);
};

class MyClass : public DoNotCopyOrAssign {
    public:
        MyClass();
};

MyClass x, y;
x = y; // Fails to compile due to private assignment operator;
MyClass z(x); // Fails to compile due to private copy constructor.

 Relational operators 
== (equality)
!= (inequality)
> (greater-than)
< (less-than)
>= (greater-than-or-equal-to)
<= (less-than-or-equal-to)

All relational operators are binary, and should return either true or false. Generally, all six operators can be based off a comparison function, or each other, although this is never done automatically (e.g. overloading > will not automatically overload < to give the opposite). There are, however, some templates defined in the header <utility>; if this header is included, then it suffices to just overload operator== and operator<, and the other operators will be provided by the STL.

 Logical operators 
! (NOT)
&& (AND)
|| (OR) 

The logical operators AND are used when evaluating two expressions to obtain a single relational result.The operator corresponds to the boolean logical opration AND,which yields true if operands are true,and false otherwise.The following panel shows the result of operator evaluating the expression. 

The ! operator is unary, && and || are binary. It should be noted that in normal use, && and || have "short-circuit" behavior, where the right operand may not be evaluated, depending on the left operand. When overloaded, these operators get function call precedence, and this short circuit behavior is lost. It is best to leave these operators alone.

 Example

bool Function1();
bool Function2();

Function1() && Function2();

If the result of Function1() is false, then Function2() is not called.

MyBool Function3();
MyBool Function4();

bool operator&&(MyBool const &, MyBool const &);

Function3() && Function4()

Both Function3() and Function4() will be called no matter what the result of the call is to Function3()
This is a waste of CPU processing, and worse, it could have surprising unintended consequences compared to the expected "short-circuit" behavior of the default operators.  Consider:

extern MyObject * ObjectPointer;
bool Function1() { return ObjectPointer != null; }
bool Function2() { return ObjectPointer->MyMethod(); }
MyBool Function3() { return ObjectPointer != null; }
MyBool Function4() { return ObjectPointer->MyMethod(); }

bool operator&&(MyBool const &, MyBool const &);

Function1() && Function2(); // Does not execute Function2() when pointer is null
Function3() && Function4(); // Executes Function4() when pointer is null

 Compound assignment operators 
+= (addition-assignment)
-= (subtraction-assignment)
*= (multiplication-assignment)
/= (division-assignment)
%= (modulus-assignment)
&= (AND-assignment)
|= (OR-assignment)
^= (XOR-assignment)
<<= (shift-left-assignment)
>>= (shift-right-assignment)

Compound assignment operators should be overloaded as member functions, as they change the left-hand operand. Like all other operators (except basic assignment), compound assignment operators must be explicitly defined, they will not be automatically (e.g. overloading = and + will not automatically overload +=). A compound assignment operator should work as expected: A @= B should be equivalent to A = A @ B. An example of += for a two-dimensional mathematical vector type follows.

Vector2D& Vector2D::operator+=(const Vector2D& right)
{
    this->x += right.x;
    this->y += right.y;
    return *this;
}

 Increment and decrement operators 
++ (increment)
-- (decrement)

Increment and decrement have two forms, prefix (++i) and postfix (i++). To differentiate, the postfix version takes a dummy integer. Increment and decrement operators are most often member functions, as they generally need access to the private member data in the class. The prefix version in general should return a reference to the changed object. The postfix version should just return a copy of the original value. In a perfect world, A += 1, A = A + 1, A++, ++A should all leave A with the same value.

 Example

SomeValue& SomeValue::operator++() // prefix
{
    ++data;
    return *this;
}

SomeValue SomeValue::operator++(int unused) // postfix
{
    SomeValue result = *this;
    ++data;
    return result;
}

Often one operator is defined in terms of the other for ease in maintenance, especially if the function call is complex.

SomeValue SomeValue::operator++(int unused) // postfix
{
    SomeValue result = *this;
    ++(*this); // call SomeValue::operator++()
    return result;
}

 Subscript operator 
The subscript operator, [ ], is a binary operator which must be a member function (hence it takes only one explicit parameter, the index). The subscript operator is not limited to taking an integral index. For instance, the index for the subscript operator for the std::map template is the same as the type of the key, so it may be a string etc. The subscript operator is generally overloaded twice; as a non-constant function (for when elements are altered), and as a constant function (for when elements are only accessed).

 Function call operator 
The function call operator, ( ), is generally overloaded to create objects which behave like functions, or for classes that have a primary operation. The function call operator must be a member function, but has no other restrictions - it may be overloaded with any number of parameters of any type, and may return any type. A class may also have several definitions for the function call operator.

 Address of, Reference, and Pointer operators 
These three operators, operator&(), operator*() and operator->() can be overloaded. In general these operators are only overloaded for smart pointers, or classes which attempt to mimic the behavior of a raw pointer. The pointer operator, operator->() has the additional requirement that the result of the call to that operator, must return a pointer, or a class with an overloaded operator->(). In general A == *&A should be true.

Note that overloading operator& invokes undefined behavior:
ISO/IEC 14882:2003, Section 5.3.1
The address of an object of incomplete type can be taken, but if the complete type of that object is a class type that declares operator&() as a member function, then the behavior is undefined (and no diagnostic is required).

 Example

class T {
    public:
        const memberFunction() const;
};

// forward declaration
class DullSmartReference;

class DullSmartPointer {
    private:
        T *m_ptr;
    public:
        DullSmartPointer(T *rhs) : m_ptr(rhs) {};
        DullSmartReference operator*() const {
            return DullSmartReference(*m_ptr);
        }
        T *operator->() const {
            return m_ptr;
        }
};

class DullSmartReference {
    private:
        T *m_ptr;
    public:
        DullSmartReference (T &rhs) : m_ptr(&rhs) {}
        DullSmartPointer operator&() const {
            return DullSmartPointer(m_ptr);
        }
        // conversion operator
        operator T() { return *m_ptr; }
};

DullSmartPointer dsp(new T);
dsp->memberFunction(); // calls T::memberFunction

T t;
DullSmartReference dsr(t);
dsp = &dsr;
t = dsr; // calls the conversion operator

These are extremely simplified examples designed to show how the operators can be overloaded and not the full details of a SmartPointer or SmartReference class. In general you won't want to overload all three of these operators in the same class.

 Comma operator 
The comma operator,() , can be overloaded. The language comma operator has left to right precedence, the operator,() has function call precedence, so be aware that overloading the comma operator has many pitfalls.

 Example

MyClass operator,(MyClass const &, MyClass const &);

MyClass Function1();
MyClass Function2();

MyClass x = Function1(), Function2();

For non overloaded comma operator, the order of execution will be Function1(), Function2(); With the overloaded comma operator, the compiler can call either Function1(), or Function2() first.

 Member Reference operators 
The two member access operators, operator->() and operator->*() can be overloaded. The most common use of overloading these operators is with defining expression template classes, which is not a common programming technique. Clearly by overloading these operators you can create some very unmaintainable code so overload these operators only with great care.

When the -> operator is applied to a pointer value of type (T *), the language dereferences the pointer and applies the . member access operator (so x->m is equivalent to (*x).m).  However, when the -> operator is applied to a class instance, it is called as a unary postfix operator; it is expected to return a value to which the -> operator can again be applied.  Typically, this will be a value of type (T *), as in the example under Address of, Reference, and Pointer operators above, but can also be a class instance with operator->() defined; the language will call operator->() as many times as necessary until it arrives at a value of type (T *).

 Memory management operators 
 new (allocate memory for object)
 new[ ] (allocate memory for array)
 delete (deallocate memory for object)
 delete[ ] (deallocate memory for array)

The memory management operators can be overloaded to customize allocation and deallocation (e.g. to insert pertinent memory headers). They should behave as expected, new should return a pointer to a newly allocated object on the heap, delete should deallocate memory, ignoring a NULL argument. To overload new, several rules must be followed:

 new must be a member function 
 the return type must be void*
 the first explicit parameter must be a size_t value

To overload delete there are also conditions:

 delete must be a member function (and cannot be virtual)
 the return type must be void
 there are only two forms available for the parameter list, and only one of the forms may appear in a class:
 void*
 void*, size_t

 Conversion operators 
Conversion operators enable objects of a class to be either implicitly (coercion) or explicitly (casting) converted to another type. Conversion operators must be member functions, and should not change the object which is being converted, so should be flagged as constant functions. The basic syntax of a conversion operator declaration, and declaration for an int-conversion operator follows.

operator ''type''() const; // const is not necessary, but is good style
operator int() const;

Notice that the function is declared without a return-type, which can easily be inferred from the type of conversion. Including the return type in the function header for a conversion operator is a syntax error.

double operator double() const; // error - return type included

 Operators which cannot be overloaded 
?: (conditional)
. (member selection)
.* (member selection with pointer-to-member)
:: (scope resolution)
sizeof (object size information)
typeid (object type information)

To understand the reasons why the language doesn't permit these operators to be overloaded, read "Why can't I overload dot, ::, sizeof, etc.?" at the Bjarne Stroustrup's C++ Style and Technique FAQ ( http://www.stroustrup.com/bs_faq2.html#overload-dot ).

 I/O 
Also commonly referenced as the C++ I/O of the C++ Standard Library, since the library also includes the C Standard library and its I/O implementation, as seen before in the Standard C I/O Section.

Input and output are essential for any computer software, as these are the only means by which the program can communicate with the user. The simplest form of input/output is pure textual, i.e. the application displays in console form, using simple ASCII characters to prompt the user for inputs, which are supplied using the keyboard.

There are many ways for a program to gain input and output, including
 File i/o, that is, reading and writing to files
 Console i/o, reading and writing to a console window, such as a terminal in UNIX-based operating systems or a DOS prompt in Windows.
 Network i/o, reading and writing from a network device
 String i/o, reading and writing treating a string as if it were the input or output device

While these may seem unrelated, they work very similarly. In fact, operating systems that follow the POSIX specification deal with files, devices, network sockets, consoles, and many other things all with one type of handle, a file descriptor. However, low-level interfaces provided by the operating system tend to be difficult to use, so C++, like other languages, provide an abstraction to make programming easier. This abstraction is the stream.

 Character encoding 

 American Standard Code for Information Interchange (ASCII) 95 chart  
ASCII is a character-encoding scheme based on the ordering of the English alphabet. The 95 ASCII graphic characters numbered from 0x20 to 0x7E (32 to 126 decimal), also known as the printable characters, represent letters, digits, punctuation marks, and a few miscellaneous symbols. The first 32 ASCII characters, from 0x00 to 0x20, are known as control characters. The space character, that denotes the space between words, as produced by the space-bar of a keyboard, represented by code 0x20 (hexadecimal), is considered a non-printing graphic (or an invisible graphic) rather than a control character.

Binary  Oct  Dec  Hex  Glyph

010 0000  040  32  20  space

010 0001  041  33  21  !

010 0010  042  34  22  "

010 0011  043  35  23  #

010 0100  044  36  24  $

010 0101  045  37  25  %

010 0110  046  38  26  &

010 0111  047  39  27  '

010 1000  050  40  28  (

010 1001  051  41  29  )

010 1010  052  42  2A  *

010 1011  053  43  2B  +

010 1100  054  44  2C  ,

010 1101  055  45  2D  -

010 1110  056  46  2E  .

010 1111  057  47  2F  /

011 0000  060  48  30  0

011 0001  061  49  31  1

011 0010  062  50  32  2

011 0011  063  51  33  3

011 0100  064  52  34  4

011 0101  065  53  35  5

011 0110  066  54  36  6

011 0111  067  55  37  7

011 1000  070  56  38  8

011 1001  071  57  39  9

011 1010  072  58  3A  :

011 1011  073  59  3B  ;

011 1100  074  60  3C  <

011 1101  075  61  3D  =

011 1110  076  62  3E  >

011 1111  077  63  3F  ?

Binary  Oct  Dec  Hex  Glyph

100 0000  100  64  40  @

100 0001  101  65  41  A

100 0010  102  66  42  B

100 0011  103  67  43  C

100 0100  104  68  44  D

100 0101  105  69  45  E

100 0110  106  70  46  F

100 0111  107  71  47  G

100 1000  110  72  48  H

100 1001  111  73  49  I

100 1010  112  74  4A  J

100 1011  113  75  4B  K

100 1100  114  76  4C  L

100 1101  115  77  4D  M

100 1110  116  78  4E  N

100 1111  117  79  4F  O

101 0000  120  80  50  P

101 0001  121  81  51  Q

101 0010  122  82  52  R

101 0011  123  83  53  S

101 0100  124  84  54  T

101 0101  125  85  55  U

101 0110  126  86  56  V

101 0111  127  87  57  W

101 1000  130  88  58  X

101 1001  131  89  59  Y

101 1010  132  90  5A  Z

101 1011  133  91  5B  [

101 1100  134  92  5C  \

101 1101  135  93  5D  ]

101 1110  136  94  5E  ^

101 1111  137  95  5F  _

Binary  Oct  Dec  Hex  Glyph

110 0000  140  96  60  `

110 0001  141  97  61  a

110 0010  142  98  62  b

110 0011  143  99  63  c

110 0100  144  100  64  d

110 0101  145  101  65  e

110 0110  146  102  66  f

110 0111  147  103  67  g

110 1000  150  104  68  h

110 1001  151  105  69  i

110 1010  152  106  6A  j

110 1011  153  107  6B  k

110 1100  154  108  6C  l

110 1101  155  109  6D  m

110 1110  156  110  6E  n

110 1111  157  111  6F  o

111 0000  160  112  70  p

111 0001  161  113  71  q

111 0010  162  114  72  r

111 0011  163  115  73  s

111 0100  164  116  74  t

111 0101  165  117  75  u

111 0110  166  118  76  v

111 0111  167  119  77  w

111 1000  170  120  78  x

111 1001  171  121  79  y

111 1010  172  122  7A  z

111 1011  173  123  7B  {

111 1100  174  124  7C  |

111 1101  175  125  7D  }

111 1110  176  126  7E  ~

 Streams 
A stream is a type of object from which we can take values, or to which we can pass values. This is done transparently in terms of the underlying code that demonstrates the use of the std::cout stream, known as the standard output stream.

// 'Hello World!' program 

#include <iostream>

int main()
{
  std::cout << "Hello World!" << std::endl;
  return 0;
}

Almost all input and output one ever does can be modeled very effectively as a stream. Having one common model means that one only has to learn it once. If you understand streams, you know the basics of how to output to files, the screen, sockets, pipes, and anything else that may come up.

A stream is an object that allows one to push data in or out of a medium, in order. Usually a stream can only output or can only input. It is possible to have a stream that does both, but this is rare. One can think of a stream as a car driving along a one-way street of information. An output stream can insert data and move on. It (usually) cannot go back and adjust something it has already written. Similarly, an input stream can read the next bit of data and then wait for the one that comes after it. It does not skip data or rewind and see what it had read five minutes ago.

The semantics of what a stream's read and write operations do depend on the type of stream. In the case of a file, an input file stream reads the file's contents in order without rewinding, and an output file stream writes to the file in order. For a console stream, output means displaying text, and input means getting input from the user via the console. If the user has not inputted anything, then the program blocks, or waits, for the user to enter in something.

 iostream 
c++ program that uses iostream to save output to the file
iostream is a header file used for input/output. It is part of the C++ standard library. The name stands for Input/Output Stream. In C++ there is no special syntax for streaming data input or output. Instead, these are combined as a library of functions. Like we have seen with the C Standard Library use of <cstdio> header, iostream provides basic OOP services for I/O.

The iostream automatically defines and uses a few standard objects:
 cin, an object of the istream class that reads data from the standard input device.
 cout, an object of the ostream class, which displays data to the standard output device.
 cerr, another object of the ostream class that writes unbuffered output to the standard error device.
 clog, like cerr, but uses buffered output.
for sending data to and from the standard streams input, output, error (unbuffered), and error (buffered) respectively. As part of the C++ standard library, these objects are a part of the std namespace.

Standard input, output, and error 
The most common streams one uses are cout, cin, and cerr (pronounced "c out", "c in", and "c err(or)", respectively). They are defined in the header <iostream>. Usually, these streams read and write from a console or terminal. In UNIX-based operating systems, such as Linux and Mac OS X, the user can redirect them to other files, or even other programs, for logging or other purposes. They are analogous to stdout, stdin, and stderr found in C. cout is used for generic output, cin is used for input, and cerr is used for printing errors. (cerr typically goes to the same place as cout, unless one or both is redirected, but it is not buffered and allows the user to fine-tune which parts of the program's output is redirected where.)

 Output 
The standard syntax for outputting to a stream, in this case, cout, is

cout << some_data << some_more_data;

Example

#include <iostream>

using namespace std;

int main()
{
  int iA = 1;
  cout << "Hello, World! " << iA << '\n';

  return 0;
}

Result of Execution
Hello, World! 1

To add a line break, send a newline character, \n.
Using std::endl also outputs a newline character, but it also calls os.flush().

Example

#include <iostream>
#include <ostream>

using namespace std;

int main()
{
  int iA = 1;
  char ch = 13;
  cout << "Hello, World!" << "\n" << iA << "\n" << ch << endl;

  return 0;
}

Execution
Hello, World!
1

It is always a good idea to end your output with a blank line, so as to not mess up with user's terminals.

As seen in the "Hello, World!" program, we direct the output to std::cout. This means that it is a member of the standard library. For now, don't worry about what this means; we will cover the library and namespaces in later chapters.

What you do need to remember is that, in order to use the output stream, you must include a reference to the standard IO library, as shown here:

#include <iostream>

This opens up a number of streams, functions and other programming devices that we can now use. 
For this section, we are interested in two of these; std::cout and std::endl.

Once we have referenced the standard IO library, we can use the output stream very simply. To use a stream, give its name, then pipe something in or out of it, as shown:

std::cout << "Hello, World!";

The << operator feeds everything to the right of it into the stream. We have essentially fed a text object into the stream. That's as far as our work goes; the stream now decides what to do with that object. In the case of the output stream, it's printed on-screen.

We're not limited to only sending a single object type to the stream, nor indeed are we limited to one object a time. Consider the examples below:

 std::cout << "Hello, " << "Joe"<< std::endl;
 std::cout << "The answer to life, the universe and everything is " << 42 << std::endl;

As can be seen, we feed in various values, separated by a pipe character. The result comes out something like:

Hello, Joe
The answer to life, the universe and everything is 42

You will have noticed the use of std::endl throughout some of the examples so far. 
This is a special manipulator, which not only outputs a newline character but also calls os.flush().

 Input 
What would be the use of an application that only ever outputted information, but didn't care about what its users wanted? Minimal to none. Fortunately, inputting is as easy as outputting when you're using the stream.

The standard input stream is called std::cin and is used very similarly to the output stream. Once again, we instantiate the standard IO library:

#include <iostream>

This gives us access to std::cin (and the rest of that class). Now, we give the name of the stream as usual, and pipe output from it into a variable. A number of things have to happen here, demonstrated in the example below:

#include <iostream>
int main(int iArgc, char a_chArgv[]) {
  int iA;
  std::cout << "Hello! How old are you? ";
  std::cin >> iA;
  std::cout << "You're really " << iA << " years old?" << std::endl;

  return 0;
}

We instantiate the standard IO library as usual, and call our main function in the normal way. Now we need to consider where the user's input goes. This calls for a variable (discussed in a later chapter) that we declare as being called a.

Next, we send some output, asking the user for their age. The real input happens now; everything the user types until they hit Enter is going to be stored in the input stream. We pull this out of the input stream and save it in our variable.

Finally, we output the user's age, piping the contents of our variable into the output stream.

Note: You will notice that, if anything other than a whole number is entered, the program will crash. This is due to the way in which we set up our variable. Don't worry about this for now; we will cover variables later on.

 A Program Using User Input  
The following program inputs two numbers from the user and prints their sum:

 #include <iostream>

 int main()
 {
    int iNumber1, iNumber2;
    std::cout << "Enter number 1: ";
    std::cin >> iNumber1;
    std::cout << "Enter number 2: ";
    std::cin >> iNumber2;
    std::cout << "The sum of " << iNumber1 << " and " << iNumber2 << " is "
               << iNumber1 + iNumber2 << ".\n";
    return 0;
 }

Just like std::cout that represents the standard output stream, the C++ library provides (and the iostream header declares) the object std::cin representing standard input, which usually gets input from the keyboard. The statement:

 std::cin >> iNumber1;

uses the extraction operator (>>) to get an integer input from the
user. When used to input integers, any leading whitespace is skipped, a sequence of valid digits optionally preceded by a + or - sign is read and the value stored in the variable. Any remaining characters in the user input are not consumed. These would be considered next time some input operation is performed.

If you want the program to use a function from a specific namespace, normally you must specify which namespace the function is in. The above example calls to cout, which is a member of the std namespace (hence std::cout). If you want a program to specifically use the std namespace for an identifier, which essentially removes the need for all future scope resolution (e.g. std::), you could write the above program like this:

#include <iostream>

using namespace std;

int main()
{
    int iNumber1, iNumber2;
    cout << "Enter number 1: ";
    cin >> iNumber1;
    cout << "Enter number 2: ";
    cin >> iNumber2;
    cout << "The sum of " << iNumber1 << " and " << iNumber2 << " is "
               << iNumber1 + iNumber2 << ".\n";
    return 0;
}

Please note that 'std' namespace is the namespace defined by standard C++ library.

 Manipulators 
A manipulator is a function that can be passed as an argument to a stream in different circumstances. For example, the manipulator 'hex' will cause the stream object to format subsequent integer input to the stream in hexadecimal instead of decimal. Likewise, 'oct' results in integers displaying in octal, and 'dec' reverts back to decimal.

Example

#include <iostream>
using namespace std;

int main()
{
  cout << dec << 16 << ' ' << 10 << "\n";
  cout << oct << 16 << ' ' << 10 << "\n";
  cout << hex << 16 << ' ' << 10 << endl;

  return 0;
}

Execution
16 10
20 12
10 a

There are many manipulators that can be used in conjunction with streams to simplify the formatting of input. For example, 'setw()' sets the field width of the data item next displayed. Used in conjunction with 'left' and 'right'(that set the justification of the data), 'setw' can easily be used to create columns of data.

Example

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
	cout << setw(10) << right << 90 << setw(8) << "Help!\n";
	cout << setw(10) << left << 45 << setw(8) << "Hi!" << endl;

	return 0;
}

Execution
        90   Help!
45        Hi!

The data in the top row display at the right of the columns created by 'setw', while in the next row, the data is left justified in the column.
Please note the inclusion of a new library 'iomanip'. Most formatting manipulators require this library.

Here are some other manipulators and their uses:

 Manipulator  Function

 boolalpha  displays boolean values as 'true' and 'false' instead of as integers.

 noboolalpha  forces bools to display as integer values

 showuppercase  converts strings to uppercase before displaying them

 noshowuppercase  displays strings as they are received, instead of in uppercase

 fixed  forces floating point numbers to display with a fixed number of decimal places

 scientific  displays floating point numbers in scientific notation

 Buffers 
Most stream objects, including 'cout' and 'cin', have an area in memory where the information they are transferring sits until it is asked for. This is called a 'buffer'. Understanding the function of buffers is essential to mastering streams and their use.

 Example 

#include <iostream>
using namespace std;

int main()
{
  int iNumber1, iNumber2;
  cin >> iNumber1;
  cin >> iNumber2;

  cout << "Number1: " << iNumber1 << "\n"
       << "Number2: " << iNumber2 << endl;

  return 0;
}

 Execution 1 
>74
>27
Number1: 74
Number2: 27

The inputs are given separately, with a hard return between them. '>' denotes user input.

 Execution 2 
>74 27
Number1: 74
Number2: 27

The inputs are entered on the same line. They both go into the 'cin' stream buffer, where they are stored until needed. As 'cin' statements are executed, the contents of the buffer are read into the appropriate variables.

 Execution 3 
>74 27 56
Number1: 74
Number2: 27

In this example, 'cin' received more input than it asked for. The third number it read in, 56, was never inserted into a variable. It would have stayed in the buffer until 'cin' was called again. The use of buffers can explain many strange behaviors that streams can exhibit.

 Example 

#include <iostream>
using namespace std;

int main()
{
  int iNumber1, iNumber2, iNumber3;
  cin >> iNumber1 >> iNumber2;

  cout << "Number1: " << iNumber1 << "\n"
    << "Number2: " << iNumber2 << endl;

  cin >> iNumber3;

  cout << "Number3: " << iNumber3 << endl;

  return 0;
}

 Execution 
>45 89 37
Number1: 45
Number2: 89
Number3: 37

Notice how all three numbers were entered at the same time in one line, but the stream only pulled them out of the buffer when they were asked for. This can cause unexpected output, since the user might accidentally put an extra space into his input. A well written program will test for this type of unexpected input and handle it gracefully.

 ios 
ios is a header file in the C++ standard library that defines several types and functions basic to the operation of iostreams. This header is typically included automatically by other iostream headers. Programmers rarely include it directly.

 Typedefs 

 Name  description

ios  Supports the ios class from the old iostream library.

streamoff  Supports internal operations.

streampos  Holds the current position of the buffer pointer or file pointer.

streamsize  Specifies the size of the stream.

wios  Supports the wios class from the old iostream library.

wstreampos  Holds the current position of the buffer pointer or file pointer.

Manipulators

 Name  description

boolalpha  Specifies that variables of type bool appear as true or false in the stream.

dec  Specifies that integer variables appear in base 10 notation.

fixed  Specifies that a floating-point number is displayed in fixed-decimal notation.

hex  Specifies that integer variables appear in base 16 notation.

internal  Causes a number's sign to be left justified and the number to be right justified.

left  Causes text that is not as wide as the output width to appear in the stream flush with the left margin.

noboolalpha  Specifies that variables of type bool appear as 1 or 0 in the stream.

noshowbase  Turns off indicating the notational base in which a number is displayed.

noshowpoint  Displays only the whole-number part of floating-point numbers whose fractional part is zero.

noshowpos  Causes positive numbers to not be explicitly signed.

noskipws  Cause spaces to be read by the input stream.

nounitbuf  Causes output to be buffered and processed when the buffer is full.

nouppercase  Specifies that hexadecimal digits and the exponent in scientific notation appear in lowercase.

oct  Specifies that integer variables appear in base 8 notation.

right  Causes text that is not as wide as the output width to appear in the stream flush with the right margin.

scientific  Causes floating point numbers to be displayed using scientific notation.

showbase  Indicates the notational base in which a number is displayed.

showpoint  Displays the whole-number part of a floating-point number and digits to the right of the decimal point even when the fractional part is zero.

showpos  Causes positive numbers to be explicitly signed.

skipws  Cause spaces to not be read by the input stream.

unitbuf  Causes output to be processed when the buffer is not empty.

uppercase  Specifies that hexadecimal digits and the exponent in scientific notation appear in uppercase.

Classes

 Name  description

basic_ios  The template class describes the storage and member functions common to both input streams (of template class basic_istream) and output streams (of template class basic_ostream) that depend on the template parameters.

fpos  The template class describes an object that can store all the information needed to restore an arbitrary file-position indicator within any stream.

ios_base  The class describes the storage and member functions common to both input and output streams that do not depend on the template parameters.

 fstream 
With cout and cin, we can do basic communication with the user. For more complex io, we would like to read from and write to files. This is done with file stream classes, defined in the header <fstream>. ofstream is an output file stream, and ifstream is an input file stream.

Files
To open a file, one can either call open on the file stream or, more commonly, use the constructor. One can also supply an open mode to further control the file stream. Open modes include
ios::app Leaves the file's original contents and appends new data to the end.
ios::out Outputs new data in the file, removing the old contents. (default for ofstream)
ios::in  Reads data from the file. (default for ifstream)

Example

// open a file called Test.txt and write "HELLO, HOW ARE YOU?" to it
#include <fstream>

using namespace std;

int main()
{
  ofstream file1;

  file1.open("file1.txt", ios::app);
  file1 << "This data will be appended to the file file1.txt\n";
  file1.close();

  ofstream file2("file2.txt");
  file2 << "This data will replace the contents of file2.txt\n";

  return 0;
}

The call to close() can be omitted, if you do not care about the return value (whether it succeeded); the destructors will call close when the object goes out of scope.

If an operation (e.g. opening a file) was unsuccessful, a flag is set in the stream object. You can check the flags' status using the bad() or fail() member functions, which return a boolean value. The stream object doesn't throw any exceptions in such a situation; hence manual status check is required. See reference for details on bad() and fail().

 Text input until EOF/error/invalid input 
Input from the stream infile to a variable data until one of the following:
EOF reached on infile.
An error occurs while reading from infile (e.g., connection closed while reading from a remote file).
The input item is invalid, e.g. non-numeric characters, when data is of type int.

#include <iostream>

// …

while (infile >> data)
{
    // manipulate data here
}

Note that the following is not correct:

#include <iostream>

// …

while (!infile.eof())
{
    infile >> data; // wrong!
    // manipulate data here
}

This will cause the last item in the input file to be processed twice, because eof() does not return true until input fails due to EOF.

 ostream 
Classes and output streams
It is often useful to have your own classes' instances compatible with the stream framework. For instance, if you defined the class Foo like this:

 class Foo
 {
 public:

	Foo() : m_iX(1), m_iY(2)
	{
	}

	int m_iX, m_iY;
 };

You will not be able to pass its instance to cout directly using the '<<' operator, because it is not defined for these two objects (Foo and ostream). What needs to be done is to define this operator and thus bind the user-defined class with the stream class.

 ostream& operator<<(ostream& output, Foo& arg)
 {
	output << arg.m_iX << "," << arg.m_iY;
	return output;
 }

Now this is possible:

 Foo myObject;
 cout << "my_object's values are: " << myObject << endl;

The operator function needs to have 'ostream&' as its return type, so chaining output works as usual between the stream and objects of type Foo:

 Foo my1, my2, my3;
 cout << my1 << my2 << my3;

This is because (cout << my1) is of type ostream&, so the next argument (my2) can be appended to it in the same expression, which again gives an ostream& so my3 can be appended and so on.

If you decided to restrict access to the member variables m_iX and m_iY (that is probably a good idea) within the class Foo, i.e.:

 class Foo
 {
 public:

	Foo() : m_iX(1), m_iY(2)
	{
	}

 private:
	int m_iX, m_iY;
 };

you will have trouble, because operator<< function doesn't have access to the private variables of its second argument. There are two possible solutions to this problem:

1. Within the class Foo, declare the operator<< function as the classes' friend that grants it access to private members, i.e. add the following line to the class declaration:

 friend ostream& operator<<(ostream& output, Foo& arg);

Then define the operator<< function as you normally would (note that the declared function is not a member of Foo, just its friend, so don't try defining it as Foo::operator<<).

2. Add public-available functions for accessing the member variables and make the operator<< function use these instead:

 class Foo
 {
 public:

	Foo() : m_iX(1), m_iY(2)
	{
	}

	int getX()
	{
		return m_iX;
	}

	int getY()
	{
		return m_iY;
	}

 private:
	int m_iX, m_iY;
 };

 ostream& operator<<(ostream& output, Foo& arg)
 {
	output << iArg.getX() << "," << iArg.getY();
	return output;
 }

 ‎Rounding number example 
This is a small example that rounds a number to a string, a function called RoundToString. Figures may have trailing zeros, those that would be expected to disappear using a number format.

The constant class contains repeating constants that should exist only once in the code so that to avoid inadvertent changes. (If the one constant is changed inadvertently, it is most likely to be seen, as it is used at several locations.)

The code was first cross-compiled by the JAVA TO C++ CONVERTER of Tangible Software Solutions. Parts may have a copyright notice requirement that prevents inclusion in this work you can get yourself the code for the StringConverter at that location.

Here is the relevant code and its call. You are invited to write a shorter version that gives the same result.

Common.cpp:

#include "StdAfx.h"

namespace common
{
    double const Common::NEARLY_ZERO = 1E-4;
    double const Common::VERY_LARGE = 1E10;
    string const Common::strZERO = *new string(1, Common::ZERO);

    bool Common::IsTrimmable(char const chCHARACTER,
        char const chTRIM,
        bool const bIS_NUMERIC)
    {
        return ((chCHARACTER == chTRIM)
            || (bIS_NUMERIC && (chCHARACTER == Common::ZERO)));
    }

    string const& Common::Trim(string const& strVALUE, char const chTRIM)
    {
        return TrimLeft(TrimRight(strVALUE, chTRIM), chTRIM);
    }

    string const& Common::TrimLeft(string const& strVALUE,
            char const chTRIM)
    {
        if (strVALUE.length() == 0) return strVALUE;
        else
        {
            ushort usPosition = 0;

            for (; usPosition < strVALUE.length(); usPosition++)
            {
                if (!IsTrimmable(strVALUE[usPosition], chTRIM)) break;
            }

            return *new string(strVALUE.substr(usPosition));
        }
    }

    string const& Common::TrimRight(string const& strVALUE,
        char const chTRIM)
    {
        if (strVALUE.length() == 0) return strVALUE;
        else
        {
            ushort usPosition = strVALUE.length() - 1;

            for (; usPosition < strVALUE.length(); usPosition--)
            {
                if (!IsTrimmable(strVALUE[usPosition], chTRIM))
                {
                    if (strVALUE[usPosition] != Common::PERIOD) ++usPosition;

                    break;
                }
            }

            return *new string(strVALUE.substr(0, usPosition));
        }
    }
}

Common.h:

#pragma once

#include <string>

namespace common
{
    /// <summary>
    /// Class that comprises of constant values and recurring algorithms.
    /// 
    /// @author Saban
    /// 
    ///</summary>
    class Common
    {
        /// <summary>
        /// Determines, if the character is trimmable or not.
        /// </summary>
        /// <param name="chCHARACTER">Character to be checked</param>
        /// <param name="chTRIM">
        /// Trim character that defaults to a space
        /// </param>
        /// <param name="bIS_NUMERIC">
        /// If numeric, zeros are also considered as trimmable characters
        /// </param>
        /// <returns>Whether the character is trimmable or not</returns>
        static bool IsTrimmable(char const chCHARACTER,
            char const chTRIM = SPACE, bool const bIS_NUMERIC = true);

    public:
        /// <summary>Carriage return constant</summary>
        //static char const CARRIAGE_RETURN = '\r';
        /// <summary>Constant of comma or decimal point in German</summary>
        static char const COMMA = ',';
        /// <summary>Dash or minus constant</summary>
        static char const DASH = '-';
        /// <summary>
        /// The exponent sign in a scientific number, or the letter e.
        /// </summary>
        static char const EXPONENT = 'e';
        /// <summary>The full stop or period</summary>
        static char const PERIOD = '.';
        /// <summary>Space constant</summary>
        static char const SPACE = ' ';
        /// <summary>Space constant</summary>
        static char const ZERO = '0';
        /// <summary>
        //// Value under which the double should switch to fixed-point.
        /// </summary>
        static double const VERY_LARGE;
        /// <summary>
        //// Value above which the double should switch to fixed-point.
        /// </summary>
        static double const NEARLY_ZERO;
          /// <summary>
          /// The zero string constant used at several places
        /// </summary>
          static string const strZERO;

        /// <summary>
        /// Trims the trim character from left and right of the value.
        /// </summary>
        /// <param name="strVALUE">Value to be trimmed</param>
        /// <param name="chTRIM">
        /// Trim character that defaults to a space
        /// </param>
        /// <returns>Trimmed string</returns>
        static string const& Trim(string const& strVALUE,
            char const chTRIM = Common::SPACE);

        /// <summary>
        /// Trims the trim character from left the value.
        /// </summary>
        /// <param name="strVALUE">Value to be trimmed</param>
        /// <param name="chTRIM">
        /// Trim character that defaults to a space
        /// </param>
        /// <returns>Trimmed string</returns>
        static string const& TrimLeft(string const& strVALUE,
            char const chTRIM = Common::SPACE);

        /// <summary>
        /// Trims the trim character from right of the value.
        /// </summary>
        /// <param name="strVALUE">Value to be trimmed</param>
        /// <param name="chTRIM">
        /// Trim character that defaults to a space
        /// </param>
        /// <returns>Trimmed string</returns>
        static string const& TrimRight(string const& strVALUE,
            char const chTRIM = Common::SPACE);
    }; // class Common
}

The Math class is an enhancement to the <math.h> library and contains the rounding calculations.

Math.cpp:

#include "StdAfx.h"
#include <string>

namespace common
{
    string const Maths::strZEROS = "000000000000000000000000000000000";

    byte Maths::CalculateMissingSignificantZeros(
        byte const ySIGNIFICANTS_AFTER,
        char const chSEPARATOR,
        double const dVALUE,
        string const strMANTISSA)
    {
        // Existing significants after decimal separator are
        byte const yAFTER = FindSignificantsAfterDecimal(chSEPARATOR, strMANTISSA);
        // Number of digits to add are
        byte const yZEROS = ySIGNIFICANTS_AFTER - ((yAFTER == 0) ? 1 : yAFTER);

        return ((yZEROS >= 0) ? yZEROS : 0);
    }

    byte Maths::FindDecimalSeparatorPosition(string const& strVALUE)
    {
        byte const ySEPARATOR_AT = (byte)strVALUE.find(Common::PERIOD);

        return (ySEPARATOR_AT > -1)
            ? ySEPARATOR_AT : (byte)strVALUE.find(Common::COMMA);
    }

    byte Maths::FindFirstNonZeroDigit(double const dVALUE)
    {
        return FindFirstNonZeroDigit(StringConverter::ToString
            <double, StringConverter::DIGITS>(dVALUE));
    }

    byte Maths::FindFirstNonZeroDigit(string const& strVALUE)
    {
        // Find the position of the first non-zero digit:
        byte yNonZeroAt = 0;

        for (; (yNonZeroAt < (byte)strVALUE.length())
            && ((strVALUE[yNonZeroAt] == Common::DASH)
            || (strVALUE[yNonZeroAt] == Common::PERIOD)
            || (strVALUE[yNonZeroAt] == Common::ZERO)); yNonZeroAt++) ;

        return yNonZeroAt;
    }

    byte Maths::FindSignificantDigits(byte const ySIGNIFICANTS_AFTER,
        char const chSEPARATOR,
        double const dVALUE)
    {
        if (dVALUE == 0) return 0;
        else
        {
//JAVA TO C++ CONVERTER TODO TASK: No native C++ equivalent to 'ToString':
            string strMantissa = FindMantissa(TestCommons::SIGNIFICANTS,
                chSEPARATOR, StringConverter::ToString<double,
                StringConverter::DIGITS>(dVALUE));

            if (dVALUE == static_cast<long>(dVALUE))
            {
                strMantissa =
                    strMantissa.substr(0, strMantissa.find(Common::COMMA));
            }

            strMantissa = RetrieveDigits(chSEPARATOR, strMantissa);

            return strMantissa.substr(
                FindFirstNonZeroDigit(strMantissa)).length();
        }
    }

    byte Maths::FindSignificantsAfterDecimal(byte const ySIGNIFICANTS_BEFORE,
        byte const ySIGNIFICANT_DIGITS)
    {
        byte const yAFTER_DECIMAL = ySIGNIFICANT_DIGITS - ySIGNIFICANTS_BEFORE;

        return (yAFTER_DECIMAL > 0) ? yAFTER_DECIMAL : 0;
    }

    byte Maths::FindSignificantsAfterDecimal(char const chSEPARATOR,
        double const dVALUE)
    {
        if (dVALUE == 0) return 1;
        else
        {
//JAVA TO C++ CONVERTER TODO TASK: No native C++ equivalent to 'ToString':
            string strValue = StringConverter::ToString<double,
                StringConverter::DIGITS>(dVALUE);

            byte const ySEPARATOR_AT = (byte)strValue.find(chSEPARATOR);

            if (ySEPARATOR_AT > -1)
            {
                strValue = strValue.substr(ySEPARATOR_AT + 1);
            }

            short const sE_AT = strValue.find(Common::EXPONENT);

            if (sE_AT > 0) strValue = strValue.substr(0, sE_AT);

            long lValue = StringConverter::FromString
                <long, StringConverter::DIGITS>(strValue);

            if (abs(dVALUE) < 1)
            {
                return (byte)StringConverter::ToString<long,
                    StringConverter::DIGITS>(lValue).length();
            }
            else if (lValue == 0) return 0;
            else
            {
                strValue = "0." + strValue;

                return (byte)(strValue.length() - 2);
            }
        }
    }

    byte Maths::FindSignificantsBeforeDecimal(char const chSEPARATOR,
        double const dVALUE)
    {
        string const strVALUE = StringConverter::ToString<double,
            StringConverter::DIGITS>(dVALUE);

        // Return immediately, if result is clear: Special handling at
        // crossroads of floating point and exponential numbers:
        if ((dVALUE == 0)
            || (abs(dVALUE) >= Common::NEARLY_ZERO) && (abs(dVALUE) < 1))
        {
            return 0;
        }
        else if ((abs(dVALUE) > 0) && (abs(dVALUE) < Common::NEARLY_ZERO))
        {
            return 1;
        }
        else
        {
            byte significants = 0;
            // Significant digits to the right of decimal separator:
            for (byte s = 0; s < (byte)strVALUE.length(); s++)
            {
                if ((strVALUE[s] == chSEPARATOR)
                    || (strVALUE[s] == Common::EXPONENT))
                {
                    break;
                }
                else if (strVALUE[s] != Common::DASH) significants++;
            }

            return significants;
        }
    }

    byte Maths::FindSignificantsAfterDecimal(char const chSEPARATOR,
        string const strVALUE)
    {
        size_t const COMMA_AT = strVALUE.find(chSEPARATOR);
        size_t const LENGTH = strVALUE.length();
        // Existing digits after decimal separator are
        byte yAfter = 0;
        // Existing significants after decimal separator may start at the first
        // non-zero digit:
        if (StringConverter::FromString<double, 5>
            (strVALUE.substr(0, COMMA_AT)) == 0)
        {
            string strRightOf = Common::TrimLeft(strVALUE.substr(COMMA_AT + 1));

            yAfter = strRightOf.length();
        }
        else yAfter = (COMMA_AT < string::npos) ? LENGTH - 1 - COMMA_AT : 0;

        return yAfter;
    }

    double Maths::Power(short const sBASIS, short const sEXPONENT)
    {
        if (sBASIS == 0) return (sEXPONENT != 0) ? 1 : 0;
        else
        {
            if (sEXPONENT == 0) return 1;
            else
            {
                // The Math method power does change the least significant 
                // digits after the decimal separator and is therefore useless.
                double result = 1;

                if (sEXPONENT > 0)
                {
                    for (short s = 0; s < sEXPONENT; s++) result *= sBASIS;
                }
                else if (sEXPONENT < 0)
                {
                    for (short s = sEXPONENT; s < 0; s++) result /= sBASIS;
                }

                return result;
            }
        }
    }

    double Maths::Round(byte const yDIGITS,
        char const chSEPARATOR,
        double const dVALUE)
    {
        if (dVALUE == 0) return 0;
        else
        {
            bool bIsScientific = false;
            double const dCONSTANT = Power(10, yDIGITS);

            if ((abs(dVALUE) < Common::NEARLY_ZERO)
                || (abs(dVALUE) >= Common::VERY_LARGE))
            {
                bIsScientific = true;
            }

            short const sEXPONENT =
                FindExponent(dVALUE, chSEPARATOR, bIsScientific);

            short sExponent = sEXPONENT;

            // Determine the correcting power:
            short sPower = sExponent;

            if (sEXPONENT == 0)
            {
                sPower = FindExponent(dVALUE, chSEPARATOR, HasDecimals(dVALUE));
            }

            double dValue1 = dVALUE*dCONSTANT*pow(10., -sPower);

            string const strE_SIGN = (sExponent < 0)
                ? StringConverter::ToString<char,
                StringConverter::DIGITS>(Common::DASH) : "";

            if (sExponent != 0)
            {
                sExponent = static_cast<short>(abs(sExponent));
                dValue1 = Round(dValue1);
            }
            else dValue1 = Round(dValue1)/dCONSTANT/pow(10., -sPower);

            // Power method cannot be used, as the exponentiated number may
            // exceed the maximal long value.
            sExponent -= Signum(sEXPONENT)*(FindSignificantDigits(
                yDIGITS, chSEPARATOR, dValue1) - 1);

            if (sEXPONENT != 0)
            {
//JAVA TO C++ CONVERTER TODO TASK: No native C++ equivalent to 'ToString':
                string strValue = StringConverter::ToString<double,
                    StringConverter::DIGITS>(dValue1);

//JAVA TO C++ CONVERTER TODO TASK: No native C++ equivalent to 'ToString':
                strValue =
                    strValue.substr(0, FindDecimalSeparatorPosition(strValue))
                    + Common::EXPONENT + strE_SIGN
                    + StringConverter::ToString<short,
                    StringConverter::DIGITS>(sExponent);

                dValue1 = StringConverter::FromString<double, 5>(strValue);
            }

            return dValue1;
        }
    }

    double Maths::Round(double const dValue)
    {
        return (double)(long long)(dValue + .5);
    }

    short Maths::FindExponent(double const dVALUE,
        char const chSEPARATOR,
        bool const bSCIENTIFIC)
    {
//JAVA TO C++ CONVERTER TODO TASK: No native C++ equivalent to 'ToString':
        return (short)StringConverter::FromString<short,
            StringConverter::DIGITS>(FindExponent(StringConverter::ToString
            <double, StringConverter::DIGITS>(dVALUE), chSEPARATOR,
            bSCIENTIFIC));
    }

    string Maths::FindExponent(string const& strVALUE,
        char const chSEPARATOR,
        bool const bSCIENTIFIC)
    {
        if (StringConverter::FromString
            <double, StringConverter::DIGITS>(strVALUE) == 0)
        {
            return Common::strZERO;
        }

        short const sE_AT = strVALUE.find(Common::EXPONENT);
        short sExponent = 0;

        if (sE_AT < 0)
        {
            // If all numbers are to be considered scientific, such as
            // 1 = 1.0000e0…
            if (bSCIENTIFIC)
            {
                // Find the exponent by counting leading zeros:
                byte const ySEPARATOR_AT = strVALUE.find(chSEPARATOR);

                if (ySEPARATOR_AT > -1)
                {
                    string const strAFTER = strVALUE.substr(ySEPARATOR_AT + 1);
                    sExponent = 0;

                    for (; sExponent < (short)strAFTER.length(); sExponent++)
                    {
                        if ((strAFTER[sExponent] >= '1')
                            && (strAFTER[sExponent] <= '9'))
                        {
                            sExponent *= -1;
                            break;
                        }
                    }
                }
            }
            else return Common::strZERO;
        }
        else
        {
            sExponent = (short)StringConverter::FromString
                <double, StringConverter::DIGITS>(strVALUE.substr(sE_AT + 1));
        }

        return StringConverter::ToString<short,
            StringConverter::DIGITS>(sExponent);
    }

    string Maths::FindMantissa(byte const yDIGITS,
        char const chSEPARATOR,
        const string& strVALUE)
    {
        byte yDigits = yDIGITS;
        short const sE_AT = strVALUE.find(Common::EXPONENT);
        string strValue = strVALUE;

        // Remove lagging insignificant zeros, if any:
        if (sE_AT == -1)
        {
            if (StringConverter::FromString<short,
                3>(strValue.substr(0, 2)) == 0)
            {
                byte yPosition = 2;

                for (; (yPosition < (byte)strValue.length())
                    && ((strValue[yPosition] == Common::PERIOD)
                    || (strValue[yPosition] == Common::ZERO)); yPosition++);

                yDigits += yPosition;

                strValue = strValue.substr(0, yDigits);
            }
        }
        else strValue = Common::TrimRight(strValue.substr(0, sE_AT));

        if (StringConverter::FromString<double, StringConverter::DIGITS>(strValue) == 0)
        {
            strValue = RemoveInsignificants(yDIGITS, strValue);
        }
        else strValue = RemoveInsignificants(yDigits, strValue);

        if (FindDecimalSeparatorPosition(strValue) == -1)
        {
            return strValue + ".0";
        }
        else return strValue;
    }

    string Maths::RemoveInsignificants(byte const yDIGITS,
        string const& strVALUE)
    {
        byte const yCHARACTERS = yDIGITS
            + ((FindDecimalSeparatorPosition(strVALUE) < string::npos) ? 1 : 0)
            + ((strVALUE[0] == Common::DASH)
            ? ((strVALUE[1] == Common::ZERO) ? 2 : 1)
            : ((strVALUE[0] == Common::ZERO) ? 1 : 0));

        return strVALUE.substr(0, yCHARACTERS);
    }

    string Maths::RetrieveDigits(char const chSEPARATOR, const string& strNUMBER)
    {
        string strNumber = strNUMBER;

        short const sE_AT = strNumber.find(Common::EXPONENT);
        // Strip off exponent part, if it exists:
        if (sE_AT > -1) strNumber = strNumber.substr(0, sE_AT);

//JAVA TO C++ CONVERTER TODO TASK: No native C++ equivalent to 'ToString':
//JAVA TO C++ CONVERTER TODO TASK: No native C++ equivalent to 'replace':
        return StringConverter::Replace(StringConverter::Replace(strNumber,
            StringConverter::ToString<char, 1>(Common::DASH), ""),
            StringConverter::ToString<char, 1>(chSEPARATOR), "");
    }

    string Maths::RoundToString(byte const ySIGNIFICANT_DIGITS,
        char const chSEPARATOR,
        double dValue)
    {
        // Number of significants that *are* before the decimal separator:
//JAVA TO C++ CONVERTER TODO TASK: No native C++ equivalent to 'ToString':
        byte const ySIGNIFICANTS_BEFORE =
            FindSignificantsBeforeDecimal(chSEPARATOR, dValue);
        // Number of decimals that *should* be after the decimal separator:
        byte const ySIGNIFICANTS_AFTER = FindSignificantsAfterDecimal(
            ySIGNIFICANTS_BEFORE, ySIGNIFICANT_DIGITS);

        byte const yDIGITS = (dValue != 0)
            ? ySIGNIFICANTS_BEFORE + ySIGNIFICANTS_AFTER : 3 /* = 0.0 */;
        // Round to the specified number of digits after decimal separator:
        double const dROUNDED =
            Maths::Round(ySIGNIFICANTS_AFTER, chSEPARATOR, dValue);

//JAVA TO C++ CONVERTER TODO TASK: No native C++ equivalent to 'ToString':
        string const strEXPONENT = FindExponent(StringConverter::ToString
            <double, StringConverter::DIGITS>(dROUNDED));
//JAVA TO C++ CONVERTER TODO TASK: No native C++ equivalent to 'ToString':
        string const strMANTISSA = FindMantissa(TestCommons::SIGNIFICANTS,
            chSEPARATOR, StringConverter::ToString<double,
            StringConverter::DIGITS>(dROUNDED));

        double const dMANTISSA = StringConverter::FromString
            <double, TestCommons::SIGNIFICANTS>(strMANTISSA);
        StringBuilder* pRESULT = new StringBuilder(strMANTISSA);

        // Determine the significant digits in this number:
        byte const ySIGNIFICANTS = FindSignificantDigits(ySIGNIFICANTS_AFTER,
            chSEPARATOR, dMANTISSA);
        // Add lagging zeros, if necessary:
        if (ySIGNIFICANTS <= ySIGNIFICANT_DIGITS)
        {
            if (ySIGNIFICANTS_AFTER != 0)
            {
                if (dValue != 0)
                {
                    pRESULT->Append(strZEROS.substr(0,
                        CalculateMissingSignificantZeros(ySIGNIFICANTS_AFTER,
                        chSEPARATOR, dMANTISSA, strMANTISSA)));
                }
            }
            else
            {
                // Cut off the decimal separator & after decimal digits:
//JAVA TO C++ CONVERTER TODO TASK: No native C++ equivalent to 'ToString':
                byte const yDECIMAL =
                    pRESULT->Find(StringConverter::ToString<char,
                    StringConverter::DIGITS>(chSEPARATOR));

                if (yDECIMAL > -1) pRESULT->SetLength(yDECIMAL);
            }
        }
        else if (ySIGNIFICANTS_BEFORE > ySIGNIFICANT_DIGITS)
        {
            dValue /= Power(10, ySIGNIFICANTS_BEFORE - ySIGNIFICANT_DIGITS);

            dValue = Round(dValue);

            byte const yDIGITS = ySIGNIFICANT_DIGITS + ((dValue < 0) ? 1 : 0);
//JAVA TO C++ CONVERTER TODO TASK: No native C++ equivalent to 'ToString':
            string const strVALUE = StringConverter::ToString<double,
                StringConverter::DIGITS>(dValue).substr(0, yDIGITS);
            pRESULT->SetLength(0);

            pRESULT->Append(strVALUE + strZEROS.substr(0,
                ySIGNIFICANTS_BEFORE - ySIGNIFICANT_DIGITS));
        }

        if (StringConverter::FromString<double,
            StringConverter::DIGITS>(strEXPONENT) != 0)
        {
            pRESULT->Append(Common::EXPONENT + strEXPONENT);
        }

//JAVA TO C++ CONVERTER TODO TASK: No native C++ equivalent to 'ToString':
        return pRESULT->ToString();
    } // public static String RoundToString(…)
}

Math.h:

#pragma once

#include <string>
#include <cmath>

/// 
namespace common
{
    /// <summary>
    /// Class for special mathematical calculations.
    /// ATTENTION: Should not depend on any other class except Java libraries!
    /// @author Saban
    ///</summary>
    class Maths
    {
    private:
        /// <summary>The string of zeros</summary>
        static string const strZEROS;

        /// <summary>
        /// Determines how many zeros are to be appended after the decimal
        /// digits.
        /// </summary>
        /// <param name="ySIGNIFICANTS_AFTER">
        /// Requested significant digits after decimal
        /// </param>
        /// <param name="chSEPARATOR">
        /// Language-specific decimal separator
        /// </param>
        /// </param>
        /// <param name="dVALUE">Rounded number</param>
        /// <param name="strMANTISSA">
        /// Current string where missing digits are to be determined
        /// </param>
        /// <returns>Requested value</returns>
        static byte CalculateMissingSignificantZeros(
            byte const ySIGNIFICANTS_AFTER, char const chSEPARATOR,
            double const dVALUE,
            string const strMANTISSA = "");

        /// <summary>
        /// Finds the decimal position language-independently.
        /// </summary>
        /// <param name="strVALUE">
        /// Value to be searched for the decimal separator
        /// </param>
        /// <returns>
        /// The position of the decimal separator or string::npos,
        /// if no decimal separator has been found.
        /// </returns>
        static byte FindDecimalSeparatorPosition(string const& strVALUE);

        /// <summary>
        /// Finds the first non-zero decimal position.
        /// </summary>
        /// <param name="dVALUE">
        /// Value to be searched for the decimal position
        /// </param>
        /// <returns>The first non-zero decimal position</returns>
        static byte FindFirstNonZeroDigit(double const dVALUE);

        /// <summary>
        /// Finds the first non-zero decimal position.
        /// </summary>
        /// <param name="strVALUE">
        /// Value to be searched for the decimal position
        /// </param>
        /// <returns>The first non-zero decimal position</returns>
        static byte FindFirstNonZeroDigit(string const& strVALUE);

        /// <summary>
        /// Calculates the number of all significant digits (without the sign
        /// and the decimal separator).
        /// </summary>
        /// <param name="ySIGNIFICANTS_AFTER">
        /// Number of decimal places after the separator</param>
        /// <param name="chSEPARATOR">
        /// Language-specific decimal separator
        /// </param>
        /// <param name="dVALUE">
        /// Value where the digits are to be counted
        /// </param>
        /// <returns>Number of significant digits</returns>
        static byte FindSignificantDigits(byte const ySIGNIFICANTS_AFTER,
            char const chSEPARATOR, double const dVALUE);

        /// <summary>
        /// Determines the number of significant digits after the decimal
        /// separator knowing the total number of significant digits and the
        /// number before the decimal separator.
        /// </summary>
        /// <param name="ySIGNIFICANTS_BEFORE">
        /// Number of significant digits before separator
        /// </param>
        /// <param name="ySIGNIFICANT_DIGITS">
        /// Number of all significant digits
        /// </param>
        /// Number of significant decimals after the separator
        /// </returns>
        static byte FindSignificantsAfterDecimal(
            byte const ySIGNIFICANTS_BEFORE, byte const ySIGNIFICANT_DIGITS);

        /// <summary>
        /// Finds the significant digits after the decimal separator of a
        /// mantissa.
        /// </summary>
        /// <param name="chSEPARATOR">
        /// Language-specific decimal separator
        /// </param>
        /// <param name="dVALUE">Value to be scrutinised</param>
        /// <returns>
        /// Number of insignificant zeros after decimal separator.
        /// </returns>
        static byte FindSignificantsAfterDecimal(char const chSEPARATOR,
            double const dVALUE);

        /// <summary>
        /// Finds the significant digits after the decimal separator of a
        /// mantissa.
        /// </summary>
        /// <param name="chSEPARATOR">
        /// Language-specific decimal separator
        /// </param>
        /// <param name="strVALUE">Value to be scrutinised</param>
        /// <returns>
        /// Number of insignificant zeros after decimal separator.
        /// </returns>
        static byte FindSignificantsAfterDecimal(char const chSEPARATOR,
            string const strVALUE);

        /// <summary>
        /// Determines the number of digits before the decimal point.</summary>
        /// <param name="chSEPARATOR">
        /// Language-specific decimal separator
        /// </param>
        /// <param name="dVALUE">Value to be scrutinised</param>
        /// <returns>Number of digits before the decimal separator</returns>
        static byte FindSignificantsBeforeDecimal(char const chSEPARATOR,
            double const dVALUE);

        /// <summary>
        /// Returns the exponent part of the double number.</summary>
        /// <param name="dVALUE">
        /// Value of which the exponent is of interest
        /// </param>
        /// <param name="chSEPARATOR">Decimal separator</param>
        /// <param name="bSCIENTIFIC">
        /// If true, the number is considered in scientific notation of the form
        /// 9.999e999 (like 1 = 1.0e0 or 0.124 = 1.24e-1).
        /// </param>
        /// <returns>Exponent of the number or zero.</returns>
        static short FindExponent(double const dVALUE,
            char const chSEPARATOR = Common::PERIOD,
            bool const bSCIENTIFIC = false);

        /// <summary>
        /// Finds the exponent of a number.</summary>
        /// <param name="strVALUE">
        /// Value where an exponent is to be searched
        /// </param>
        /// <param name="chSEPARATOR">Decimal separator</param>
        /// <param name="bSCIENTIFIC">
        /// If true, the number is considered in scientific notation of the form
        /// 1 = 1.0e0 or 0.124 = 1.24e-1.
        /// </param>
        /// <returns>Exponent, if it exists, or "0"</returns>
        static string FindExponent(string const& strVALUE,
            char const chSEPARATOR = Common::PERIOD,
            bool const bSCIENTIFIC = false);

        /// <summary>
        /// Finds the mantissa of a number.</summary>
        /// <param name="yDIGITS">
        /// Number of all digits
        /// </param>
        /// <param name="chSEPARATOR">
        /// Language-specific decimal separator
        /// </param>
        /// <param name="strVALUE">
        /// Value where the mantissa is to be found
        /// </param>
        /// <returns>Mantissa of the number</returns>
        static string FindMantissa(byte const yDIGITS,
            char const chSEPARATOR,
            string const& strVALUE);

        /// <summary>
        /// Removes all insignificant digits.</summary>
        /// <param name="yDIGITS">
        /// Number of significant digits
        /// </param>
        /// <returns>Number with the requested number of digits</returns>
        static string RemoveInsignificants(byte const yDigits,
            string const& strVALUE);

        /// <summary>
        /// Retrieves the digits of the value without decimal separator or
        /// sign.
        /// </summary>
        /// <param name="chSEPARATOR"></param>
        /// <param name="strNUMBER">Mantissa to be scrutinised</param>
        /// <returns>The digits only</returns>
        static string RetrieveDigits(char const chSEPARATOR,
            string const& strNUMBER);

    public:
        /// <summary>
        /// Determines whether the number has decimal places after 
        /// the separator or not.
        /// </summary>
        /// <param name="VALUE"></param>
        /// <returns>true, if it has decimals and false otherwise.</returns>
        template<class T> 
        static bool HasDecimals(const T VALUE)
        {
            return ((VALUE - (long long)VALUE) != 0);
        }

        /// <summary>
        /// Calculates the power of the base to the exponent without changing
        /// the least-significant digits of a number.
        /// </summary>
        /// <param name="BASIS"></param>
        /// <param name="EXPONENT"></param>
        /// <returns>BASIS to power of EXPONENT</returns>
        static double Power(short const sBASIS, short const sEXPONENT);

        /// <summary>
        /// Rounds a number to the decimal places.</summary>
        /// <param name="yDIGITS">Number of all decimal places</param>
        /// <param name="chSEPARATOR">
        /// Language-specific decimal separator
        /// </param>
        /// <param name="dVALUE">Number to be rounded</param>
        /// <returns>Rounded number to the requested decimal places</returns>
        static double Round(byte const yDIGITS,
            char const chSEPARATOR, double const dVALUE);

        /// <summary>
        /// Replacement for Math.round(double) of Java.</summary>
        /// <param name="dValue">Number to be rounded</param>
        /// <returns>Rounded number to the requested decimal places</returns>
        static double Round(double const dVALUE);

        /// <summary>Signum function</summary>
        /// <param name="number">Value to be scrutinised</param>
        /// <returns>Sign of the number</returns>
        template<class T> 
        static byte Signum(T number) 
        {
            return (number < T(0)) ? T(-1) : (number > T(0));
        }

        /// <summary>
        /// Rounds to a fixed number of significant digits.</summary>
        /// <param name="ySIGNIFICANT_DIGITS">
        /// Requested number of significant digits
        /// </param>
        /// <param name="chSEPARATOR">
        /// Language-specific decimal separator
        /// </param>
        /// <param name="dValue">Number to be rounded</param>
        /// <returns>Rounded number</returns>
        static string RoundToString(byte const ySIGNIFICANT_DIGITS,
            char const chSEPARATOR, double dValue);
    }; // class Maths
}

Using precompiled headers requires the StdAfx files:

StdAfx.cpp:

// StdAfx.cpp : Quelldatei, die nur die Standard-Includes einbindet.
// Commons.pch ist der vorkompilierte Header.
// StdAfx.obj enthält die vorkompilierten Typinformationen.

#include "StdAfx.h"

StdAfx.h:

// StdAfx.h : Includedatei für Standardsystem-Includedateien
// oder häufig verwendete projektspezifische Includedateien,
// die nur in unregelmäßigen Abständen geändert werden.
//

#pragma once

using namespace std;

typedef signed char byte;
typedef unsigned short ushort;

// Used headers:
#include "Common.h"
#include "Maths.h"
#include "StringBuilder.h"
#include "TestCommons.h"

#include "StringConverter.h"

#include <iostream>

The StringBuilder class was added by the JAVA TO C++ CONVERTER during the crosscompilation:

StringBuilder.cpp:

#include "StdAfx.h"

namespace common
{
    StringBuilder::StringBuilder()
    {
        strMain = "";
    }

    StringBuilder::StringBuilder(string const& strVALUE)
    {
        Append(strVALUE);
    }

    size_t const StringBuilder::Find(string const& strSEARCH) const
    {
        return strMain.find(strSEARCH);
    }

    string const& StringBuilder::ToString() const
    {
        return strMain; 
    }

    void StringBuilder::Append(string const& strVALUE)
    {
        strMain.append(strVALUE);
    }

    void StringBuilder::SetLength(const string::size_type SIZE)
    {
        strMain.resize(SIZE);
    }
}

StringBuilder.h:

#pragma once

namespace common
{
    class StringBuilder
    {
    private: 
        string strMain; 

    public:
        /// <summary>
        /// Standard constructor
        /// </summary>
        StringBuilder();

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="strSUBJECT">Value to be used</param>
        StringBuilder(string const& strSUBJECT);

        /// <summary>
        /// Finds the search string inside itself.
        /// </summary>
        /// <param name="strSEARCH">Value to be used</param>
        /// <returns>
        /// The position of the searched text or -1, if the search string
        /// has not been found.
        /// </returns>
        size_t const Find(string const& strSEARCH) const;

        /// <summary>
        /// Converts the contents of itself to a string.
        /// </summary>
        /// <returns>String content</returns>
        string const& ToString() const;

        /// <summary>
        /// Appends a text to this object
        /// </summary>
        /// <param name="strVALUE">Value to be appended</param>
        void Append(string const& strVALUE);

        /// <summary>
        /// Sets the length of the content of this object.
        /// </summary>
        /// <param name="SIZE">New reduced size</param>
        void SetLength(const string::size_type SIZE);
    };
}

Extensive testing of a software is crucial for qualitative code. To say that the code is tested does not give much information. The question is what is tested. Not in this case, but often it is also important to know where (in which environment) it was tested, and how - i.e. the test succession. Here is the code used to test the Maths class.

TestCommons.cpp:

#include "StdAfx.h"

namespace common
{
    void TestCommons::Test()
    {
        // Test rounding
        vector<double>* pa_dValues = new vector<double>();

        vector<double>& a_dValues = *pa_dValues;

        a_dValues.push_back(0.0);
        AddValue(1.4012984643248202e-45, a_dValues);
        AddValue(1.999999757e-5, a_dValues);
        AddValue(1.999999757e-4, a_dValues);
        AddValue(0.000640589, a_dValues);
        AddValue(1.999999757e-3, a_dValues);
        AddValue(0.3396899998188019, a_dValues);
        AddValue(0.34, a_dValues);
        AddValue(7.07, a_dValues);
        AddValue(118.188, a_dValues);
        AddValue(118.2, a_dValues);
        AddValue(123.405009, a_dValues);
        AddValue(30.76994323730469, a_dValues);
        AddValue(130.76994323730469, a_dValues);
        AddValue(540, a_dValues);
        AddValue(12345, a_dValues);
        AddValue(123456, a_dValues);
        AddValue(540911, a_dValues);
        AddValue(9.223372036854776e56, a_dValues);

        byte const ySIGNIFICANTS = 5;

        for (vector<double>::const_iterator element = a_dValues.begin();
            element != a_dValues.end(); ++element)
        {
            cout << "Maths::RoundToString(" << (short)ySIGNIFICANTS << ", '"
                << Common::PERIOD << "', " << StringConverter::ToString
                <double, StringConverter::DIGITS>(*element) << ") = ";
            cout << Maths::RoundToString(ySIGNIFICANTS, Common::PERIOD,
                *element) << endl;
        }

        pa_dValues->clear();
        byte y;

        cin >> y;
    } // void Test()

    void TestCommons::AddValue(double const dVALUE, vector<double>& a_dValues)
    {
        a_dValues.push_back(-dVALUE);
        a_dValues.push_back(dVALUE);
    }
}

TestCommons.h:

#pragma once

#include <string>
#include <vector>

namespace common
{
    /// <summary>
    /// Test class for the common functionality
    /// @author Saban
    ///</summary>
    class TestCommons
    {
    private:
        /// <summary>
        /// Method that adds a negative and a positive value to values.</summary>
        /// <param name="dVALUE"></param>
        /// <param name="a_dValues"></param>
        static void AddValue(double const dVALUE, vector<double>& a_dValues);

    public:
        /// <summary>Number of significant digits</summary>
        static short const SIGNIFICANTS = 5;

        /// <summary>
        /// Test for the common functionality</summary>
        /// <param name="args"></param>
        static void Test();
    }; // class TestCommons
}

The results of your better code should comply with the result I got:

Maths::RoundToString(5, '.', 0.00000000000000000) = 0.00000
Maths::RoundToString(5, '.', -1.40129846432482020e-045) = -1.4012e-45
Maths::RoundToString(5, '.', 1.40129846432482020e-045) = 1.4013e-45
Maths::RoundToString(5, '.', -1.99999975700000000e-005) = -1.9998e-5
Maths::RoundToString(5, '.', 1.99999975700000000e-005) = 2.0000e-5
Maths::RoundToString(5, '.', -0.00019999997570000) = -0.00019999
Maths::RoundToString(5, '.', 0.00019999997570000) = 0.00020000
Maths::RoundToString(5, '.', -0.00064058900000000) = -0.00064058
Maths::RoundToString(5, '.', 0.00064058900000000) = 0.00064059
Maths::RoundToString(5, '.', -0.00199999975700000) = -0.0019999
Maths::RoundToString(5, '.', 0.00199999975700000) = 0.0020000
Maths::RoundToString(5, '.', -0.33968999981880188) = -0.33967
Maths::RoundToString(5, '.', 0.33968999981880188) = 0.33968
Maths::RoundToString(5, '.', -0.34000000000000002) = -0.33999
Maths::RoundToString(5, '.', 0.34000000000000002) = 0.34000
Maths::RoundToString(5, '.', -7.07000000000000030) = -7.0699
Maths::RoundToString(5, '.', 7.07000000000000030) = 7.0700
Maths::RoundToString(5, '.', -118.18800000000000000) = -118.18
Maths::RoundToString(5, '.', 118.18800000000000000) = 118.19
Maths::RoundToString(5, '.', -118.20000000000000000) = -118.19
Maths::RoundToString(5, '.', 118.20000000000000000) = 118.20
Maths::RoundToString(5, '.', -123.40500900000001000) = -123.40
Maths::RoundToString(5, '.', 123.40500900000001000) = 123.41
Maths::RoundToString(5, '.', -30.76994323730469100) = -30.768
Maths::RoundToString(5, '.', 30.76994323730469100) = 30.770
Maths::RoundToString(5, '.', -130.76994323730469000) = -130.75
Maths::RoundToString(5, '.', 130.76994323730469000) = 130.77
Maths::RoundToString(5, '.', -540.00000000000000000) = -539.99
Maths::RoundToString(5, '.', 540.00000000000000000) = 540.00
Maths::RoundToString(5, '.', -12345.00000000000000000) = -12344
Maths::RoundToString(5, '.', 12345.00000000000000000) = 12345
Maths::RoundToString(5, '.', -123456.00000000000000000) = -123450
Maths::RoundToString(5, '.', 123456.00000000000000000) = 123460
Maths::RoundToString(5, '.', -540911.00000000000000000) = -540900
Maths::RoundToString(5, '.', 540911.00000000000000000) = 540910
Maths::RoundToString(5, '.', -9.22337203685477560e+056) = -9.2232e56
Maths::RoundToString(5, '.', 9.22337203685477560e+056) = 9.2234e56

If you are interested in a comparison of C++ with C#, take a look at C# programming rounding number example. If you want to compare C++ with Java, compare it to the rounding code at Java Programming rounding number example.

 The string class 
The string class is a part of the C++ standard library, used for convenient manipulation of sequences of characters, to replace the static, unsafe C method of handling strings. To use the string class in a program, the <string> header must be included. The standard library string class can be accessed through the std namespace.

The basic template class is basic_string<> and its standard specializations are string and wstring.

 Basic usage 
Declaring a std string is done by using one of these two methods:

using namespace std;
string std_string;

or

std::string std_string;

 Text I/O 
This section will deal only with keyboard and text input. There are many other inputs that can be read (mouse movements and button clicks, etc), but these will not be covered in this section, even reading the special keys of the keyboard will be excluded.  

Perhaps the most basic use of the string class is for reading text from the user and writing it to the screen. In the header file iostream, C++ defines an object named cin that handles input in much the same way that cout handles output.

// snipped designed to get an integer value from the user
int x; 
std::cin >> x;

The >> operator will cause the execution to stop and will wait for the user to type something. If the user types a valid integer, it will be converted into an integer value and stored in x.

If the user types something other than an integer, the compiler will not report an error. Instead, it leaves the old content (a "random" meaningless value) in x and continues. 

This can then be extended into the following program:

#include <iostream>
#include <string>

int main(){
    std::string name;
    std::cout << "Please enter your first name: ";
    std::cin >> name;
    std::cout << "Welcome " << name << "!" << std::endl;

    return 0;
}

Although a string may hold a sequence containing any character--including spaces and nulls--when reading into a string using cin and the extraction operator (>>) only the characters before the first space will be stored. Alternatively, if an entire line of text is desired, the getline function may be used:

    std::getline(std::cin, name);

 Getting user input 
Fortunately, there is a way to check and see if an input statement succeeds. We can invoke the good function on cin to check what is called the stream state. good returns a bool: if true, then the last input statement succeeded. If not, we know that some previous operation failed, and also that the next operation will fail.

Thus, getting input from the user might look like this:

#include <iostream>
using namespace std;
int main () 
{ 
  int x; 

  // prompt the user for input 
  cout << "Enter an integer: "; 

  // get input 
  cin >> x; 

  // check and see if the input statement succeeded 
  if (cin.good() == false) { 
    cout << "That was not an integer." << endl; 
    return -1; 
  } 

  // print the value we got from the user 
  cout << x << endl; 
  return 0; 
}

cin can also be used to input a string:

string name; 

cout << "What is your name? "; 
cin >> name; 
cout << name << endl;

As with the scanf() function from the Standard C Library, this statement only takes the first word of input, and leaves the rest for the next input statement. So, if you run this program and type your full name, it will only output your first name.

You may also notice the >> operator doesn't handle errors as expected (for example, if you accidentally typed your name in a prompt for a number.)  Because of these issues, it may be more suitable to read a line of text, and using the line for input — this is performed using the function called getline.

string name; 

cout << "What is your name? "; 
getline (cin, name); 
cout << name << endl;

The first argument to getline is cin, which is where the input is coming from. The second argument is the name of the string variable where you want the result to be stored.

getline reads the entire line until the user hits Return or Enter. This is useful for inputting strings that contain spaces.

In fact, getline is generally useful for getting input of any kind. For example, if you wanted the user to type an integer, you could input a string and then check to see if it is a valid integer. If so, you can convert it to an integer value. If not, you can print an error message and ask the user to try again.

To convert a string to an integer you can use the strtol function defined in the header file cstdlib.  (Note that the older function atoi is less safe than strtol, as well as being less capable.)

If you still need the features of the >> operator, you will need to create a string stream as available from <sstream>.  The use of this stream will be discussed in a later chapter.

 More advanced string manipulation 

We will be using this dummy string for some of our examples.

string str("Hello World!");

This invokes the default constructor with a const char* argument. Default constructor creates a string which contains nothing, i.e. no characters, not even a '\0' (however std::string is not null terminated).

string str2(str);

Will trigger the copy constructor. std::string knows enough to make a deep copy of the characters it 
stores.

string str2 = str;

This will copy strings using assignment operator. Effect of this code is same as using copy constructor in example above.

 Size 

string::size_type string::size() const;
string::size_type string::length() const;

So for example one might do:

string::size_type strSize =  str.size();
string::size_type strSize2 = str2.length();

The methods size() and length() both return the size of the string object. There is no apparent difference. Remember that the last character in the string is size() - 1 and not size(). Like in C-style strings, and arrays in general, std::string starts counting from 0.

 I/O 

ostream& operator<<(ostream &out, string &str);
istream& operator>>(istream &in, string &str);

The shift operators (>> and <<) have been overloaded so you can perform I/O operations on istream and ostream objects, most notably cout, cin, and filestreams. Thus you could just do console I/O like this:

std::cout << str << endl;
std::cin >> str;

istream& getline (istream& in, string& str, char delim = '\n');

Alternatively, if you want to read entire lines at a time, use getline(). Note that this is not a member function. getline() will retrieve characters from input stream in and assign them to str until EOF is reached or delim is encountered. getline will reset the input string before appending data to it. delim can be set to any char value and acts as a general delimiter. Here is some example usage:

#include <fstream>
//open a file
std::ifstream file("somefile.cpp");
std::string data, temp;

while( getline(file, temp, '#')) //while data left in file
{
    //append data
    data += temp;
}

std::cout << data;

Because of the way getline works (i.e. it returns the input stream), you can nest multiple getline() calls to get multiple strings; however this may significantly reduce readability.

 Operators 

char& string::operator[](string::size_type pos);

Chars in strings can be accessed directly using the overloaded subscript ([]) operator, like in char arrays:

std::cout << str[0] << str[2];

prints "Hl".

std::string supports casting from the older C string type const char*. You can also assign or append a simple char to a string. Assigning a char* to a string is as simple as

str = "Hello World!";

If you want to do it character by character, you can also use

str = 'H';

Not surprisingly, operator+ and operator+= are also defined! You can append another string, a const char* or a char to any string.

The comparison operators >, <, ==, >=, <=, != all perform comparison operations on strings, similar to the C strcmp() function. These return a true/false value.

if(str == "Hello World!")
{
 std::cout << "Strings are equal!";
}

 Searching strings 

string::size_type string::find(string needle, string::size_type pos = 0) const;

You can use the find() member function to find the first occurrence of a string inside another. find() will look for needle inside this starting from position pos and return the position of the first occurrence of the needle. For example:

std::string haystack = "Hello World!";
std::string needle = "o";
std::cout << haystack.find(needle);

Will simply print "4" which is the index of the first occurrence of "o" in str. If we want the "o" in "World", we need to modify pos to point past the first occurrence. str.find(find, 4) would return 4, while str.find(find, 5) would give 7. If the substring isn't found, find() returns std::string::npos.This simple code searches a string for all occurrences of "wiki" and prints their positions:

std::string wikistr = "wikipedia is full of wikis (wiki-wiki means fast)";
for(string::size_type i = 0, tfind; (tfind = wikistr.find("wiki", i)) != string::npos; i = tfind + 1)
{
 std::cout << "Found occurrence of 'wiki' at position " << tfind << std::endl;
}

string::size_type string::rfind(string needle, string::size_type pos = string::npos) const;

The function rfind() works similarly, except it returns the last occurrence of the passed string.

 Inserting/erasing 

string& string::insert(size_type pos, const string& str);

You can use the insert() member function to insert another string into a string.
For example:

string newstr = " Human";
str.insert (5,newstr);

Would return Hello Human World!

string& string::erase(size_type pos, size_type n);

You can use erase() to remove a substring from a string. For example:

str.erase (6,11);

Would return Hello!

string& string::substr(size_type pos, size_type n);

You can use substr() to extract a substring from a string. For example:

string str = "Hello World!";
string part = str.substr(6,5);

Would return World.

 Backwards compatibility 

const char* string::c_str() const;
const char* string::data() const;

For backwards compatibility with C/C++ functions which only accept char* parameters, you can use the member functions string::c_str() and string::data() to return a temporary const char* string you can pass to a function.  The difference between these two functions is that c_str() returns a null-terminated string while data() does not necessarily return a null-terminated string.  So, if your legacy function requires a null-terminated string, use c_str(), otherwise use data() (and presumably pass the length of the string in as well).

 String Formatting 

Strings can only be appended to other strings, but not to numbers or other datatypes, so something like std::string("Foo") + 5 would not result in a string with the content "Foo5". To convert other datatypes into string there exist the class std::ostringstream, found in the include file <sstream>. std::ostringstream acts exactly like std::cout, the only difference is that the output doesn't go to the current standard output as provided by the operating system, but into an internal buffer, that buffer can be converted into a std::string via the std::ostringstream::str() method.

 Example 

#include <iostream>
#include <sstream>

int main()
{ 
    std::ostringstream buffer;

    // Use the std::ostringstream just like std::cout or other iostreams
    buffer << "You have: " << 5 << " Helloworlds in your inbox";

    // Convert the std::ostringstream to a normal string
    std::string text = buffer.str();

    std::cout << text << std::endl;

    return 0;
}

 Advanced use 

 Chapter Summary 
Structures 
Unions 
Classes  (Inheritance, Member Functions, Polymorphism and this pointer)
Abstract Classes  including Pure abstract classes (abstract types) 
Nice Class 
Operator overloading 
Standard Input/Output streams Library 
string 

Advanced Features
 Templates 
Templates are a way to make code more reusable. Trivial examples include creating generic data structures which can store arbitrary data types. Templates are of great utility to programmers, especially when combined with multiple inheritance and operator overloading. The Standard Template Library (STL) provides many useful functions within a framework of connected templates.

As templates are very expressive they may be used for things other than generic programming.  One such use is called template metaprogramming, which is a way of pre-evaluating some of the code at compile-time rather than run-time.  Further discussion here only relates to templates as a method of generic programming.

By now you should have noticed that functions that perform the same tasks tend to look similar. For example, if you wrote a function that prints an int, you would have to have the int declared first. This way, the possibility of error in your code is reduced, however, it gets somewhat annoying to have to create different versions of functions just to handle all the different data types you use. For example, you may want the function to simply print the input variable, regardless of what type that variable is. Writing a different function for every possible input type (double, char *, etc. ...) would be extremely cumbersome. That is where templates come in.

Templates solve some of the same problems as macros, generate "optimized" code at compile time, but are subject to C++'s strict type checking.

Parameterized types, better known as templates, allow the programmer to create one function that can handle many different types. Instead of having to take into account every data type, you have one arbitrary parameter name that the compiler then replaces with the different data types that you wish the function to use, manipulate, etc.

Templates are instantiated at compile-time with the source code. 
Templates are type safe. 
Templates allow user-defined specialization. 
Templates allow non-type parameters. 
Templates use “lazy structural constraints”. 
Templates support mix-ins. 

 Syntax for Templates 

Templates are pretty easy to use, just look at the syntax:

 template <class TYPEPARAMETER>

(or, equivalently, and preferred by some)

 template <typename TYPEPARAMETER>

 Function template 
There are two kinds of templates.  A function template behaves like a function that can accept arguments of many different types.  For example, the Standard Template Library contains the function template max(x, y) which returns either x or y, whichever is larger.  max() could be defined like this:

    template <typename TYPEPARAMETER>
    TYPEPARAMETER max(TYPEPARAMETER x, TYPEPARAMETER y)
    {
        if (x < y)
            return y;
        else
            return x;
    }

This template can be called just like a function:

    std::cout << max(3, 7);   // outputs 7

The compiler determines by examining the arguments that this is a call to max(int, int) and instantiates a version of the function where the type TYPEPARAMETER is int.

This works whether the arguments x and y are integers, strings, or any other type for which it makes sense to say "x < y". If you have defined your own data type, you can use operator overloading to define the meaning of < for your type, thus allowing you to use the max() function. While this may seem a minor benefit in this isolated example, in the context of a comprehensive library like the STL it allows the programmer to get extensive functionality for a new data type, just by defining a few operators for it.  Merely defining < allows a type to be used with the standard sort(), stable_sort(), and binary_search() algorithms; data structures such as sets, heaps, and associative arrays; and more.

As a counterexample, the standard type complex does not define the < operator, because there is no strict order on complex numbers.  Therefore max(x, y) will fail with a compile error if x and y are complex values.  Likewise, other templates that rely on < cannot be applied to complex data.  Unfortunately, compilers historically generate somewhat esoteric and unhelpful error messages for this sort of error. Ensuring that a certain object adheres to a method protocol can alleviate this issue.

{TYPEPARAMETER} is just the arbitrary TYPEPARAMETER name that you want to use in your function. Some programmers prefer using just T in place of TYPEPARAMETER.

Let us say you want to create a swap function that can handle more than one data type... something that looks like this:

 template <class SOMETYPE> 
 void swap (SOMETYPE &x, SOMETYPE &y) 
 { 
   SOMETYPE temp = x; 
   x = y; 
   y = temp; 
 }

The function you see above looks really similar to any other swap function, with the differences being the template <class SOMETYPE> line before the function definition and the instances of SOMETYPE in the code. Everywhere you would normally need to have the name or class of the datatype that you're using, you now replace with the arbitrary name that you used in the template <class SOMETYPE>. For example, if you had SUPERDUPERTYPE instead of SOMETYPE, the code would look something like this:

 template <class SUPERDUPERTYPE> 
 void swap (SUPERDUPERTYPE &x, SUPERDUPERTYPE &y) 
 { 
   SUPERDUPERTYPE temp = x; 
   x = y; 
   y = temp; 
 }

As you can see, you can use whatever label you wish for the template TYPEPARAMETER, as long as it is not a reserved word.

 Class template 
A class template extends the same concept to classes.  Class templates are often used to make generic containers. For example, the STL has a linked list container. To make a linked list of integers, one writes list<int>. A list of strings is denoted list<string>. A list has a set of standard functions associated with it, which work no matter what you put between the brackets.

If you want to have more than one template TYPEPARAMETER, then the syntax would be:

 template <class SOMETYPE1, class SOMETYPE2, ...>

Templates and Classes
Let us say that rather than create a simple templated function, you would like to use templates for a class, so that the class may handle more than one datatype. You may have noticed that some classes are able to accept a type as a parameter and create variations of an object based on that type (for example the classes of the STL container class hierarchy). This is because they are declared as templates using syntax not unlike the one presented below:

 template <class T> class Foo
 {
 public:
   Foo();
   void some_function();
   T some_other_function();

 private:
   int member_variable;
   T parametrized_variable;
 };

Defining member functions of a template class is somewhat like defining a function template, except for the fact, that you use the scope resolution operator to indicate that this is the template classes' member function. The one important and non-obvious detail is the requirement of using the template operator containing the parametrized type name after the class name.

The following example describes the required syntax by defining functions from the example class above.

 template <class T> Foo<T>::Foo()
 {
   member_variable = 0;
 }

 template <class T> void Foo<T>::some_function()
 {
   cout << "member_variable = " << member_variable << endl;
 }

 template <class T> T Foo<T>::some_other_function()
 {
   return parametrized_variable;
 }

As you may have noticed, if you want to declare a function that will return an object of the parametrized type, you just have to use the name of that parameter as the function's return type.

 Advantages and disadvantages 
Some uses of templates, such as the max() function, were previously filled by function-like preprocessor macros.

// a max() macro
#define max(a,b)   ((a) < (b) ? (b) : (a))

Both macros and templates are expanded at compile time.  Macros are always expanded inline; templates can also be expanded as inline functions when the compiler deems it appropriate.  Thus both function-like macros and function templates have no run-time overhead.

However, templates are generally considered an improvement over macros for these purposes.  Templates are type-safe.  Templates avoid some of the common errors found in code that makes heavy use of function-like macros.  Perhaps most importantly, templates were designed to be applicable to much larger problems than macros.  The definition of a function-like macro must fit on a single logical line of code.

There are three primary drawbacks to the use of templates.  First, many compilers historically have very poor support for templates, so the use of templates can make code somewhat less portable.  Second, almost all compilers produce confusing, unhelpful error messages when errors are detected in template code.  This can make templates difficult to develop.  Third, each use of a template may cause the compiler to generate extra code (an instantiation of the template), so the indiscriminate use of templates can lead to code bloat, resulting in excessively large executables.

The other big disadvantage of templates is that to replace a #define like max which acts identically with dissimilar types or function calls is impossible. Templates have replaced using #defines for complex functions but not for simple stuff like max(a,b). For a full discussion on trying to create a template for the #define max, see the paper "Min, Max and More" that Scott Meyer wrote for C++ Report in January 1995.

The biggest advantage of using templates, is that a complex algorithm can have a simple interface that the compiler then uses to choose the correct implementation based on the type of the arguments. For instance, a searching algorithm can take advantage of the properties of the container being searched. This technique is used throughout the C++ standard library.

 Linkage problems 
While linking a template-based program consisting over several modules spread over a couple files, it is a frequent and mystifying situation to find that the object code of the modules won't link due to 'unresolved reference to (insert template member function name here) in (...)'. The offending function's implementation is there, so why is it missing from the object code? Let us stop a moment and consider how can this be possible.

Assume you have created a template based class called Foo and put its declaration in the file Util.hpp along with some other regular class called Bar:

 template <class T> Foo
 {
 public: 
   Foo();
   T some_function();
   T some_other_function();
   T some_yet_other_function();
   T member;
 };

 class Bar
 {
   Bar();
   void do_something();
 };

Now, to adhere to all the rules of the art, you create a file called Util.cc, where you put all
the function definitions, template or otherwise:

 #include "Util.hpp"

 template <class T> T Foo<T>::some_function()
 {
  ...
 }

 template <class T> T Foo<T>::some_other_function()
 {
  ...
 }

 template <class T> T Foo<T>::some_yet_other_function()
 {
  ...
 }

and, finally:

 void Bar::do_something()
 {
   Foo<int> my_foo;
   int x = my_foo.some_function();
   int y = my_foo.some_other_function();
 }

Next, you compile the module, there are no errors, you are happy. But suppose there is an another 
(main) module in the program, which resides in MyProg.cc:

 #include "Util.hpp"	// imports our utility classes' declarations, including the template

 int main()
 {
   Foo<int> main_foo;
   int z = main_foo.some_yet_other_function();
   return 0;
 }

This also compiles clean to the object code. Yet when you try to link the two modules together, you get an error saying there is an undefined reference to Foo<int>::some_yet_other function() in
MyProg.cc. You defined the template member function correctly, so what is the problem?

As you remember, templates are instantiated at compile-time. This helps avoid code bloat,
which would be the result of generating all the template class and function variants for all
possible types as its parameters. So, when the compiler processed the Util.cc code, it saw that
the only variant of the Foo class was Foo<int>, and the only needed functions were: 

 int Foo<int>::some_function();
 int Foo<int>::some_other_function();

No code in Util.cc required any other variants of Foo or its methods to exist, so the compiler
generated no code other than that. There is no implementation of some_yet_other_function() in the object code, just as there is no implementation for

 double Foo<double>::some_function();

or

 string Foo<string>::some_function();

The MyProg.cc code compiled without errors, because the member function of Foo it uses is correctly declared in the Util.hpp header, and it is expected that it will be available upon linking. But it is not and hence the error, and a lot of nuisance if you are new to templates
and start looking for errors in your code, which ironically is perfectly correct.

The solution is somewhat compiler dependent. For the GNU compiler, try experimenting with the -frepo flag, and also reading the template-related section of 'info gcc' (node "Template Instantiation": "Where is the Template?") may prove enlightening. In Borland, supposedly, there is a selection in the linker options, which activates 'smart' templates just for this kind of problem.

The other thing you may try is called explicit instantiation. What you do is create some dummy code
in the module with the templates, which creates all variants of the template class and calls all
variants of its member functions, which you know are needed elsewhere. Obviously, this requires you to know a lot about what variants you need throughout your code. In our simple example this would go like this:

1. Add the following class declaration to Util.hpp:

 class Instantiations
 {
 private:
   void Instantiate();
 };

2. Add the following member function definition to Util.cc:

 void Instantiations::Instantiate()
 {
   Foo<int> my_foo;
   my_foo.some_yet_other_function();
   // other explicit instantiations may follow
 }

Of course, you never need to actually instantiate the Instantiations class, or call any of its methods. The fact that they just exist in the code makes the compiler generate all the template variations which are required. Now the object code will link without problems.

There is still one, if not elegant, solution. Just move all the template functions' definition code to the Util.hpp header file. This is not pretty, because header files are for declarations, and the implementation is supposed to be defined elsewhere, but it does the trick in this situation. 
While compiling the MyProg.cc (and any other modules which include Util.hpp) code, the compiler will generate all the template variants which are needed, because the definitions are readily available.

 Template Meta-programming overview
Template meta-programming (TMP) refers to uses of the C++ template system to perform computation at compile-time within the code.  It can, for the most part, be considered to be "programming with types" — in that, largely, the "values" that TMP works with are specific C++ types. Using types as the basic objects of calculation allows the full power of the type-inference rules to be used for general-purpose computing.

 Compile-time programming 
The preprocessor allows certain calculations to be carried out at compile time, meaning that by the time the code has finished compiling the decision has already been taken, and can be left out of the compiled executable. The following is a very contrived example:

#define myvar 17

#if myvar % 2
   cout << "Constant is odd" << endl;
#else
   cout << "Constant is even" << endl;
#endif

This kind of construction does not have much application beyond conditional inclusion of platform-specific code. In particular there's no way to iterate, so it can not be used for general computing. Compile-time programming with templates works in a similar way but is much more powerful, indeed it is actually Turing complete.

Traits classes are a familiar example of a simple form of template meta-programming: given input of a type, they compute as output properties associated with that type (for example, std::iterator_traits<> takes an iterator type as input, and computes properties such as the iterator's difference_type, value_type and so on).

 The nature of template Meta-programming 
Template meta-programming is much closer to functional programming than ordinary idiomatic C++ is. This is because 'variables' are all immutable, and hence it is necessary to use recursion rather than iteration to process elements of a set. This adds another layer of challenge for C++ programmers learning TMP: as well as learning the mechanics of it, they must learn to think in a different way.

 Limitations of Template Meta-programming 
Because template meta-programming evolved from an unintended use of the template system, it is frequently cumbersome. Often it is very hard to make the intent of the code clear to a maintainer, since the natural meaning of the code being used is very different from the purpose to which it is being put. The most effective way to deal with this is through reliance on idiom; if you want to be a productive template meta-programmer you will have to learn to recognize the common idioms.

It also challenges the capabilities of older compilers; generally speaking, compilers from around the year 2000 and later are able to deal with much practical TMP code. Even when the compiler supports it, the compile times can be extremely large and in the case of a compile failure the error messages are frequently impenetrable.

Some coding standards may even forbid template meta-programming, at least outside of third-party libraries like Boost.

 History of TMP 
Historically TMP is something of an accident; it was discovered during the process of standardizing the C++ language that its template system happens to be Turing-complete, i.e., capable in principle of computing anything that is computable.  The first concrete demonstration of this was a program written by Erwin Unruh, which computed prime numbers although it did not actually finish compiling: the list of prime numbers was part of an error message generated by the compiler on attempting to compile the code.  TMP has since advanced considerably, and is now a practical tool for library builders in C++, though its complexities mean that it is not generally appropriate for the majority of applications or systems programming contexts.

#include <iostream>

template <int p, int i>
class is_prime {
public:
	enum { prim = ( (p % i) && is_prime<p, i - 1>::prim ) }; 
}; 

template <int p>
class is_prime<p, 1> {
public:
	enum { prim = 1 };
}; 

template <int i>
class Prime_print {      // primary template for loop to print prime numbers
public:
	Prime_print<i - 1> a; 
	enum { prim = is_prime<i, i - 1>::prim };
	void f() {
		a.f();
		if (prim)
		{
			std::cout << "prime number:" << i << std::endl;
		}
	} 
}; 

template<>
class Prime_print<1> {   // full specialization to end the loop
public:
	enum { prim = 0 };
	void f() {}
}; 

#ifndef LAST 
#define LAST 18 
#endif

int main()
{
   Prime_print<LAST> a; 
   a.f(); 
}

 Building blocks 
 Values 
The 'variables' in TMP are not really variables since their values cannot be altered, but you can have named values that you use rather like you would variables in ordinary programming. When programming with types, named values are typedefs:

struct ValueHolder
{
   typedef int value;
};

You can think of this as 'storing' the int type so that it can be accessed under the value name. Integer values are usually stored as members in an enum:

struct ValueHolder
{
   enum { value = 2 };
};

This again stores the value so that it can be accessed under the name value. Neither of these examples is any use on its own, but they form the basis of most other TMP, so they are vital patterns to be aware of.

 Functions 
A function maps one or more input parameters into an output value. The TMP analogue to this is a template class:

template<int X, int Y>
struct Adder
{
   enum { result = X + Y };
};

This is a function that adds its two parameters and stores the result in the result enum member. You can call this at compile time with something like Adder<1, 2>::result, which will be expanded at compile time and act exactly like a literal 3 in your program.

 Branching 
A conditional branch can be constructed by writing two alternative specialisations of a template class. The compiler will choose the one that fits the types provided, and a value defined in the instantiated class can then be accessed. For example, consider the following partial specialisation:

template<typename X, typename Y>
struct SameType
{
   enum { result = 0 };
};

template<typename T>
struct SameType<T, T>
{
   enum { result = 1 };
};

This tells us if the two types it is instantiated with are the same. This might not seem very useful, but it can see through typedefs that might otherwise obscure whether types are the same, and it can be used on template arguments in template code. You can use it like this:

if (SameType<SomeThirdPartyType, int>::result)
{
   // ... Use some optimised code that can assume the type is an int
}
else
{
   // ... Use defensive code that doesn't make any assumptions about the type
}

The above code isn't very idiomatic: since the types can be identified at compile-time, the if() block will always have a trivial condition (it'll always resolve to either if (1) { ... } or if (0) { ... }). However, this does illustrate the kind of thing that can be achieved.

 Recursion 
Since you don't have mutable variables available when you're programming with templates, it's impossible to iterate over a sequence of values. Tasks that might be achieved with iteration in standard C++ have to be redefined in terms of recursion, i.e. a function that calls itself. This usually takes the shape of a template class whose output value recursively refers to itself, and one or more specialisations that give fixed values to prevent infinite recursion. You can think of this as a combination of the function and conditional branch ideas described above.

Calculating factorials is naturally done recursively:  $0! = 1$ , and for  $n>0$ ,  $n!=n\times (n-1)!$ .  In TMP, this corresponds to a class template "factorial" whose general form uses the recurrence relation, and a specialization of which terminates the recursion.

First, the general (unspecialized) template says that factorial<n>::value is given by n*factorial<n-1>::value:

template <unsigned n>
struct factorial
{
  enum { value = n * factorial<n-1>::value };
};

Next, the specialization for zero says that factorial<0>::value evaluates to 1:

template <>
struct factorial<0>
{
  enum { value = 1 };
};

And now some code that "calls" the factorial template at compile-time:

int main() {
  // Because calculations are done at compile-time, they can be
  // used for things such as array sizes.
  int array[ factorial<7>::value ];
}

Observe that the factorial<N>::value member is expressed in terms of the factorial<N> template, but this can't continue infinitely: each time it is evaluated, it calls itself with a progressively smaller (but non-negative) number. This must eventually hit zero, at which point the specialisation kicks in and evaluation doesn't recurse any further.

Example: Compile-time "If" 
The following code defines a meta-function called "if_"; this is a class template that can be used to choose between two types based on a compile-time constant, as demonstrated in main below:

 1 template <bool Condition, typename TrueResult, typename FalseResult>
 2 class if_;
 3 
 4 template <typename TrueResult, typename FalseResult>
 5 struct if_<true, TrueResult, FalseResult>
 6 {
 7   typedef TrueResult result;
 8 };
 9 
10 template <typename TrueResult, typename FalseResult>
11 struct if_<false, TrueResult, FalseResult>
12 {
13   typedef FalseResult result;
14 };
15 
16 int main()
17 {
18   typename if_<true, int, void*>::result number(3);
19   typename if_<false, int, void*>::result pointer(&number);
20 
21    typedef typename if_<(sizeof(void *) > sizeof(uint32_t)), uint64_t, uint32_t>::result
22       integral_ptr_t;
23 	  
24    integral_ptr_t converted_pointer = reinterpret_cast<integral_ptr_t>(pointer);
25 }

On line 18, we evaluate the if_ template with a true value, so the type used is the first of the provided values. Thus the entire expression if_<true, int, void*>::result evaluates to int. Similarly, on line 19 the template code evaluates to void *. These expressions act exactly the same as if the types had been written as literal values in the source code.

Line 21 is where it starts to get clever: we define a type that depends on the value of a platform-dependent sizeof expression. On platforms where pointers are either 32 or 64 bits, this will choose the correct type at compile time without any modification, and without preprocessor macros. Once the type has been chosen, it can then be used like any other type.

For comparison, this problem is best attacked in C90 as follows

1 # include <stddef.h>
2 typedef size_t integral_ptr_t;
3 typedef int the_correct_size_was_chosen [sizeof (integral_ptr_t) >= sizeof (void *)? 1: -1];

As it happens, the library-defined type size_t should be the correct choice for this particular problem on any platform.
To ensure this, line 3 is used as a compile time check to see if the selected type is actually large enough; if not, the array type the_correct_size_was_chosen will be defined with a negative length, causing a compile-time error.  In C99, <stdint.h> may define the types intptr_h and uintptr_h.

 Conventions for "Structured" TMP 

Standard Template Library (STL)
The Standard Template Library (STL), part of the C++ Standard Library, offers collections of algorithms, containers, iterators, and other fundamental components, implemented as templates, classes, and functions essential to extend functionality and standardization to C++. STL main focus is to provide improvements implementation standardization  with  emphasis in performance and correctness.

Instead of wondering if your array would ever need to hold 257 records or having nightmares of string buffer overflows, you can enjoy vector and string that automatically extend to contain more records or characters. For example, vector is just like an array, except that vector's size can expand to hold more cells or shrink when fewer will suffice. One must keep in mind that the STL does not conflict with OOP but in itself is not object oriented; In particular it makes no use of runtime polymorphism (i.e., has no virtual functions).

The true power of the STL lies not in its container classes, but in the fact that it is a framework, combining algorithms with data structures using indirection through iterators to allow generic implementations of higher order algorithms to work efficiently on varied forms of data. To give a simple example, the same std::copy function can be used to copy elements from one array to another, or to copy the bytes of a file, or to copy the whitespace-separated words in "text like this" into a container such as std::vector<std::string>.

 // std::copy from array a to array b
 int a[10] = { 3,1,4,1,5,9,2,6,5,4 };
 int b[10];
 std::copy(&a[0], &a[9], b);

 // std::copy from input stream a to an arbitrary OutputIterator
 template <typename OutputIterator>
 void f(std::istream &a, OutputIterator destination) {
   std::copy(std::istreambuf_iterator<char>(a),
             std::istreambuf_iterator<char>(),
             destination);
 }

 // std::copy from a buffer containing text, inserting items in
 // order at the back of the container called words.
 std::istringstream buffer("text like this");
 std::vector<std::string> words;
 std::copy(std::istream_iterator<std::string>(buffer),
           std::istream_iterator<std::string>(),
           std::back_inserter(words));
 assert(words[0] == "text");
 assert(words[1] == "like");
 assert(words[2] == "this");

 History 

The C++ Standard Library incorporated part of the STL (published as a software library by SGI/Hewlett-Packard Company). The primary implementer of the C++ Standard Template Library was Alexander Stepanov.

Today we call STL to what was adopted into the C++ Standard. The ISO C++ does not specify header content, and allows implementation of the STL either in the headers, or in a true library.

Compilers will already have one implementation included as part of the C++ Standard (i.e., MS Visual Studio uses the Dinkum STL). All implementations will have to comply to the standard's requirements regarding functionality and behavior, but consistency of programs across all major hardware implementations, operating systems, and compilers will also depends on the portability of the STL implementation. They may also offer extended features or be optimized to distinct setups. 

There are many different implementations of the STL, all based on the language standard but  nevertheless differing from each other, making it transparent for the programmer, enabling specialization and rapid evolution of the code base. Several open source implementations are available, which can be useful to consult.

List of STL implementations.   
 libstdc++ from gnu (was part of libg++)
 SGI STL library (http://www.sgi.com/tech/stl/) free STL implementation.
 Rogue Wave standard library (HP, SGI, SunSoft, Siemens-Nixdorf) / Apache C++ Standard Library (STDCXX)
 Dinkum STL library by P.J. Plauger (http://www.dinkumware.com/) commercial STL implementation widely used, since it was licensed in is co-maintained by Microsoft and it is the STL implementation that ships with Visual Studio.
 Apache C++ Standard Library ( http://stdcxx.apache.org/ ) (open source)
 STLport STL library (http://www.stlport.com/) open source and highly cross-platform implementation based on the SGI implementation.

Containers
The containers we will discuss in this section of the book are part of the standard namespace (std::).  They all originated in the original SGI implementation of the STL.

Sequence Containers
 Sequences - easier than arrays 

Sequences are similar to C arrays, but they are easier to use. Vector is usually the first sequence to be learned. Other sequences, list and double-ended queues, are similar to vector but more efficient in some special cases.  (Their behavior is also different in important ways concerning validity of iterators when the container is changed; iterator validity is an important, though somewhat advanced, concept when using containers in C++.)

 vector - "an easy-to-use array"
 list - in effect, a doubly-linked list
 deque - double-ended queue (properly pronounced "deck", often mispronounced as "dee-queue")

vector
The vector is a template class in itself, it is a Sequence Container and allows you to easily create a dynamic array of elements (one type per instance) of almost any data-type or object within a programs when using it. The vector class handles most of the memory management for you.

Since a vector contain contiguous elements it is an ideal choice to replace the old C style array, in a situation where you need to store data, and ideal in a situation where you need to store dynamic data as an array that changes in size during the program's execution (old C style arrays can't do it). However, vectors do incur a very small overhead compared to static arrays (depending on the quality of your compiler), and cannot be initialized through an initialization list.

Accessing members of a vector or appending elements takes a fixed amount of time, no matter how large the vector is, whereas locating a specific value in a vector element or inserting elements into the vector takes an amount of time directly proportional to its location in it (size dependent).

Example

/*
David Cary 2009-03-04
quick demo for wikibooks
*/

#include <iostream>
#include <vector>
using namespace std;

vector<int> pick_vector_with_biggest_fifth_element(vector<int> left,vector<int> right)
{
    if(left[5] < right[5])
    {
        return( right );
    }
    // else
    return left ;
}

int* pick_array_with_biggest_fifth_element(int * left,int * right)
{
    if(left[5] < right[5])
    {
        return( right );
    }
    // else 
    return left ;
}

int vector_demo(void)
{
    cout << "vector demo" << endl;
    vector<int> left(7);
    vector<int> right(7);

    left[5] = 7;
    right[5] = 8;
    cout << left[5] << endl;
    cout << right[5] << endl;
    vector<int> biggest(pick_vector_with_biggest_fifth_element( left, right ) );
    cout << biggest[5] << endl;

    return 0;
}

int array_demo(void)
{
    cout << "array demo" << endl;
    int left[7];
    int right[7];

    left[5] = 7;
    right[5] = 8;
    cout << left[5] << endl;
    cout << right[5] << endl;
    int * biggest =
        pick_array_with_biggest_fifth_element( left, right );
    cout << biggest[5] << endl;

    return 0;
}

int main(void)
{
    vector_demo();
    array_demo();
}

Member Functions
The vector class models the Container concept, which means it has begin(), end(), size(), max_size(), empty(), and swap() methods.

 informative
vector::front - Returns reference to first element of vector.
vector::back - Returns reference to last element of vector.
vector::size - Returns number of elements in the vector.
vector::empty - Returns true if vector has no elements.
standard operations
vector::insert - Inserts elements into a vector (single & range), shifts later elements up. Inefficient.
vector::push_back - Appends (inserts) an element to the end of a vector, allocating memory for it if necessary. Amortized O(1) time.
vector::erase - Deletes elements from a vector (single & range), shifts later elements down. Inefficient.
vector::pop_back -  Erases the last element of the vector, (possibly reducing capacity - usually it isn't reduced, but this depends on particular STL implementation). Amortized O(1) time.
vector::clear - Erases all of the elements.  Note however that if the data elements are pointers to memory that was created dynamically (e.g., the new operator was used), the memory will not be freed.
allocation/size modification
vector::assign - Used to delete a origin vector and copies the specified elements to an empty target vector.
vector::reserve - Changes capacity (allocates more memory) of vector, if needed. In many STL implementations capacity can only grow, and is never reduced.
vector::capacity - Returns current capacity (allocated memory) of vector.
vector::resize - Changes the vector size.
 iteration
vector::begin - Returns an iterator to start traversal of the vector.
vector::end - Returns an iterator that points just beyond the end of the vector.
vector::at - Returns a reference to the data element at the specified location in the vector, with bounds checking.

vector<int> v;
for (vector<int>::iterator it = v.begin(); it!=v.end(); ++it/* increment operand is used to move to next element*/) {
    cout << *it << endl;
}

vector::Iterators
std::vector<T> provides Random Access Iterators; as with all containers, the primary access to iterators is via begin() and end() member functions.  These are overloaded for const- and non-const containers, returning iterators of types std::vector<T>::const_iterator and std::vector<T>::iterator respectively.

vector examples

 /* Vector sort example */
 #include <iostream>
 #include <vector>

 int main()
 {
         using namespace std;

         cout << "Sorting STL vector, \"the easier array\"... " << endl;
         cout << "Enter numbers, one per line.  Press ctrl-D to quit." << endl;

         vector<int> vec; 
         int tmp;
         while (cin>>tmp) {
                 vec.push_back(tmp);
         }

         cout << "Sorted: " << endl;
         sort(vec.begin(), vec.end());   
         int i = 0;
         for (i=0; i<vec.size(); i++) {
                 cout << vec[i] << endl;;
         }

         return 0;
 }

The call to sort above actually calls an instantiation of the function template std::sort, which will work on any half-open range specified by two random access iterators.

If you like to make the code above more "STLish" you can write this program in the following way:

 #include <iostream>
 #include <vector>
 #include <algorithm>
 #include <iterator>

 int main()
 {
        using namespace std;

        cout << "Sorting STL vector, \"the easier array\"... " << endl;
        cout << "Enter numbers, one per line.  Press ctrl-D to quit." << endl;

        istream_iterator<int> first(cin);
        istream_iterator<int> last;
        vector<int> vec(first, last);

        sort(vec.begin(), vec.end());

        cout << "Sorted: " << endl;

        copy(vec.begin(), vec.end(), ostream_iterator<int>(cout, "\n"));

        return 0;
 }

Linked lists
The STL provides a class template called list (part of the standard namespace (std::)) which implements a non-intrusive doubly-linked list.  Linked lists can insert or remove elements in the middle in constant time, but do not have random access.  One useful feature of std::list is that references, pointers and iterators to items inserted into a list remain valid so long as that item remains in the list.

list examples

 /* List example - insertion in a list */
 #include <iostream>
 #include <algorithm>
 #include <iterator>
 #include <list>

 void print_list(std::list<int> const& a_filled_list)
 {
        using namespace std;

        ostream_iterator<int> out(cout, "  ");
        copy(a_filled_list.begin(), a_filled_list.end(), out);
 }

 int main()
 {
	 std::list<int> my_list;

	 my_list.push_back(1);
	 my_list.push_back(10);
	 print_list(my_list); //print : 1 10

	 std::cout << std::endl;

	 my_list.push_front(45);
	 print_list(my_list); //print : 45 1 10

	 return 0;
 }

Associative Containers (key and value)
This type of container point to each element in the container with a key value, thus simplifying searching containers for the programmer. Instead of iterating through an array or vector element by element to find a specific one, you can simply ask for people["tero"]. Just like vectors and other containers, associative containers can expand to hold any number of elements.

Maps and Multimaps
map and multimap are associative containers that manage key/value pairs as elements as seen above.  The elements of each container will sort automatically using the actual key for sorting criterion.  The difference between the two is that maps do not allow duplicates, whereas, multimaps does. 

 map - unique keys
 multimap - same key can be used many times
 set - unique key is the value
 multiset - key is the value, same key can be used many times

  /* Map example - character distribution  */
  #include <iostream>
  #include <map>
  #include <string>
  #include <cctype>

  using namespace std;

  int main()
  {
          /* Character counts are stored in a map, so that 
           * character is the key.
           * Count of char a is chars['a']. */
          map<char, long> chars;

          cout << "chardist - Count character distributions" << endl;
          cout << "Type some text. Press ctrl-D to quit." << endl;
          char c;
          while (cin.get(c)) {
                  // Upper A and lower a are considered the same 
                  c=tolower(static_cast<unsigned char>(c));
                  chars[c]=chars[c]+1; // Could be written as ++chars[c];
          }

          cout << "Character distribution: " << endl;

          string alphabet("abcdefghijklmnopqrstuvwxyz");
          for (string::iterator letter_index=alphabet.begin(); letter_index != alphabet.end(); letter_index++) {
                  if (chars[*letter_index] != 0) {
                          cout << char(toupper(*letter_index))
                               << ":" << chars[*letter_index]
                               << "\t" << endl; 
                  }
          }
          return 0;
  }

 Container Adapters 
 stack - last in, first out (LIFO)
 queue - first in, first out (FIFO)
 priority queue

Iterators
C++'s iterators are one of the foundation of the STL. Iterators exist in languages other than C++, but C++ uses an unusual form of iterators, with pros and cons.

In C++, an iterator is a concept rather than a specific type, they are a generalization of the pointers as an abstraction for the use of containers. Iterators are further divided based on properties such as traversal properties.

The basic idea of an iterator is to provide a way to navigate over some collection of objects concept.

Some (overlapping) categories of iterators are:
 Singular iterators
 Invalid iterators
 Random access iterators
 Bidirectional iterators
 Forward iterators
 Input iterators
 Output iterators
 Mutable iterators

A pair of iterators [begin, end) is used to define a half open range, which includes the element identified from begin to end, except for the element identified by end.  As a special case, the half open range [x, x) is empty, for any valid iterator x.

The most primitive examples of iterators in C++ (and likely the inspiration for their syntax) are the built-in pointers, which are commonly used to iterate over elements within arrays.

Iteration over a Container 
Accessing (but not modifying) each element of a container group of type C<T> using an iterator.

 for (
      typename C<T>::const_iterator iter = group.begin();
      iter != group.end();
      ++iter
     )
 {
     T const &element = *iter;

     // access element here
 }

Note the usage of typename. It informs the compiler that 'const_iterator' is a type as opposed to a static member variable.  (It is only necessary inside templated code, and indeed in C++98 is invalid in regular, non-template, code.  This may change in the next revision of the C++ standard so that the typename above is always permitted.)

Modifying each element of a container group of type C<T> using an iterator.

 for (
      typename C<T>::iterator iter = group.begin();
      iter != group.end();
      ++iter
     )
 {
     T &element = *iter;

     // modify element here
 }

When modifying the container itself while iterating over it, some containers (such as vector) require care that the iterator doesn't become invalidated, and end up pointing to an invalid element.  For example, instead of:

  for (i = v.begin(); i != v.end(); ++i) {
    ...
    if (erase_required) {
      v.erase(i);
    }
  }

Do:

  for (i = v.begin(); i != v.end(); ) {
    ...
    if (erase_required) {
        i = v.erase(i);
    } else {
        ++i;
    }
  }

The erase() member function returns the next valid iterator, or end(), thus ending the loop.  Note that ++i is not executed when erase() has been called on an element.

Functors
A functor or function object, is an object that has an operator ().  The importance of functors is that they can be used in many contexts in which C++ functions can be used, whilst also having the ability to maintain state information.  Next to iterators, functors are one of the most fundamental ideas exploited by the STL.

The STL provides a number of pre-built functor classes; std::less, for example, is often used to specify a default comparison function for algorithms that need to determine which of two objects comes "before" the other.

 #include <vector>
 #include <algorithm>
 #include <iostream>

 // Define the Functor for AccumulateSquareValues
 template<typename T>
 struct AccumulateSquareValues
 {
     AccumulateSquareValues() : sumOfSquares()
     {
     }
     void operator()(const T& value)
     {
         sumOfSquares += value*value;
     }
     T Result() const
     {
         return sumOfSquares;
     }
     T sumOfSquares;
 };

 std::vector<int> intVec;
 intVec.reserve(10);
 for( int idx = 0; idx < 10; ++idx )
 {
     intVec.push_back(idx);
 }
 AccumulateSquareValues<int> sumOfSquare = std::for_each(intVec.begin(), 
                                                         intVec.end(), 
                                                         AccumulateSquareValues<int>() );
 std::cout << "The sum of squares for 1-10 is " << sumOfSquare.Result() << std::endl;

 // note: this problem can be solved in another, more clear way:
 // int sum_of_squares = std::inner_product(intVec.begin(), intVec.end(), intVec.begin(), 0);

 Algorithms 
The STL also provides several useful algorithms, in the form of template functions, that are provided to, with the help of the iterator concept, manipulate the STL containers (or derivations).

The STL algorithms aren't restricted to STL containers, for instance:

#include <algorithm>

  int array[10] = { 2,3,4,5,6,7,1,9,8,0 };

  int* begin = &array[0];
  int* end = &array[0] + 10;

  std::sort(begin, end);// the sort algorithm will work on a C style array

The _if suffix
The _copy suffix

Non-modifying algorithms 
Modifying algorithms 
Removing algorithms 
Mutating algorithms 
Sorting algorithms 
Sorted range algorithms 
Numeric algorithms

 Permutations 

 Sorting and related operations 

 Minimum and maximum 
The standard library provides function templates min and max, which return the minimum and maximum of their two arguments respectively. Each has an overload available that allows you to customize the way the values are compared.

template<class T>
const T& min(const T& a, const T& b);

template<class T, class Compare>
const T& min(const T& a, const T& b, Compare c);

template<class T>
const T& max(const T& a, const T& b);

template<class T, class Compare>
const T& max(const T& a, const T& b, Compare c);

An example of how to use the Compare type parameter :

 #include <iostream>
 #include <algorithm>
 #include <string>

 class Account
 {
	 private :
         std::string owner_name;
	 int credit;
	 int potential_credit_transfer;

	 public :
	 Account(){}
	 Account(std::string name, int initial_credit, int initial_credit_transfer) :
	 	 owner_name(name),
	         credit(initial_credit),
	         potential_credit_transfer(initial_credit_transfer)
	 {}

	 bool operator<(Account const& account) const { return credit < account.credit; }

	 int potential_credit() const { return credit + potential_credit_transfer; }

	 std::string const& owner() const { return owner_name; }
 };

 struct CompareAccountCredit
 {
	 bool operator()(Account const& account1, Account const& account2) const 
         { return account1 < account2; }
 };

 struct CompareAccountPotentialCredit
 {
	 bool operator()(Account const& account1, Account const& account2) const 
         { return account1.potential_credit() < account2.potential_credit(); }
 };

 int main()
 {
	 Account account1("Dennis Ritchie", 1000, 250), account2("Steeve Jobs", 500, 10000), 
         result_comparison;

	 result_comparison = std::min(account1, account2, CompareAccountCredit());
	 std::cout << "min credit of account is : " + result_comparison.owner() << std::endl;

	 result_comparison = std::min(account1, account2, CompareAccountPotentialCredit());
	 std::cout << "min potential credit of account is : " + result_comparison.owner() << std::endl;

	 return 0;
 }

Allocators
Allocators are used by the Standard C++ Library (and particularly by the STL) to allow parameterization of memory allocation strategies.  

The subject of allocators is somewhat obscure, and can safely be ignored by most application software developers.  All standard library constructs that allow for specification of an allocator have a default allocator which is used if none is given by the user.

Custom allocators can be useful if the memory use of a piece of code is unusual in a way that leads to performance problems if used with the general-purpose default allocator.  There are also other cases in which the default allocator is inappropriate, such as when using standard containers within an implementation of replacements for global operators new and delete.

 Smart Pointers 
Using raw pointers to store allocated data and then cleaning them up in the destructor can generally be considered a very bad idea since it is error-prone.  Even temporarily storing allocated data in a raw pointer and then deleting it when done with it should be avoided for this reason.  For example, if your code throws an exception, it can be cumbersome to properly catch the exception and delete all allocated objects.  

Smart pointers can alleviate this headache by using the compiler and language semantics to ensure the pointer content is automatically released when the pointer itself goes out of scope.

#include <memory>
class A
{
public:
        virtual ~A() {}
	virtual char val() = 0;
};

class B : public A
{
public:
	virtual char val() { return 'B'; }
};

A* get_a_new_b()
{
	return new B();
}

bool some_func()
{
	bool rval = true;
	std::auto_ptr<A> a( get_a_new_b() );
	try {
		std::cout << a->val();
	} catch(...) {
		if( !a.get() ) {
			throw "Memory allocation failure!";
		}
		rval = false;
	}
	return rval;
}

Semantics
The auto_ptr has semantics of strict ownership, meaning that the auto_ptr instance is the sole entity responsible for the object's lifetime. If an auto_ptr is copied, the source loses the reference. For example:

#include <iostream>
#include <memory>
using namespace std;

int main(int argc, char **arv)
{
    int *i = new int;
    auto_ptr<int> x(i);
    auto_ptr<int> y;

    y = x;

    cout << x.get() << endl;
    cout << y.get() << endl;
}

This code will print a NULL address for the first auto_ptr object and some non-NULL address for the second, showing that the source object lost the reference during the assignment (=). The raw pointer i in the example should not be deleted, as it will be deleted by the auto_ptr that owns the reference.  In fact, new int could be passed directly into x, eliminating the need for i.

Notice that the object pointed by an auto_ptr is destructed using operator delete; this means that you should only use auto_ptr for pointers obtained with operator new. This excludes pointers returned by malloc(), calloc() or realloc() and operator new[].

 Exception Handling 
Exception handling is a construct designed to handle the occurrence of exceptions, that is special conditions that changes the normal flow of program execution. Since when designing a programming task (a class or even a function), one cannot always assume that application/task will run or be completed correctly (exit with the result it was intended to). It may be the case that it will be just inappropriate for that given task to report an error message (return an error code) or just exit. To handle these types of cases, C++ supports the use of language constructs to separate error handling and reporting code from ordinary code, that is, constructs that can deal with these exceptions (errors and abnormalities) and so we call this global approach that adds uniformity to program design the exception handling.

An exception is said to be thrown at the place where some error or abnormal condition is detected. The throwing will cause the normal program flow to be aborted, in a raised exception. An exception is thrown programmatic, the programmer specifies the conditions of a throw.

In handled exceptions, execution of the program will resume at a designated block of code, called a catch block, which encloses the point of throwing in terms of program execution. The catch block can be, and usually is, located in a different function/method than the point of throwing. In this way, C++ supports non-local error handling. Along with altering the program flow, throwing of an exception passes an object to the catch block. This object can provide data that is necessary for the handling code to decide in which way it should react on the exception.

Consider this next code example of a try and catch block combination for clarification:

void AFunction()
{
    // This function does not return normally, 
    // instead execution will resume at a catch block.
    // The thrown object is in this case of the type char const*,
    // i.e. it is a C-style string. More usually, exception
    // objects are of class type.
    throw "This is an exception!"; 
}

void AnotherFunction()
{
    // To catch exceptions, you first have to introduce
    // a try block via " try { ... } ". Then multiple catch
    // blocks can follow the try block.
    // " try { ... } catch(type 1) { ... } catch(type 2) { ... }"
    try 
    {
        AFunction();
       // Because the function throws an exception,
       // the rest of the code in this block will not
       // be executed
    }
    catch(char const* pch)  // This catch block 
                            // will react on exceptions
                            // of type char const*
    {
        // Execution will resume here.
        // You can handle the exception here.
    }
               // As can be seen
    catch(...) // The ellipsis indicates that this
               // block will catch exceptions of any type. 
    {
       // In this example, this block will not be executed,
       // because the preceding catch block is chosen to 
       // handle the exception.
    }
}

Unhandled exceptions on the other hand will result in a function termination and the stack will be unwound (stack allocated objects will have destructors called) as it looks for an exception handler. If none is found it will ultimately result in the termination of the program.

From the point of view of a programmer, raising an exception is a useful way to signal that a routine could not execute normally. For example, when an input argument is invalid (e.g. a zero denominator in division) or when a resource it relies on is unavailable (like a missing file, or a hard disk error). In systems without exceptions, routines would need to return some special error code. However, this is sometimes complicated by the semi-predicate problem, in which users of the routine need to write extra code to distinguish normal return values from erroneous ones.

Because it is hard to write exception safe code, you should only use an exception when you have to—when an error has occurred that you can not handle. Do not use exceptions for the normal flow of the program.

This example is wrong, it is a demonstration on what to avoid: 

void sum(int iA, int iB)
{
    throw iA + iB;
}

int main()
{
    int iResult;

    try 
    {
        sum(2, 3);
    }
    catch(int iTmpResult)  
    {
        // Here the exception is used instead of a return value!
        // This is  wrong!
        iResult = iTmpResult;
    }

    return 0;
}

 Stack unwinding 
Consider the following code

void g()
{ 
    throw std::exception();
}

void f()
{
    std::string str = "Hello"; // This string is newly allocated
    g();
}

int main()
{
    try
    {
        f();
    }
    catch(...) 
    { }
}

The flow of the program:
 main() calls f()
 f() creates a local variable named str
 str constructor allocates a memory chunk to hold the string "Hello"
 f() calls g()
 g()throws an exception
 f() does not catch the exception. 
 Because the exception was not caught, we now need to exit f() in a clean fashion.
 At this point, all the destructors of local variables previous to the throw
 are called—This is called 'stack unwinding'.
 The destructor of str is called, which releases the memory occupied by it. 
 As you can see, the mechanism of 'stack unwinding' is essential to prevent resource leaks—without it, str would never be destroyed, and the memory it used would be lost until the end of the program (even until the next loss of power, or cold boot depending on the Operative System memory management).
 main() catches the exception
 The program continues.

The 'stack unwinding' guarantees destructors of local variables (stack variables) will be called
when we leave its scope.

 Throwing objects 
There are several ways to throw an exception object.

Throw a pointer to the object:

void foo()
{
    throw new MyApplicationException();
}

void bar()
{
    try 
    {
        foo();
    }
    catch(MyApplicationException* e)
    {
        // Handle exception
    }
}

But now, who is responsible to delete the exception? The handler? This makes code uglier. There must be a better way!

How about this:

void foo()
{
    throw MyApplicationException();
}

void bar()
{
    try 
    {
        foo();
    }
    catch(MyApplicationException e)
    {
        // Handle exception
    }
}

Looks better! But now, the catch handler that catches the exception, does it by value, meaning that a copy constructor is called. This can cause the program to crash if the exception caught was a bad_alloc caused by insufficient memory. In such a situation, seemingly safe code that is assumed to handle memory allocation problems results in the program crashing with a failure of the exception handler. Moreover, catching by value may cause the copy to have different behavior because of object slicing.

The correct approach is:

void foo()
{
    throw MyApplicationException();
}

void bar()
{
    try 
    {
        foo();
    }
    catch(MyApplicationException const& e)
    {
        // Handle exception
    }
}

This method has all the advantages—the compiler is responsible for destroying the object, and no copying is done at catch time!

The conclusion is that exceptions should be thrown by value, and caught by (usually const) reference.

 Constructors and destructors 
When an exception is thrown from a constructor, the object is not considered instantiated, and therefore its destructor will not be called. But all destructors of already successfully constructed base and member objects of the same master object will be called. Destructors of not yet constructed base or member objects of the same master object will not be executed. Example:

class A : public B, public C
{
public:
    D sD;
    E sE;
    A(void)
    :B(), C(), sD(), sE()
    {
    }
};

Let's assume the constructor of base class C throws. Then the order of execution is: 
 B
 C (throws)
 ~B

Let's assume the constructor of member object sE throws. Then the order of execution is:
 B
 C
 sD
 sE (throws)
 ~sD
 ~C
 ~B
Thus if some constructor is executed, one can rely on that all other constructors of the same master object executed before, were successful. This enables one, to use an already constructed member or base object as an argument for the constructor of one of the following member or base objects of the same master object.

What happens when we allocate this object with new?
 Memory for the object is allocated
 The object's constructor throws an exception
 The object was not instantiated due to the exception
 The memory occupied by the object is deleted
 The exception is propagated, until it is caught

The main purpose of throwing an exception from a constructor is to inform the program/user that the creation and initialization of the object did not finish correctly. This is a very clean way of providing this important information, as constructors do not return a separate value containing some error code (as an initialization function might).

In contrast, it is strongly recommended not to throw exceptions inside a destructor. It is important to note when a destructor is called: 
 as part of a normal deallocation (exit from a scope, delete)
 as part of a stack unwinding that handles a previously thrown exception. 

In the former case, throwing an exception inside a destructor can simply cause memory leaks due to incorrectly deallocated object. In the latter, the code must be more clever. If an exception was thrown as part of the stack unwinding caused by another exception, there is no way to choose which exception to handle first. This is interpreted as a failure of the exception handling mechanism and that causes the program to call the function terminate.

To address this problem, it is possible to test if the destructor was called as part of an exception handling process. To this end, one should use the standard library function uncaught_exception, which returns true if an exception has been thrown, but hasn't been caught yet. All code executed in such a situation must not throw another exception.

Situations where such careful coding is necessary are extremely rare. It is far safer and easier to debug if the code was written in such a way that destructors did not throw exceptions at all.

 Writing exception safe code 
Exception safety
A piece of code is said to be exception-safe, if run-time failures within the code will not produce ill effects, such as memory leaks, garbled stored data, or invalid output. Exception-safe code must satisfy invariants placed on the code even if exceptions occur. There are several levels of exception safety:
 Failure transparency, also known as the no throw guarantee: Operations are guaranteed to succeed and satisfy all requirements even in presence of exceptional situations. If an exception occurs, it will not throw the exception further up. (Best level of exception safety.)
 Commit or rollback semantics, also known as strong exception safety or no-change guarantee: Operations can fail, but failed operations are guaranteed to have no side effects so all data retain original values.
 Basic exception safety: Partial execution of failed operations can cause side effects, but invariants on the state are preserved. Any stored data will contain valid values even if data has different values now from before the exception.
 Minimal exception safety also known as no-leak guarantee: Partial execution of failed operations may store invalid data but will not cause a crash, and no resources get leaked.
 No exception safety: No guarantees are made. (Worst level of exception safety)

 Partial handling 
Consider the following case:

void g()
{
    throw "Exception";
}

void f()
{
    int* pI = new int(0);
    g();
    delete pI;
}

int main()
{
    f();
    return 0;
}

Can you see the problem in this code? If g() throws an exception, the variable pI is never deleted and we have a memory leak.

To prevent the memory leak, f() must catch the exception, and delete pI.
But f() can't handle the exception, it doesn't know how! 

What is the solution then? f() shall catch the exception, and then re-throw it:

void g()
{
    throw "Exception";
}

void f()
{
    int* pI = new int(0);

    try
    {
        g();
    }
    catch (...)
    {
        delete pI;
        throw; // This empty throw re-throws the exception we caught
               // An empty throw can only exist in a catch block
    }

    delete pI;
}

int main()
{
    f();
    return 0;
}

There's a better way though; using RAII classes to avoid the need to use exception handling.

 Guards 
If you plan to use exceptions in your code, you must always try to write your code in an exception safe manner. Let's see some of the problems that can occur:

Consider the following code:

void g()
{ 
    throw std::exception();
}

void f()
{
    int* pI = new int(2);

    *pI = 3;
    g();
    // Oops, if an exception is thrown, pI is never deleted
    // and we have a memory leak
    delete pI;
}

int main()
{
    try
    {
        f();
    } 
    catch(...) 
    { }

    return 0;
}

Can you see the problem in this code? When an exception is thrown, we will never run the line that deletes pI!

What's the solution to this? Earlier we saw a solution based on f() ability to catch and re-throw. But there is a neater solution using the 'stack unwinding' mechanism.
But 'stack unwinding' only applies to destructors for objects, so how can we use it?

We can write a simple wrapper class:

 // Note: This type of class is best implemented using templates, discussed in the next chapter.
 class IntDeleter {
 public:
    IntDeleter(int* piValue)
    {
        m_piValue = piValue;
    }

    ~IntDeleter() 
    {
        delete m_piValue;
    }

    // operator *, enables us to dereference the object and use it
    // like a regular pointer.
    int&  operator *() 
    {
        return *m_piValue;
    }

 private:
     int* m_piValue;
 };

The new version of f():

 void f()
 {
   IntDeleter pI(new int(2));

   *pI = 3;
   g();
   // No need to delete pI, this will be done in destruction.
   // This code is also exception safe.
 }

The pattern presented here is called a guard. A guard is very useful in other cases, and it can also help us make our code more exception safe. The guard pattern is similar to a finally block in other languages.

Note that the C++ Standard Library provides a templated guard by the name of unique_ptr.

 Exception hierarchy 
You may throw as exception an object (like a class or string), a pointer (like char*), or a primitive (like int). So, which should you choose?
You should throw objects, as they ease the handling of exceptions for the programmer. It is common to create a class hierarchy of exception classes:
 class MyApplicationException {};
 class MathematicalException : public MyApplicationException {};
 class DivisionByZeroException : public MathematicalException {};
 class InvalidArgumentException : public MyApplicationException {};

An example:

float divide(float fNumerator, float fDenominator)
{
    if (fDenominator == 0.0)
    {
        throw DivisionByZeroException();
    }

    return fNumerator/fDenominator;
}

enum MathOperators {DIVISION, PRODUCT};

float operate(int iAction, float fArgLeft, float fArgRight)
{ 
    if (iAction == DIVISION)
    {
        return divide(fArgLeft, fArgRight);
    }
    else if (iAction == PRODUCT))
    {
        // call the product function
        // ... 
    }

    // No match for the action! iAction is an invalid agument
    throw InvalidArgumentException(); 
}

int main(int iArgc, char* a_pchArgv[])
{
    try
    {
        operate(atoi(a_pchArgv[0]), atof(a_pchArgv[1]), atof(a_pchArgv[2]));
    } 
    catch(MathematicalException& )
    {
        // Handle Error
    }
    catch(MyApplicationException& )
    {
        // This will catch in InvalidArgumentException too.
        // Display help to the user, and explain about the arguments.
    }

    return 0;
}

 Exception specifications 

The range of exceptions that can be thrown by a function are an important part of that function's public interface. Without this information, you would have to assume that any exception could occur when calling any function, and consequently write code that was extremely defensive. Knowing the list of exceptions that can be thrown, you can simplify your code since it doesn't need to handle every case.

This exception information is specifically part of the public interface. Users of a class don't need to know anything about the way it is implemented, but they do need to know about the exceptions that can be thrown, just as they need to know the number and type of parameters to a member function. One way of providing this information to clients of a library is via code documentation, but this needs to be manually updated very carefully. Incorrect exception information is worse than none at all, since you may end up writing code that is less exception-safe than you intended to.

C++ provides another way of recording the exception interface, by means of exception specifications. An exception specification is parsed by the compiler, which provides a measure of automated checking. An exception specification can be applied to any function, and looks like this:

double divide(double dNumerator, double dDenominator) throw (DivideByZeroException);

You can specify that a function cannot throw any exceptions by using an empty exception specification:

void safeFunction(int iFoo) throw();

 Shortcomings of exception specifications 
C++ does not programmatically enforce exception specifications at compile time. For example, the following code is legal:

void DubiousFunction(int iFoo) throw()
{
    if (iFoo < 0)
    {
        throw RangeException();
    }
}

Rather than checking exception specifications at compile time, C++ checks them at run time, which means that you might not realize that you have an inaccurate exception specification until testing or, if you are unlucky, when the code is already in production.

If an exception is thrown at run time that propagates out of a function that doesn't allow the exception in its exception specification, the exception will not propagate any further and instead, the function RangeException() will be called. The RangeException() function doesn't return, but can throw a different type of exception that may (or may not) satisfy the exception specification and allow exception handling to carry on normally. If this still doesn't recover the situation, the program will be terminated.

Many people regard the behavior of attempting to translate exceptions at run time to be worse than simply allowing the exception to propagate up the stack to a caller who may be able to handle it. The fact that the exception specification has been violated does not mean that the caller can't handle the situation, only that the author of the code didn't expect it. Often there will be a catch (...) block somewhere on the stack that can deal with any exception. 

 Noexcept specifiers 

Run-Time Type Information (RTTI)
RTTI refers to the ability of the system to report on the dynamic type of an object and to provide information about that type at runtime (as opposed to at compile time), and when utilized consistently can be a powerful tool to ease the work of the programmer in managing resources.

 dynamic_cast 
Consider what you have already learned about the dynamic_cast keyword, and let's say that we have the following class hierarchy:

class Interface
{
public:
        virtual void GenericOp() = 0;// pure virtual function
};

class SpecificClass : public Interface
{
public:
        virtual void GenericOp();
        virtual void SpecificOp();
};

Let's say that we also have a pointer of type Interface*, like so:

Interface* ptr_interface;

Supposing that a situation emerges that we are forced to presume but have no guarantee that the pointer points to an object of type SpecificClass and we would like to call the member SpecificOp() of that class. To dynamically convert to a derived type we can use dynamic_cast, like so:

SpecificClass* ptr_specific = dynamic_cast<SpecificClass*>(ptr_interface);
if( ptr_specific ){
    // our suspicions are confirmed -- it really was a SpecificClass
    ptr_specific->SpecificOp();
}else{
    // our suspicions were incorrect -- it is definitely not a SpecificClass.
    // The ptr_interface points to an instance of some other child class of the base InterfaceClass.
    ptr_interface->GenericOp();
};

With dynamic_cast, the program converts the base class pointer to a derived class pointer and allows the derived class members to be called. Be very careful, however: if the pointer that you are trying to cast is not of the correct type, then dynamic_cast will return a null pointer.

We can also use dynamic_cast with references.

SpecificClass& ref_specific = dynamic_cast<SpecificClass&>(ref_interface);

This works almost in the same way as pointers. However, if the real type of the object being cast is not correct then dynamic_cast will not return null (there's no such thing as a null reference). Instead, it will throw a std::bad_cast exception.

 typeid 
Syntax

    typeid( object );

The typeid operator is used to determine the class of an object at runtime. It returns a reference to a std::type_info object, which exists until the end of the program, that describes the "object". If the "object" is a dereferenced null pointer, then the operation will throw a std::bad_typeid exception.

Objects of class std::bad_typeid are derived from std::exception, and thrown by typeid and others.

The use of typeid is often preferred over dynamic_cast<class_type> in situations where just the class information is needed, because typeid, applied on a type or non de-referenced value is a constant-time procedure, whereas dynamic_cast must traverse the class derivation lattice of its argument at runtime. However, you should never rely on the exact content, like for example returned by std::type_info::name(), as this is implementation specific with respect to the compile.

It is generally only useful to use typeid on the dereference of a pointer or reference (i.e. typeid(*ptr) or typeid(ref)) to an object of polymorphic class type (a class with at least one virtual member function). This is because these are the only expressions that are associated with run-time type information. The type of any other expression is statically known at compile time.

Example

#include <iostream>
#include <typeinfo>  //for 'typeid' to work

class Person {
public:
   // ... Person members ...
   virtual ~Person() {}
};

class Employee : public Person {
   // ... Employee members ...
};

int main () {
   Person person;
   Employee employee;
   Person *ptr = &employee;
   // The string returned by typeid::name is implementation-defined
   std::cout << typeid(person).name() << std::endl;   // Person (statically known at compile-time)
   std::cout << typeid(employee).name() << std::endl; // Employee (statically known at compile-time)
   std::cout << typeid(ptr).name() << std::endl;      // Person * (statically known at compile-time)
   std::cout << typeid(*ptr).name() << std::endl;     // Employee (looked up dynamically at run-time
                                                      //           because it is the dereference of a
                                                      //           pointer to a polymorphic class)
}

Output (exact output varies by system):

Person
Employee
Person*
Employee

In RTTI it is used in this setup:

const std::type_info& info = typeid(object_expression);

Sometimes we need to know the exact type of an object. The typeid operator returns a reference to a standard class std::type_info that contains information about the type. This class provides some useful members including the == and != operators. The most interesting method is probably:

const char* std::type_info::name() const;

This member function returns a pointer to a C-style string with the name of the object type. For example, using the classes from our earlier example:

const std::type_info &info = typeid(*ptr_interface);
std::cout << info.name() << std::endl;

This program would print something like^[1]
SpecificClass because that is the dynamic type of the pointer ptr_interface.

typeid is actually an operator rather than a function, as it can also act on types:

const std::type_info& info = typeid(type);

for example (and somewhat circularly)

const std::type_info& info = typeid(std::type_info);

will give a type_info object which describes type_info objects.  This latter use is not RTTI, but rather CTTI (compile-time type identification).

Limitations
There are some limitations to RTTI. First, RTTI can only be used with polymorphic types. That means that your classes must have at least one virtual function, either directly or through inheritance. Second, because of the additional information required to store types some compilers require a special switch to enable RTTI.

Note that references to pointers will not work under RTTI:

void example( int*& refptrTest )
{
        std::cout << "What type is *&refptrTest : " << typeid( refptrTest ).name() << std::endl;
}

Will report int*, as typeid() does not support reference types.

Misuses of RTTI
RTTI should only be used sparingly in C++ programs. There are several reasons for this. Most importantly, other language mechanisms such as polymorphism and templates are almost always superior to RTTI. As with everything, there are exceptions, but the usual rule concerning RTTI is more or less the same as with goto statements. Do not use it as a shortcut around proper, more robust design.  Only use RTTI if you have a very good reason to do so and only use it if you know what you are doing.

↑  (The exact string returned by std::type_info::name() is compiler-dependent).

 Chapter Summary 
Templates  
Template Meta-Programming (TMP) 
Standard Template Library (STL) 
Smart Pointers 
Exception Handling 
Run-Time Type Information (RTTI) 

 Beyond the Standard 
 Resource Acquisition Is Initialization (RAII) 
The RAII technique is often used for controlling thread locks in multi-threaded applications.
Another typical example of RAII is file operations, e.g. the C++ standard library's file-streams. An input file stream is opened in the object's constructor, and it is closed upon destruction of the object. Since C++ allows objects to be allocated on the stack, C++'s scoping mechanism can be used to control file access.

With RAII we can use, for instance, Class destructors to guarantee clean up, similar to the finally keyword in other languages. Doing this automates the task and so avoids errors but gives the freedom not to use it.

RAII is also used (as shown in the example below) to ensure exception safety. RAII makes it possible to avoid resource leaks without extensive use of try/catch blocks and is widely used in the software industry.

The ownership of dynamically allocated memory (memory allocated with new) can be controlled with RAII. For this purpose, the C++ Standard Library defines auto ptr. Furthermore, lifetime of shared objects can be managed by a smart pointer with shared-ownership semantics such as boost::shared_ptr defined in C++ by the Boost library or policy based Loki::SmartPtr from Loki library.

The following RAII class is a lightweight wrapper to the C standard library file system calls.

 #include <cstdio>

 // exceptions
 class file_error { } ;
 class open_error : public file_error { } ;
 class close_error : public file_error { } ;
 class write_error : public file_error { } ;

 class file
 {
 public:
     file( const char* filename )
         :
         m_file_handle(std::fopen(filename, "w+"))
     {
         if( m_file_handle == NULL )
         {
             throw open_error() ;
         }
     }

     ~file()
     {
         std::fclose(m_file_handle) ;
     }

     void write( const char* str )
     {
         if( std::fputs(str, m_file_handle) == EOF )
         {
             throw write_error() ;
         }
     }

     void write( const char* buffer, std::size_t num_chars )
     {
         if( num_chars != 0
             &&
             std::fwrite(buffer, num_chars, 1, m_file_handle) == 0 )
         {
             throw write_error() ;
         }
     }

 private:
     std::FILE* m_file_handle ;

     // copy and assignment not implemented; prevent their use by
     // declaring private.
     file( const file & ) ;
     file & operator=( const file & ) ;
 } ;

This RAII class can be used as follows :

void example_with_RAII()
{
  // open file (acquire resource)
  file logfile("logfile.txt") ;

  logfile.write("hello logfile!") ;
  // continue writing to logfile.txt ...

  // logfile.txt will automatically be closed because logfile's
  // destructor is always called when example_with_RAII() returns or
  // throws an exception.
}

Without using RAII, each function using an output log would have to manage the file explicitly.
For example, an equivalent implementation without using RAII is this:

void example_without_RAII()
{
  // open file
  std::FILE* file_handle = std::fopen("logfile.txt", "w+") ;

  if( file_handle == NULL )
  {
    throw open_error() ;
  }

  try
  {

    if( std::fputs("hello logfile!", file_handle) == EOF )
    {
      throw write_error() ;
    }

    // continue writing to logfile.txt ... do not return
    // prematurely, as cleanup happens at the end of this function
  }
  catch(...)
  {
    // manually close logfile.txt
    std::fclose(file_handle) ;

    // re-throw the exception we just caught
    throw ;
  }

  // manually close logfile.txt 
  std::fclose(file_handle) ;
}

The implementation of file and example_without_RAII() becomes more complex if fopen() and fclose() could potentially throw exceptions; example_with_RAII() would be unaffected, however.

The essence of the RAII idiom is that the class file encapsulates the management of any finite resource, like the FILE* file handle. It guarantees that the resource will properly be disposed of at function exit. Furthermore, file instances guarantee that a valid log file is available (by throwing an exception if the file could not be opened).

There's also a big problem in the presence of exceptions: in example_without_RAII(), if more than one resource were allocated, but an exception was to be thrown between their allocations, there's no general way to know which resources need to be released in the final catch block - and releasing a not-allocated resource is usually a bad thing. RAII takes care of this problem; the automatic variables are destructed in the reverse order of their construction, and an object is only destructed if it was fully constructed (no exception was thrown inside its constructor). So example_without_RAII() can never be as safe as example_with_RAII() without special coding for each situation, such as checking for invalid default values or nesting try-catch blocks.  Indeed, it should be noted that example_without_RAII() contained resource bugs in previous versions of this article.

This frees example_with_RAII() from explicitly managing the resource as would otherwise be required. When several functions use file, this simplifies and reduces overall code size and helps ensure program correctness.

example_without_RAII() resembles the idiom used for resource management in non-RAII languages such as Java. While Java's try-finally blocks allow for the correct release of resources, the burden nonetheless falls on the programmer to ensure correct behavior, as each and every function using file may explicitly demand the destruction of the log file with a try-finally block.

 Garbage collection 
Garbage collection is a form of automatic memory management. The garbage collector or collector attempts to reclaim garbage, or memory used by objects that will never be accessed or mutated again by the application.

Tracing garbage collectors require some implicit runtime overhead that may be beyond the control of the programmer, and can sometimes lead to performance problems. For example, commonly used Stop-The-World garbage collectors, which pause program execution at arbitrary times, may make garbage collecting languages inappropriate for some embedded systems, high-performance server software, and applications with real-time needs.

A more fundamental issue is that garbage collectors violate locality of reference, since they deliberately go out of their way to find bits of memory that haven't been accessed recently. The performance of modern computer architectures is increasingly tied to caching, which depends on the assumption of locality of reference for its effectiveness. Some garbage collection methods result in better locality of reference than others. Generational garbage collection is relatively cache-friendly, and copying collectors automatically defragment memory helping to keep related data together. Nonetheless, poorly timed garbage collection cycles could have a severe performance impact on some computations, and for this reason many runtime systems provide mechanisms that allow the program to temporarily suspend, delay or activate garbage collection cycles.

Despite these issues, for many practical purposes, allocation/deallocation-intensive algorithms implemented in modern garbage collected languages can actually be faster than their equivalents using explicit memory management (at least without heroic optimizations by an expert programmer). A major reason for this is that the garbage collector allows the runtime system to amortize allocation and deallocation operations in a potentially advantageous fashion. For example, consider the following program in C++:

#include <iostream>

class A {
  int x;
public:
  A() { x = 0; ++x; }
};

int main() {
 for (int i = 0; i < 1000000000; ++i) {
   A *a = new A();
   delete a;
 }
 std::cout << "DING!" << std::endl;
}

One of more widely used libraries that provides this function is Hans Boehm's conservative GC.  As we have seen earlier C++ also supports a powerful idiom called RAII (resource acquisition is initialization) that can be used to safely and automatically manage resources including memory.

 Programming Patterns 

Software design patterns are abstractions that help structure system designs. While not new, since the concept was already described by Christopher Alexander in its architectural theories, it only gathered some traction in programming due to the publication of Design Patterns: Elements of Reusable Object-Oriented Software book in October 1994 by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides, known as the Gang of Four (GoF), that identifies and describes 23 classic software design patterns. 

A design pattern is neither a static solution, nor is it an algorithm. A pattern is a way to describe and address by name (mostly a simplistic description of its goal), a repeatable solution or approach to a common design problem, that is, a common way to solve a generic problem (how generic or complex, depends on how restricted the target goal is). Patterns can emerge on their own or by design. This is why design patterns are useful as an abstraction over the implementation and a help at design stage. With this concept, an easier way to facilitate communication over a design choice as normalization technique is given so that every person can share the design concept.

Depending on the design problem they address, design patterns can be classified in different categories, of which the main categories are:
Creational Patterns
Structural Patterns
Behavioral Patterns. 

Patterns are commonly found in objected-oriented programming languages like C++ or Java. They can be seen as a template for how to solve a problem that occurs in many different situations or applications. It is not code reuse, as it usually does not specify code, but code can be easily created from a design pattern. Object-oriented design patterns typically show relationships and interactions between classes or objects without specifying the final application classes or objects that are involved. 

Each design pattern consists of the following parts:

 Problem/requirement 
 To use a design pattern, we need to go through a mini analysis design that may be coded to test out the solution.  This section states the requirements of the problem we want to solve. This is usually a common problem that will occur in more than one application.

 Forces 
 This section states the technological boundaries, that helps and guides the creation of the solution.

 Solution 
 This section describes how to write the code to solve the above problem. This is the design part of the design pattern. It may contain class diagrams, sequence diagrams, and or whatever is needed to describe how to code the solution.

Design patterns can be considered as a standardization of commonly agreed best practices to solve specific design problems. One should understand them as a way to implement good design patterns within applications. Doing so will reduce the use of inefficient and obscure solutions^{[citation needed]}. Using design patterns speeds up your design and helps to communicate it to other programmers^{[citation needed]}.

 Creational Patterns 
In software engineering, creational design patterns are design patterns that deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic form of object creation could result in design problems or added complexity to the design. Creational design patterns solve this problem by somehow controlling this object creation. 

In this section of the book we assume that the reader has enough familiarity with functions, global variables, stack vs. heap, classes, pointers, and static member functions as introduced before. 

As we will see there are several creational design patterns, and all will deal with a specific implementation task, that will create a higher level of abstraction to the code base, we will now cover each one.

 Builder 
The Builder Creational Pattern is used to separate the construction of a complex object from its representation so that the same construction process can create different objects representations.

 Problem 
 We want to construct a complex object, however we do not want to have a complex constructor member or one that would need many arguments.

 Solution 
 Define an intermediate object whose member functions define the desired object part by part before the object is available to the client.  Builder Pattern lets us defer the construction of the object until all the options for creation have been specified.

#include <string>
#include <iostream>
#include <memory>
using namespace std;

// "Product"
class Pizza
{
public:
	void setDough(const string& dough)
	{
		m_dough = dough;
	}
	void setSauce(const string& sauce)
	{
		m_sauce = sauce;
	}
	void setTopping(const string& topping)
	{
		m_topping = topping;
	}
	void open() const
	{
		cout << "Pizza with " << m_dough << " dough, " << m_sauce << " sauce and "
			<< m_topping << " topping. Mmm." << endl;
	}
private:
	string m_dough;
	string m_sauce;
	string m_topping;
};

// "Abstract Builder"
class PizzaBuilder
{
public:
	virtual ~PizzaBuilder() {};

	Pizza* getPizza()
	{
		return m_pizza.get();
	}
	void createNewPizzaProduct()
	{
		m_pizza = make_unique<Pizza>();
	}
	virtual void buildDough() = 0;
	virtual void buildSauce() = 0;
	virtual void buildTopping() = 0;
protected:
	unique_ptr<Pizza> m_pizza;
};

//----------------------------------------------------------------

class HawaiianPizzaBuilder : public PizzaBuilder
{
public:
	virtual ~HawaiianPizzaBuilder() {};

	virtual void buildDough()
	{
		m_pizza->setDough("cross");
	}
	virtual void buildSauce()
	{
		m_pizza->setSauce("mild");
	}
	virtual void buildTopping()
	{
		m_pizza->setTopping("ham+pineapple");
	}
};

class SpicyPizzaBuilder : public PizzaBuilder
{
public:
	virtual ~SpicyPizzaBuilder() {};

	virtual void buildDough()
	{
		m_pizza->setDough("pan baked");
	}
	virtual void buildSauce()
	{
		m_pizza->setSauce("hot");
	}
	virtual void buildTopping()
	{
		m_pizza->setTopping("pepperoni+salami");
	}
};

//----------------------------------------------------------------

class Cook
{
public:
	void openPizza()
	{
		m_pizzaBuilder->getPizza()->open();
	}
	void makePizza(PizzaBuilder* pb)
	{
		m_pizzaBuilder = pb;
		m_pizzaBuilder->createNewPizzaProduct();
		m_pizzaBuilder->buildDough();
		m_pizzaBuilder->buildSauce();
		m_pizzaBuilder->buildTopping();
	}
private:
	PizzaBuilder* m_pizzaBuilder;
};

int main()
{
	Cook cook;
	HawaiianPizzaBuilder hawaiianPizzaBuilder;
	SpicyPizzaBuilder    spicyPizzaBuilder;

	cook.makePizza(&hawaiianPizzaBuilder);
	cook.openPizza();

	cook.makePizza(&spicyPizzaBuilder);
	cook.openPizza();
}

 Factory 
Definition: A utility class that creates an instance of a class from a family of derived classes

 Abstract Factory 
Definition: A utility class that creates an instance of several families of classes. It can also return
a factory for a certain group.

The Factory Design Pattern is useful in a situation that requires the creation of many different types of objects, all derived from a common base type. The Factory Method defines a method for creating the objects, which subclasses can then override to specify the derived type that will be created. Thus, at run time, the Factory Method can be passed a description of a desired object (e.g., a string read from user input) and return a base class pointer to a new instance of that object. The pattern works best when a well-designed interface is used for the base class, so there is no need to cast the returned object.

 Problem 
 We want to decide at run time what object is to be created based on some configuration or application parameter. When we write the code, we do not know what class should be instantiated.  

 Solution 
 Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

In the following example, a factory method is used to create laptop or desktop computer objects at run time.

Let's start by defining Computer, which is an abstract base class (interface) and its derived classes: Laptop and Desktop.

 class Computer
 {
 public:
     virtual void Run() = 0;
     virtual void Stop() = 0;

     virtual ~Computer() {}; /* without this, you do not call Laptop or Desktop destructor in this example! */
 };
 class Laptop: public Computer
 {
 public:
     void Run() override {mHibernating = false;}; 
     void Stop() override {mHibernating = true;}; 
     virtual ~Laptop() {}; /* because we have virtual functions, we need virtual destructor */
 private:
     bool mHibernating; // Whether or not the machine is hibernating
 };
 class Desktop: public Computer
 {
 public:
     void Run() override {mOn = true;}; 
     void Stop() override {mOn = false;}; 
     virtual ~Desktop() {};
 private:
     bool mOn; // Whether or not the machine has been turned on
 };

The actual ComputerFactory class returns a Computer, given a real world description of the object.

 class ComputerFactory
 {
 public:
     static Computer *NewComputer(const std::string &description)
     {
         if(description == "laptop")
             return new Laptop;
         if(description == "desktop")
             return new Desktop;
         return NULL;
     }
 };

Let's analyze the benefits of this design. First, there is a compilation benefit. If we move the interface Computer into a separate header file with the factory, we can then move the implementation of the NewComputer() function into a separate implementation file. Now the implementation file for NewComputer() is the only one that requires knowledge of the derived classes. Thus, if a change is made to any derived class of Computer, or a new Computer subtype is added, the implementation file for NewComputer() is the only file that needs to be recompiled. Everyone who uses the factory will only care about the interface, which should remain consistent throughout the life of the application.

Also, if there is a need to add a class, and the user is requesting objects through a user interface, no code calling the factory may be required to change to support the additional computer type. The code using the factory would simply pass on the new string to the factory, and allow the factory to handle the new types entirely.

Imagine programming a video game, where you would like to add new types of enemies in the future, each of which has different AI functions and can update differently. By using a factory method, the controller of the program can call to the factory to create the enemies, without any dependency or knowledge of the actual types of enemies. Now, future developers can create new enemies, with new AI controls and new drawing member functions, add it to the factory, and create a level which calls the factory, asking for the enemies by name. Combine this method with an XML description of levels, and developers could create new levels without having to recompile their program. All this, thanks to the separation of creation of objects from the usage of objects.

Another example:

#include <stdexcept>
#include <iostream>
#include <memory>
using namespace std;

class Pizza {
public:
	virtual int getPrice() const = 0;
	virtual ~Pizza() {};  /* without this, no destructor for derived Pizza's will be called. */
};

class HamAndMushroomPizza : public Pizza {
public:
	virtual int getPrice() const { return 850; };
	virtual ~HamAndMushroomPizza() {};
};

class DeluxePizza : public Pizza {
public:
	virtual int getPrice() const { return 1050; };
	virtual ~DeluxePizza() {};
};

class HawaiianPizza : public Pizza {
public:
	virtual int getPrice() const { return 1150; };
	virtual ~HawaiianPizza() {};
};

class PizzaFactory {
public:
	enum PizzaType {
		HamMushroom,
		Deluxe,
		Hawaiian
	};

	static unique_ptr<Pizza> createPizza(PizzaType pizzaType) {
		switch (pizzaType) {
		case HamMushroom: return make_unique<HamAndMushroomPizza>();
		case Deluxe:      return make_unique<DeluxePizza>();
		case Hawaiian:    return make_unique<HawaiianPizza>();
		}
		throw "invalid pizza type.";
	}
};

/*
* Create all available pizzas and print their prices
*/
void pizza_information(PizzaFactory::PizzaType pizzatype)
{
	unique_ptr<Pizza> pizza = PizzaFactory::createPizza(pizzatype);
	cout << "Price of " << pizzatype << " is " << pizza->getPrice() << std::endl;
}

int main()
{
	pizza_information(PizzaFactory::HamMushroom);
	pizza_information(PizzaFactory::Deluxe);
	pizza_information(PizzaFactory::Hawaiian);
}

 Prototype 
A prototype pattern is used in software development when the type of objects to create is determined by a prototypical instance, which is cloned to produce new objects. This pattern is used, for example, when the inherent cost of creating a new object in the standard way (e.g., using the new keyword) is prohibitively expensive for a given application.

Implementation: Declare an abstract base class that specifies a pure virtual clone() method. Any class that needs a "polymorphic constructor" capability derives itself from the abstract base class, and implements the clone() operation.

Here the client code first invokes the factory method. This factory method, depending on the parameter, finds out the concrete class.  On this concrete class, the clone() method is called and the object is returned by the factory method.

 This is a sample implementation of Prototype method. We have the detailed description of all the components here.
 Record class, which is a pure virtual class that has a pure virtual method clone().
 CarRecord, BikeRecord and PersonRecord as concrete implementation of a Record class.
 An enum RecordType as one to one mapping of each concrete implementation of Record class.
 RecordFactory class that has a Factory method CreateRecord(…). This method requires an enum RecordType as parameter and depending on this parameter it returns the concrete implementation of Record class.

/** Implementation of Prototype Method **/
#include <iostream>
#include <unordered_map>
#include <string>
#include <memory>
using namespace std;

/** Record is the base Prototype */
class Record
{
public:
	virtual ~Record() {}
	virtual void print() = 0;
	virtual unique_ptr<Record> clone() = 0;
};

/** CarRecord is a Concrete Prototype */
class CarRecord : public Record
{
private:
	string m_carName;
	int m_ID;

public:
	CarRecord(string carName, int ID) : m_carName(carName), m_ID(ID)
	{
	}

	void print() override
	{
		cout << "Car Record" << endl
		     << "Name  : "   << m_carName << endl
		     << "Number: "   << m_ID << endl << endl;
	}

	unique_ptr<Record> clone() override
	{
		return make_unique<CarRecord>(*this);
	}
};

/** BikeRecord is the Concrete Prototype */
class BikeRecord : public Record
{
private:
	string m_bikeName;
	int m_ID;

public:
	BikeRecord(string bikeName, int ID) : m_bikeName(bikeName), m_ID(ID)
	{
	}

	void print() override
	{
		cout << "Bike Record" << endl
		     << "Name  : " << m_bikeName << endl
		     << "Number: " << m_ID << endl << endl;
	}

	unique_ptr<Record> clone() override
	{
		return make_unique<BikeRecord>(*this);
	}
};

/** PersonRecord is the Concrete Prototype */
class PersonRecord : public Record
{
private:
	string m_personName;
	int m_age;

public:
	PersonRecord(string personName, int age) : m_personName(personName), m_age(age)
	{
	}

	void print() override
	{
		cout << "Person Record" << endl
			<< "Name : " << m_personName << endl
			<< "Age  : " << m_age << endl << endl;
	}

	unique_ptr<Record> clone() override
	{
		return make_unique<PersonRecord>(*this);
	}
};

/** Opaque record type, avoids exposing concrete implementations */
enum RecordType
{
	CAR,
	BIKE,
	PERSON
};

/** RecordFactory is the client */
class RecordFactory
{
private:
	unordered_map<RecordType, unique_ptr<Record>, hash<int> > m_records;

public:
	RecordFactory()
	{
		m_records[CAR]    = make_unique<CarRecord>("Ferrari", 5050);
		m_records[BIKE]   = make_unique<BikeRecord>("Yamaha", 2525);
		m_records[PERSON] = make_unique<PersonRecord>("Tom", 25);
	}

	unique_ptr<Record> createRecord(RecordType recordType)
	{
		return m_records[recordType]->clone();
	}
};

int main()
{
	RecordFactory recordFactory;

	auto record = recordFactory.createRecord(CAR);
	record->print();

	record = recordFactory.createRecord(BIKE);
	record->print();

	record = recordFactory.createRecord(PERSON);
	record->print();
}

Another example:

To implement the pattern, declare an abstract base class that specifies a pure virtual clone() member function. Any class that needs a "polymorphic constructor" capability derives itself from the abstract base class, and implements the clone() operation.

The client, instead of writing code that invokes the new operator on a hard-wired class name, calls the clone() member function on the prototype, calls a factory member function with a parameter designating the particular concrete derived class desired, or invokes the clone() member function through some mechanism provided by another design pattern.

 class CPrototypeMonster
 {
 protected:            
     CString           _name;
 public:
     CPrototypeMonster();
     CPrototypeMonster( const CPrototypeMonster& copy );
     virtual ~CPrototypeMonster();

     virtual CPrototypeMonster*    Clone() const=0; // This forces every derived class to provide an overload for this function.
     void        Name( CString name );
     CString    Name() const;
 };

 class CGreenMonster : public CPrototypeMonster
 {
 protected: 
     int         _numberOfArms;
     double      _slimeAvailable;
 public:
     CGreenMonster();
     CGreenMonster( const CGreenMonster& copy );
     ~CGreenMonster();

     virtual CPrototypeMonster*    Clone() const;
     void  NumberOfArms( int numberOfArms );
     void  SlimeAvailable( double slimeAvailable );

     int         NumberOfArms() const;
     double      SlimeAvailable() const;
 };

 class CPurpleMonster : public CPrototypeMonster
 {
 protected:
     int         _intensityOfBadBreath;
     double      _lengthOfWhiplikeAntenna;
 public:
     CPurpleMonster();
     CPurpleMonster( const CPurpleMonster& copy );
     ~CPurpleMonster();

     virtual CPrototypeMonster*    Clone() const;

     void  IntensityOfBadBreath( int intensityOfBadBreath );
     void  LengthOfWhiplikeAntenna( double lengthOfWhiplikeAntenna );

     int       IntensityOfBadBreath() const;
     double    LengthOfWhiplikeAntenna() const;
 };

 class CBellyMonster : public CPrototypeMonster
 {
 protected:
     double      _roomAvailableInBelly;
 public:
     CBellyMonster();
     CBellyMonster( const CBellyMonster& copy );
     ~CBellyMonster();

     virtual CPrototypeMonster*    Clone() const;

     void       RoomAvailableInBelly( double roomAvailableInBelly );
     double     RoomAvailableInBelly() const;
 };

 CPrototypeMonster* CGreenMonster::Clone() const
 {
     return new CGreenMonster(*this);
 }

 CPrototypeMonster* CPurpleMonster::Clone() const
 {
     return new CPurpleMonster(*this);
 }

 CPrototypeMonster* CBellyMonster::Clone() const
 {
     return new CBellyMonster(*this);
 }

A client of one of the concrete monster classes only needs a reference (pointer) to a 
CPrototypeMonster class object to be able to call the ‘Clone’ function and create copies of that object. The function below demonstrates this concept:

 void DoSomeStuffWithAMonster( const CPrototypeMonster* originalMonster )
 {
     CPrototypeMonster* newMonster = originalMonster->Clone();
     ASSERT( newMonster );

     newMonster->Name("MyOwnMonster");
     // Add code doing all sorts of cool stuff with the monster.
     delete newMonster;
 }

Now originalMonster can be passed as a pointer to CGreenMonster, CPurpleMonster or CBellyMonster.

 Singleton 
The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance. It is named after the singleton set, which is defined to be a set containing one element. This is useful when exactly one object is needed to coordinate actions across the system. 

Check list 
 Define a private static attribute in the "single instance" class.
 Define a public static accessor function in the class.
 Do "lazy initialization" (creation on first use) in the accessor function.
 Define all constructors to be protected or private.
 Clients may only use the accessor function to manipulate the Singleton.

Let's take a look at how a Singleton differs from other variable types.

Like a global variable, the Singleton exists outside of the scope of any functions. Traditional implementation uses a static member function of the Singleton class, which will create a single instance of the Singleton class on the first call, and forever return that instance. The following code example illustrates the elements of a C++ singleton class, that simply stores a single string.

 class StringSingleton
 {
 public:
     // Some accessor functions for the class, itself
     std::string GetString() const 
     {return mString;}
     void SetString(const std::string &newStr)
     {mString = newStr;}

     // The magic function, which allows access to the class from anywhere
     // To get the value of the instance of the class, call:
     //     StringSingleton::Instance().GetString();
     static StringSingleton &Instance()
     {
         // This line only runs once, thus creating the only instance in existence
         static StringSingleton *instance = new StringSingleton;
         // dereferencing the variable here, saves the caller from having to use 
         // the arrow operator, and removes temptation to try and delete the 
         // returned instance.
         return *instance; // always returns the same instance
     }

 private: 
     // We need to make some given functions private to finish the definition of the singleton
     StringSingleton(){} // default constructor available only to members or friends of this class

     // Note that the next two functions are not given bodies, thus any attempt 
     // to call them implicitly will return as compiler errors. This prevents 
     // accidental copying of the only instance of the class.
     StringSingleton(const StringSingleton &old); // disallow copy constructor
     const StringSingleton &operator=(const StringSingleton &old); //disallow assignment operator

     // Note that although this should be allowed, 
     // some compilers may not implement private destructors
     // This prevents others from deleting our one single instance, which was otherwise created on the heap
     ~StringSingleton(){} 
 private: // private data for an instance of this class
     std::string mString;
 };

Variations of Singletons:

Applications of Singleton Class:

One common use of the singleton design pattern is for application configurations. Configurations may need to be accessible globally, and future expansions to the application configurations may be needed. The subset C's closest alternative would be to create a single global struct. This had the lack of clarity as to where this object was instantiated, as well as not guaranteeing the existence of the object. 

Take, for example, the situation of another developer using your singleton inside the constructor of their object. Then, yet another developer decides to create an instance of the second class in the global scope. If you had simply used a global variable, the order of linking would then matter. Since your global will be accessed, possibly before main begins executing, there is no definition as to whether the global is initialized, or the constructor of the second class is called first. This behavior can then change with slight modifications to other areas of code, which would change order of global code execution. Such an error can be very hard to debug. But, with use of the singleton, the first time the object is accessed, the object will also be created. You now have an object which will always exist, in relation to being used, and will never exist if never used.

A second common use of this class is in updating old code to work in a new architecture. Since developers may have used globals liberally, moving them into a single class and making it a singleton, can be an intermediary step to bring the program inline to stronger object oriented structure.

Another example:

#include <iostream>
using namespace std;

/* Place holder for thread synchronization mutex */
class Mutex
{   /* placeholder for code to create, use, and free a mutex */
};

/* Place holder for thread synchronization lock */
class Lock
{   public:
        Lock(Mutex& m) : mutex(m) { /* placeholder code to acquire the mutex */ }
        ~Lock() { /* placeholder code to release the mutex */ }
    private:
        Mutex & mutex;
};

class Singleton
{   public:
        static Singleton* GetInstance();
        int a;
        ~Singleton() { cout << "In Destructor" << endl; }

    private:
        Singleton(int _a) : a(_a) { cout << "In Constructor" << endl; }

        static Mutex mutex;

        // Not defined, to prevent copying
        Singleton(const Singleton& );
        Singleton& operator =(const Singleton& other);
};

Mutex Singleton::mutex;

Singleton* Singleton::GetInstance()
{
    Lock lock(mutex);

    cout << "Get Instance" << endl;

    // Initialized during first access
    static Singleton inst(1);

    return &inst;
}

int main()
{
    Singleton* singleton = Singleton::GetInstance();
    cout << "The value of the singleton: " << singleton->a << endl;
    return 0;
}

 Structural Patterns 

 1. Adapter 
Convert the interface of a class into another interface that clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.

#include <iostream>

class Muslim {  // Abstract Target
        public:
	        virtual ~Muslim() = default;
	        virtual void performsMuslimRitual() const = 0;
};

class MuslimFemale : public Muslim {  // Concrete Target
        public:
	        virtual void performsMuslimRitual() const override {std::cout << "Muslim girl performs Muslim ritual." << std::endl;}
};

class Hindu {  // Abstract Adaptee
        public:
	        virtual ~Hindu() = default;
	        virtual void performsHinduRitual() const = 0;
};

class HinduFemale : public Hindu {  // Concrete Adaptee
        public:
	        virtual void performsHinduRitual() const override {std::cout << "Hindu girl performs Hindu ritual." << std::endl;}
};

class MuslimRitual {
        public:
	        void carryOutRitual (Muslim* muslim) {
		        std::cout << "On with the Muslim rituals!" << std::endl;
		        muslim->performsMuslimRitual();
	        }
};

class MuslimAdapter : public Muslim {  // Adapter
	private:
		Hindu* hindu;
	public:
		MuslimAdapter (Hindu* h) : hindu(h) {}
		virtual void performsMuslimRitual() const override {hindu->performsHinduRitual();}
};

int main() {  // Client code
	HinduFemale* hinduGirl = new HinduFemale;
	MuslimFemale* muslimGirl = new MuslimFemale;
	MuslimRitual muslimRitual;
//	muslimRitual.carryOutRitual (hinduGirl);  // Will not compile of course since the parameter must be of type Muslim*.
	MuslimAdapter* adaptedHindu = new MuslimAdapter (hinduGirl);  // hinduGirl has adapted to become a Muslim!

	muslimRitual.carryOutRitual (muslimGirl);
	muslimRitual.carryOutRitual (adaptedHindu);  // So now hinduGirl, in the form of adaptedHindu, participates in the muslimRitual!
                // Note that hinduGirl is carrying out her own type of ritual in muslimRitual though.

	delete adaptedHindu;  // adaptedHindu is not needed anymore
	delete hinduGirl; // hinduGirl is not needed anymore
	delete muslimGirl; // muslimGirl is not needed anymore, too
	return 0;
}

 2. Bridge 
The Bridge Pattern is used to separate out the interface from its implementation. Doing this gives the flexibility so that both can vary independently.

The following example will output:
API1.circle at 1:2 7.5
API2.circle at 5:7 27.5

#include <iostream>

using namespace std;

/* Implementor*/
class DrawingAPI {
  public:
   virtual void drawCircle(double x, double y, double radius) = 0;
   virtual ~DrawingAPI() {}
};

/* Concrete ImplementorA*/
class DrawingAPI1 : public DrawingAPI {
  public:
   void drawCircle(double x, double y, double radius) {
      cout << "API1.circle at " << x << ':' << y << ' ' << radius << endl;
   }
};

/* Concrete ImplementorB*/
class DrawingAPI2 : public DrawingAPI {
public:
   void drawCircle(double x, double y, double radius) {
      cout << "API2.circle at " << x << ':' << y << ' ' <<  radius << endl;
   }
};

/* Abstraction*/
class Shape {
  public:
   virtual ~Shape() {}
   virtual void draw() = 0;
   virtual void resizeByPercentage(double pct) = 0;
};

/* Refined Abstraction*/
class CircleShape : public Shape {
  public:
   CircleShape(double x, double y,double radius, DrawingAPI *drawingAPI) :
	   m_x(x), m_y(y), m_radius(radius), m_drawingAPI(drawingAPI)
   {}
   void draw() {
      m_drawingAPI->drawCircle(m_x, m_y, m_radius);
   }
   void resizeByPercentage(double pct) {
      m_radius *= pct;
   }
  private:
   double m_x, m_y, m_radius;
   DrawingAPI *m_drawingAPI;
};

int main(void) {
   CircleShape circle1(1,2,3,new DrawingAPI1());
   CircleShape circle2(5,7,11,new DrawingAPI2());
   circle1.resizeByPercentage(2.5);
   circle2.resizeByPercentage(2.5);
   circle1.draw();
   circle2.draw();
   return 0;
}

 3. Composite 
Composite lets clients treat individual objects and compositions of objects uniformly. The Composite pattern can represent both the conditions. In this pattern, one can develop tree structures for representing part-whole hierarchies.

#include <vector>
#include <iostream> // std::cout
#include <memory> // std::auto_ptr
#include <algorithm> // std::for_each
using namespace std;

class Graphic
{
public:
  virtual void print() const = 0;
  virtual ~Graphic() {}
};

class Ellipse : public Graphic
{
public:
  void print() const {
    cout << "Ellipse \n";
  }
};

class CompositeGraphic : public Graphic
{
public:
  void print() const {
    // for each element in graphicList_, call the print member function
    for_each(graphicList_.begin(), graphicList_.end(), [](Graphic* a){a->print();});
  }

  void add(Graphic *aGraphic) {
    graphicList_.push_back(aGraphic);
  }

private:
  vector<Graphic*>  graphicList_;
};

int main()
{
  // Initialize four ellipses
  const auto_ptr<Ellipse> ellipse1(new Ellipse());
  const auto_ptr<Ellipse> ellipse2(new Ellipse());
  const auto_ptr<Ellipse> ellipse3(new Ellipse());
  const auto_ptr<Ellipse> ellipse4(new Ellipse());

  // Initialize three composite graphics
  const auto_ptr<CompositeGraphic> graphic(new CompositeGraphic());
  const auto_ptr<CompositeGraphic> graphic1(new CompositeGraphic());
  const auto_ptr<CompositeGraphic> graphic2(new CompositeGraphic());

  // Composes the graphics
  graphic1->add(ellipse1.get());
  graphic1->add(ellipse2.get());
  graphic1->add(ellipse3.get());

  graphic2->add(ellipse4.get());

  graphic->add(graphic1.get());
  graphic->add(graphic2.get());

  // Prints the complete graphic (four times the string "Ellipse")
  graphic->print();
  return 0;
}

 4. Decorator 
The decorator pattern helps to attach additional behavior or responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality. This is also called “Wrapper”. If your application does some kind of filtering, then Decorator might be good pattern to consider for the job.

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

class Car //Our Abstract base class
{
        protected:
                string _str;
        public:
                Car()
                {
                        _str = "Unknown Car";
                }

                virtual string getDescription()
                {       
                        return _str;
                }

                virtual double getCost() = 0;

                virtual ~Car()
                {
                        cout << "~Car()\n";
                }
};

class OptionsDecorator : public Car //Decorator Base class
{
        public:
                virtual string getDescription() = 0;

                virtual ~OptionsDecorator()
                {
                        cout<<"~OptionsDecorator()\n";
                }
};

class CarModel1 : public Car
{       
        public:
                CarModel1()
                {
                        _str = "CarModel1";
                }
                virtual double getCost()
                {
                        return 31000.23;
                }

                ~CarModel1()
                {
                        cout<<"~CarModel1()\n";
                }
};

class Navigation: public OptionsDecorator
{
                Car *_b;
        public:
                Navigation(Car *b)
                {
                        _b = b;
                }
                string getDescription()
                {
                        return _b->getDescription() + ", Navigation";
                }

                double getCost()
                {
                        return 300.56 + _b->getCost();
                }
                ~Navigation()
                {
                        cout << "~Navigation()\n";
                        delete _b;
                }
};

class PremiumSoundSystem: public OptionsDecorator
{
                Car *_b;
        public:
                PremiumSoundSystem(Car *b)
                {
                        _b = b;
                }
                string getDescription()
                {
                        return _b->getDescription() + ", PremiumSoundSystem";
                }

                double getCost()
                {
                        return 0.30 + _b->getCost();
                }
                ~PremiumSoundSystem()
                {
                        cout << "~PremiumSoundSystem()\n";
                        delete _b;
                }
};

class ManualTransmission: public OptionsDecorator
{
                Car *_b;
        public:
                ManualTransmission(Car *b)
                {
                        _b = b;
                }
                string getDescription()
                {
		        return _b->getDescription()+ ", ManualTransmission";
                }

                double getCost()
                {
                        return 0.30 + _b->getCost();
                }
                ~ManualTransmission()
                {
                        cout << "~ManualTransmission()\n";
                        delete _b;
                }
};

int main()
{
        //Create our Car that we want to buy
        Car *b = new CarModel1();

        cout << "Base model of " << b->getDescription() << " costs $" << b->getCost() << "\n";  

        //Who wants base model let's add some more features

        b = new Navigation(b);
        cout << b->getDescription() << " will cost you $" << b->getCost() << "\n";
        b = new PremiumSoundSystem(b);
        b = new ManualTransmission(b);
        cout << b->getDescription() << " will cost you $" << b->getCost() << "\n";

        // WARNING! Here we leak the CarModel1, Navigation and PremiumSoundSystem objects!
        // Either we delete them explicitly or rewrite the Decorators to take 
        // ownership and delete their Cars when destroyed.
        delete b;  

        return 0;
}

The output of the program above is:

Base model of CarModel1 costs $31000.2
CarModel1, Navigation will cost you $31300.8
CarModel1, Navigation, PremiumSoundSystem, ManualTransmission will cost you $31301.4
~ManualTransmission
~PremiumSoundSystem() 
~Navigation()
~CarModel1
~Car() 
~OptionsDecorator()
~Car() 
~OptionsDecorator()
~Car() 
~OptionsDecorator()
~Car()

Another example:

#include <iostream>
#include <string>
#include <memory>

class Interface {
	public:
		virtual ~Interface() { }
		virtual void write (std::string&) = 0;
};

class Core : public Interface {
	public:
	   	~Core() {std::cout << "Core destructor called.\n";}
	   	virtual void write (std::string& text) override {};  // Do nothing.
};

class Decorator : public Interface {
	private:
	   	std::unique_ptr<Interface> interface;
	public:
	   	Decorator (std::unique_ptr<Interface> c) {interface = std::move(c);}
	   	virtual void write (std::string& text) override {interface->write(text);}
};

class MessengerWithSalutation : public Decorator {
	private:
	   	std::string salutation;
	public:
	   	MessengerWithSalutation (std::unique_ptr<Interface> c, const std::string& str) : Decorator(std::move(c)), salutation(str) {}
	   	~MessengerWithSalutation() {std::cout << "Messenger destructor called.\n";}
	   	virtual void write (std::string& text) override {
		   	text = salutation + "\n\n" + text;
		 	Decorator::write(text);
		}
};

class MessengerWithValediction : public Decorator {
	private:
	   	std::string valediction;
	public:
	   	MessengerWithValediction (std::unique_ptr<Interface> c, const std::string& str) : Decorator(std::move(c)), valediction(str) {}
	   	~MessengerWithValediction() {std::cout << "MessengerWithValediction destructor called.\n";}
	   	virtual void write (std::string& text) override {
		 	Decorator::write(text);
			text += "\n\n" + valediction;
		}
};

int main() {
	const std::string salutation = "Greetings,";
	const std::string valediction = "Sincerly, Andy";
	std::string message1 = "This message is not decorated.";
	std::string message2 = "This message is decorated with a salutation.";
	std::string message3 = "This message is decorated with a valediction.";
	std::string message4 = "This message is decorated with a salutation and a valediction.";

	std::unique_ptr<Interface> messenger1 = std::make_unique<Core>();
	std::unique_ptr<Interface> messenger2 = std::make_unique<MessengerWithSalutation> (std::make_unique<Core>(), salutation);
	std::unique_ptr<Interface> messenger3 = std::make_unique<MessengerWithValediction> (std::make_unique<Core>(), valediction);
	std::unique_ptr<Interface> messenger4 = std::make_unique<MessengerWithValediction> (std::make_unique<MessengerWithSalutation>
  						                  (std::make_unique<Core>(), salutation), valediction);

	messenger1->write(message1);
	std::cout << message1 << '\n';
	std::cout << "\n------------------------------\n\n";

	messenger2->write(message2);
	std::cout << message2 << '\n';
	std::cout << "\n------------------------------\n\n";

	messenger3->write(message3);
	std::cout << message3 << '\n';
	std::cout << "\n------------------------------\n\n";

	messenger4->write(message4);
	std::cout << message4 << '\n';
	std::cout << "\n------------------------------\n\n";
}

The output of the program above is:

This message is not decorated.

------------------------------

Greetings,

This message is decorated with a salutation.

------------------------------

This message is decorated with a valediction.

Sincerly, Andy

------------------------------

Greetings,

This message is decorated with a salutation and a valediction.

Sincerly, Andy

------------------------------

MessengerWithValediction destructor called.
Messenger destructor called.
Core destructor called.
MessengerWithValediction destructor called.
Core destructor called.
Messenger destructor called.
Core destructor called.
Core destructor called.

 5. Facade 
The Facade Pattern hides the complexities of the system by providing an interface to the client from where the client can access the system on an unified interface. Facade defines a higher-level interface that makes the subsystem easier to use. For instance making one class method perform a complex process by calling several other classes.

/*Facade is one of the easiest patterns I think... And this is very simple example. 

Imagine you set up a smart house where everything is on remote. So to turn the lights on you push lights on button - And same for TV,
AC, Alarm, Music, etc...

When you leave a house you would need to push a 100 buttons to make sure everything is off and are good to go which could be little 
annoying if you are lazy like me 
so I defined a Facade for leaving and coming back. (Facade functions represent buttons...) So when I come and leave I just make one 
call and it takes care of everything...
*/

#include <string>
#include <iostream>

using namespace std;

class Alarm
{
public:
	void alarmOn()
	{
		cout << "Alarm is on and house is secured"<<endl;
	}

	void alarmOff()
	{
		cout << "Alarm is off and you can go into the house"<<endl;
	}
};

class Ac
{
public:
	void acOn()
	{
		cout << "Ac is on"<<endl;
	}

	void acOff()
	{
		cout << "AC is off"<<endl;
	}
};

class Tv
{
public:
	void tvOn()
	{
		cout << "Tv is on"<<endl;
	}

	void tvOff()
	{
		cout << "TV is off"<<endl;
	}
};

class HouseFacade
{
	Alarm alarm;
	Ac ac;
	Tv tv;

public:
	HouseFacade(){}

	void goToWork()
	{
		ac.acOff();
		tv.tvOff();
		alarm.alarmOn();
	}

	void comeHome()
	{
		alarm.alarmOff();
		ac.acOn();
		tv.tvOn();
	}
};

int main()
{
	HouseFacade hf;

	//Rather than calling 100 different on and off functions thanks to facade I only have 2 functions...
	hf.goToWork();
	hf.comeHome();
}

The output of the program above is:

AC is off
TV is off
Alarm is on and house is secured
Alarm is off and you can go into the house
Ac is on
Tv is on

 6. Flyweight 

The pattern for saving memory (basically) by sharing properties of objects. Imagine a huge amount of similar objects which all have most of their properties the same.  It's natural to move these properties out of these objects to some external data structure and provide each object with the link to that data structure.

#include <iostream>
#include <string>
#include <vector>

#define NUMBER_OF_SAME_TYPE_CHARS 3;

/* Actual flyweight objects class (declaration) */
class FlyweightCharacter;

/*
	FlyweightCharacterAbstractBuilder is a class holding the properties which are shared by
	many objects. So instead of keeping these properties in those objects we keep them externally, making
	objects flyweight. See more details in the comments of main function.
*/
class FlyweightCharacterAbstractBuilder {
	FlyweightCharacterAbstractBuilder() {}
	~FlyweightCharacterAbstractBuilder() {}
public:
	static std::vector<float> fontSizes; // lets imagine that sizes be may of floating point type
	static std::vector<std::string> fontNames; // font name may be of variable length (lets take 6 bytes is average)

	static void setFontsAndNames();
	static FlyweightCharacter createFlyweightCharacter(unsigned short fontSizeIndex,
		unsigned short fontNameIndex,
		unsigned short positionInStream);
};

std::vector<float> FlyweightCharacterAbstractBuilder::fontSizes(3);
std::vector<std::string> FlyweightCharacterAbstractBuilder::fontNames(3);
void FlyweightCharacterAbstractBuilder::setFontsAndNames() {
	fontSizes[0] = 1.0;
	fontSizes[1] = 1.5;
	fontSizes[2] = 2.0;

	fontNames[0] = "first_font";
	fontNames[1] = "second_font";
	fontNames[2] = "third_font";
}

class FlyweightCharacter {
	unsigned short fontSizeIndex; // index instead of actual font size
	unsigned short fontNameIndex; // index instead of font name

	unsigned positionInStream;

public:

	FlyweightCharacter(unsigned short fontSizeIndex, unsigned short fontNameIndex, unsigned short positionInStream):
		fontSizeIndex(fontSizeIndex), fontNameIndex(fontNameIndex), positionInStream(positionInStream) {}
	void print() {
		std::cout << "Font Size: " << FlyweightCharacterAbstractBuilder::fontSizes[fontSizeIndex]
			<< ", font Name: " << FlyweightCharacterAbstractBuilder::fontNames[fontNameIndex]
			<< ", character stream position: " << positionInStream << std::endl;
	}
	~FlyweightCharacter() {}
};

FlyweightCharacter FlyweightCharacterAbstractBuilder::createFlyweightCharacter(unsigned short fontSizeIndex, unsigned short fontNameIndex, unsigned short positionInStream) {
	FlyweightCharacter fc(fontSizeIndex, fontNameIndex, positionInStream);

	return fc;
}

int main(int argc, char** argv) {
	std::vector<FlyweightCharacter> chars;

	FlyweightCharacterAbstractBuilder::setFontsAndNames();
	unsigned short limit = NUMBER_OF_SAME_TYPE_CHARS;

	for (unsigned short i = 0; i < limit; i++) {
		chars.push_back(FlyweightCharacterAbstractBuilder::createFlyweightCharacter(0, 0, i));
		chars.push_back(FlyweightCharacterAbstractBuilder::createFlyweightCharacter(1, 1, i + 1 * limit));
		chars.push_back(FlyweightCharacterAbstractBuilder::createFlyweightCharacter(2, 2, i + 2 * limit));
	}
	/*
		Each char stores links to it's fontName and fontSize so what we get is:

		each object instead of allocating 6 bytes (convention above) for string
		and 4 bytes for float allocates 2 bytes for fontNameIndex and fontSizeIndex.

		That means for each char we save 6 + 4 - 2 - 2 = 6 bytes.
		Now imagine we have NUMBER_OF_SAME_TYPE_CHARS = 1000 i.e. with our code
		we will have 3 groups of chars whith 1000 chars in each group which will save us

		3 * 1000 * 6 - (3 * 6 + 3 * 4) = 17970 saved bytes.

		3 * 6 + 3 * 4 is a number of bytes allocated by FlyweightCharacterAbstractBuilder.

		So the idea of the pattern is to move properties shared by many objects to some
		external container. The objects in that case don't store the data themselves they
		store only links to the data which saves memory and make the objects lighter.
		The data size of properties stored externally may be significant which will save REALLY
		huge ammount of memory and will make each object super light in comparisson to it's counterpart.
		That's where the name of the pattern comes from: flyweight (i.e. very light).
	*/
	for (unsigned short i = 0; i < chars.size(); i++) {
		chars[i].print();
	}

	std::cin.get(); return 0;
}

 7. Proxy 
The Proxy Pattern will provide an object a surrogate or placeholder for another object to control access to it.  It is used when you need to represent a complex object with a simpler one. If creation of an object is expensive, it can be postponed until the very need arises and meanwhile a simpler object can serve as a placeholder. This placeholder object is called the “Proxy” for the complex object.

 Curiously Recurring Template 
This technique is known more widely as a mixin. Mixins are described in the literature to be a powerful tool for expressing abstractions^{[citation needed]}.

 Interface-based Programming (IBP) 
Interface-based programming is closely related with Modular Programming and Object-Oriented Programming, it defines the application as a collection of inter-coupled modules (interconnected and which plug into each other via interface). Modules can be unplugged, replaced, or upgraded, without the need of compromising the contents of other modules. 

The total system complexity is greatly reduced. Interface Based Programming adds more to  modular Programming in that it insists that Interfaces are to be added to these modules. The entire system is thus viewed as Components and the interfaces that helps them to co-act.

Interface-based Programming increases the modularity of the application and hence its maintainability at a later development cycles, especially when each module must be developed by different teams. It is a well-known methodology that has been around for a long time and it is a core technology behind frameworks such as CORBA.

This is particularly convenient when third parties develop additional components for the established system. They just have to develop components that satisfy the interface specified by the parent application vendor. 

Thus the publisher of the interfaces assures that he will not change the interface and the subscriber agrees to implement the interface as whole without any deviation.
An interface is therefore said to be a Contractual agreement and the programming paradigm based on this is termed as "interface based programming".

 Behavioral Patterns 
 Chain of Responsibility 
Chain of Responsibility pattern has the intent to avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chains the receiving objects and passes the requests along the chain until an object handles it.

#include <iostream>

using namespace std;

class Handler {
    protected:
        Handler *next;

    public:
        Handler() { 
            next = NULL; 
        }

        virtual ~Handler() { }

        virtual void request(int value) = 0;

        void setNextHandler(Handler *nextInLine) {
            next = nextInLine;
        }
};

class SpecialHandler : public Handler {
    private:
        int myLimit;
        int myId;

    public:
        SpecialHandler(int limit, int id) {
            myLimit = limit;
            myId = id;
        }

        ~SpecialHandler() { }

        void request(int value) {
            if(value < myLimit) {
                cout << "Handler " << myId << " handled the request with a limit of " << myLimit << endl;
            } else if(next != NULL) {
                next->request(value);
            } else {
                cout << "Sorry, I am the last handler (" << myId << ") and I can't handle the request." << endl;
            }
        }
};

int main () {
    Handler *h1 = new SpecialHandler(10, 1);
    Handler *h2 = new SpecialHandler(20, 2);
    Handler *h3 = new SpecialHandler(30, 3);

    h1->setNextHandler(h2);
    h2->setNextHandler(h3);

    h1->request(18);

    h1->request(40);

    delete h1;
    delete h2;
    delete h3;

    return 0;
}

 Command 
Command pattern is an Object behavioral pattern that decouples sender and receiver by encapsulating a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undo-able operations. It can also be thought as an object oriented equivalent of call back method. 

Call Back:
It is a function that is registered to be called at later point of time based on user actions.

#include <iostream>

using namespace std;

/*the Command interface*/
class Command 
{
public:
	virtual void execute()=0;
};

/*Receiver class*/
class Light {

public:
	Light() {  }

	void turnOn() 
	{
		cout << "The light is on" << endl;
	}

	void turnOff() 
	{
		cout << "The light is off" << endl;
	}
};

/*the Command for turning on the light*/
class FlipUpCommand: public Command 
{
public:

	FlipUpCommand(Light& light):theLight(light)
	{

	}

	virtual void execute()
	{
		theLight.turnOn();
	}

private:
	Light& theLight;
};

/*the Command for turning off the light*/
class FlipDownCommand: public Command
{
public:   
	FlipDownCommand(Light& light) :theLight(light)
	{

	}
	virtual void execute() 
	{
		theLight.turnOff();
	}
private:
	Light& theLight;
};

class Switch {
public:
	Switch(Command& flipUpCmd, Command& flipDownCmd)
	:flipUpCommand(flipUpCmd),flipDownCommand(flipDownCmd)
	{

	}

	void flipUp()
	{
		flipUpCommand.execute();
	}

	void flipDown()
	{
		flipDownCommand.execute();
	}

private:
	Command& flipUpCommand;
	Command& flipDownCommand;
};

/*The test class or client*/
int main() 
{
	Light lamp;
	FlipUpCommand switchUp(lamp);
	FlipDownCommand switchDown(lamp);

	Switch s(switchUp, switchDown);
	s.flipUp();
	s.flipDown();
}

 Interpreter 
Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.

#include <iostream>
#include <string>
#include <map>
#include <list>

namespace wikibooks_design_patterns
{

//	based on the Java sample around here

typedef std::string String;
struct Expression;
typedef std::map<String,Expression*> Map;
typedef std::list<Expression*> Stack;

struct Expression {
    virtual int interpret(Map variables) = 0;
	virtual ~Expression() {}
};

class Number : public Expression {
private:
	int number;
public: 
	Number(int number)       { this->number = number; }
	int interpret(Map variables)  { return number; }
};

class Plus : public Expression {
    Expression* leftOperand;
    Expression* rightOperand;
public: 

    Plus(Expression* left, Expression* right) { 
        leftOperand = left; 
        rightOperand = right;
    }
    ~Plus(){ 
	delete leftOperand;
	delete rightOperand;
    }

    int interpret(Map variables)  { 
        return leftOperand->interpret(variables) + rightOperand->interpret(variables);
    }
};

class Minus : public Expression {
    Expression* leftOperand;
    Expression* rightOperand;
public: 
    Minus(Expression* left, Expression* right) { 
        leftOperand = left; 
        rightOperand = right;
    }
    ~Minus(){ 
	delete leftOperand;
	delete rightOperand;
    }

    int interpret(Map variables)  { 
        return leftOperand->interpret(variables) - rightOperand->interpret(variables);
    }
};

class Variable : public Expression {
    String name;
public: 
	Variable(String name)       { this->name = name; }
    int interpret(Map variables)  { 
        if(variables.end() == variables.find(name)) return 0;
        return variables[name]->interpret(variables); 
    }
};

//	While the interpreter pattern does not address parsing, a parser is provided for completeness.

class Evaluator : public Expression {
    Expression* syntaxTree;

public:
	Evaluator(String expression){
        Stack expressionStack;

	size_t last = 0;
	for (size_t next = 0; String::npos != last; last = (String::npos == next) ? next : (1+next)) {
	    next = expression.find(' ', last);
	    String token( expression.substr(last, (String::npos == next) ? (expression.length()-last) : (next-last)));

            if  (token == "+") {
		Expression* right = expressionStack.back(); expressionStack.pop_back();
                Expression* left = expressionStack.back(); expressionStack.pop_back();
                Expression* subExpression = new Plus(right, left);
                expressionStack.push_back( subExpression );
            }
            else if (token == "-") {
                // it's necessary remove first the right operand from the stack
                Expression* right = expressionStack.back(); expressionStack.pop_back();
                // ..and after the left one
                Expression* left = expressionStack.back(); expressionStack.pop_back();
                Expression* subExpression = new Minus(left, right);
                expressionStack.push_back( subExpression );
            }
            else                        
                expressionStack.push_back( new Variable(token) );
        }

        syntaxTree = expressionStack.back(); expressionStack.pop_back();
    }

     ~Evaluator() {
	delete syntaxTree;
     }

    int interpret(Map context) {
        return syntaxTree->interpret(context);
    }
};

}

void main()
{
	using namespace wikibooks_design_patterns;

	Evaluator sentence("w x z - +");

	static
	const int sequences[][3] = {
		{5, 10, 42}, {1, 3, 2}, {7, 9, -5},
	};
	for (size_t i = 0; sizeof(sequences)/sizeof(sequences[0]) > i; ++i) {
		Map variables;
		variables["w"] = new Number(sequences[i][0]);
		variables["x"] = new Number(sequences[i][1]);
		variables["z"] = new Number(sequences[i][2]);
		int result = sentence.interpret(variables);
		for (Map::iterator it = variables.begin(); variables.end() != it; ++it) delete it->second;

		std::cout<<"Interpreter result: "<<result<<std::endl;
	}
}

 Iterator 
The 'iterator' design pattern is used liberally within the STL for traversal of various containers. The full understanding of this will liberate a developer to create highly reusable and easily understandable^{[citation needed]} data containers.

The basic idea of the iterator is that it permits the traversal of a container (like a pointer moving across an array). However, to get to the next element of a container, you need not know anything about how the container is constructed. This is the iterators job. By simply using the member functions provided by the iterator, you can move, in the intended order of the container, from the first element to the last element.

Let us start by considering a traditional single dimensional array with a pointer moving from the start to the end. This example assumes knowledge of pointer arithmetic.
Note that the use of "it" or "itr," henceforth, is a short version of "iterator."

 const int ARRAY_LEN = 42;
 int *myArray = new int[ARRAY_LEN];
 // Set the iterator to point to the first memory location of the array
 int *arrayItr = myArray;
 // Move through each element of the array, setting it equal to its position in the array
 for(int i = 0; i < ARRAY_LEN; ++i)
 {
    // set the value of the current location in the array
    *arrayItr = i;
    // by incrementing the pointer, we move it to the next position in the array.
    // This is easy for a contiguous memory container, since pointer arithmetic 
    // handles the traversal.
    ++arrayItr;
 }
 // Do not be messy, clean up after yourself
 delete[] myArray;

This code works very quickly for arrays, but how would we traverse a linked list, when the memory is not contiguous?
Consider the implementation of a rudimentary linked list as follows:

 class IteratorCannotMoveToNext{}; // Error class
 class MyIntLList
 {
 public:
     // The Node class represents a single element in the linked list. 
     // The node has a next node and a previous node, so that the user 
     // may move from one position to the next, or step back a single 
     // position. Notice that the traversal of a linked list is O(N), 
     // as is searching, since the list is not ordered.
     class Node
     {
     public:
         Node():mNextNode(0),mPrevNode(0),mValue(0){}
         Node *mNextNode;
         Node *mPrevNode;
         int mValue;
     };
     MyIntLList():mSize(0) 
     {}
     ~MyIntLList()
     {
         while(!Empty())
             pop_front();
     } // See expansion for further implementation;
     int Size() const {return mSize;}
     // Add this value to the end of the list
     void push_back(int value)
     {
         Node *newNode = new Node;
         newNode->mValue = value;
         newNode->mPrevNode = mTail;
         mTail->mNextNode = newNode;
         mTail = newNode;
         ++mSize;
     }
     // Remove the value from the beginning of the list
     void pop_front()
     {
         if(Empty())
             return;
         Node *tmpnode = mHead;
         mHead = mHead->mNextNode;
         delete tmpnode;
         --mSize;
     }
     bool Empty()
     {return mSize == 0;}

     // This is where the iterator definition will go, 
     // but lets finish the definition of the list, first

 private:
     Node *mHead;
     Node *mTail;
     int mSize;
 };

This linked list has non-contiguous memory, and is therefore not a candidate for pointer arithmetic. And we do not want to expose the internals of the list to other developers, forcing them to learn them, and keeping us from changing it.

This is where the iterator comes in. The common interface makes learning the usage of the container easier, and hides the traversal logic from other developers.

Let us examine the code for the iterator, itself.

     /*
      *  The iterator class knows the internals of the linked list, so that it 
      *  may move from one element to the next. In this implementation, I have 
      *  chosen the classic traversal method of overloading the increment 
      *  operators. More thorough implementations of a bi-directional linked 
      *  list would include decrement operators so that the iterator may move 
      *  in the opposite direction.
      */
     class Iterator
     {
     public:
         Iterator(Node *position):mCurrNode(position){}
         // Prefix increment
         const Iterator &operator++()
         {
             if(mCurrNode == 0 || mCurrNode->mNextNode == 0)
                 throw IteratorCannotMoveToNext();e
             mCurrNode = mCurrNode->mNextNode;
             return *this;
         }
         // Postfix increment
         Iterator operator++(int)
         {
             Iterator tempItr = *this;
             ++(*this);
             return tempItr;
         }
         // Dereferencing operator returns the current node, which should then 
         // be dereferenced for the int. TODO: Check syntax for overloading 
         // dereferencing operator
         Node * operator*()
         {return mCurrNode;}
         // TODO: implement arrow operator and clean up example usage following
     private:
         Node *mCurrNode;
     };
     // The following two functions make it possible to create 
     // iterators for an instance of this class.
     // First position for iterators should be the first element in the container.
     Iterator Begin(){return Iterator(mHead);}
     // Final position for iterators should be one past the last element in the container.
     Iterator End(){return Iterator(0);}

With this implementation, it is now possible, without knowledge of the size of the container or how its data is organized, to move through each element in order, manipulating or simply accessing the data. This is done through the accessors in the MyIntLList class, Begin() and End().

 // Create a list
 MyIntLList myList;
 // Add some items to the list
 for(int i = 0; i < 10; ++i)
     myList.push_back(i);
 // Move through the list, adding 42 to each item.
 for(MyIntLList::Iterator it = myList.Begin(); it != myList.End(); ++it)
     (*it)->mValue += 42;

The following program gives the implementation of an iterator design pattern with a generic template:

/************************************************************************/
/* Iterator.h                                                           */
/************************************************************************/
#ifndef MY_ITERATOR_HEADER
#define MY_ITERATOR_HEADER

#include <iterator>
#include <vector>
#include <set>

//////////////////////////////////////////////////////////////////////////
template<class T, class U>
class Iterator
{
public:
	typedef typename std::vector<T>::iterator iter_type;
	Iterator(U *pData):m_pData(pData){
		m_it = m_pData->m_data.begin();
	}

	void first()
	{
		m_it = m_pData->m_data.begin();
	}

	void next()
	{
		m_it++;
	}

	bool isDone()
	{
		return (m_it == m_pData->m_data.end());
	}

	iter_type current()
	{
		return m_it;
	}
private:
	U *m_pData;
	iter_type m_it;
};

template<class T, class U, class A>
class setIterator
{
public:
	typedef typename std::set<T,U>::iterator iter_type;

	setIterator(A *pData):m_pData(pData)
	{
		m_it = m_pData->m_data.begin();
	}

	void first()
	{
		m_it = m_pData->m_data.begin();
	}

	void next()
	{
		m_it++;
	}

	bool isDone()
	{
		return (m_it == m_pData->m_data.end());
	}

	iter_type current()
	{
		return m_it;
	}

private:
	A			*m_pData;		
	iter_type		m_it;
};
#endif

/************************************************************************/
/* Aggregate.h                                                          */
/************************************************************************/
#ifndef MY_DATACOLLECTION_HEADER
#define MY_DATACOLLECTION_HEADER
#include "Iterator.h"

template <class T>
class aggregate
{
	friend class Iterator<T, aggregate>;
public:
	void add(T a)
	{
		m_data.push_back(a);
	}

	Iterator<T, aggregate> *create_iterator()
	{
		return new Iterator<T, aggregate>(this);
	}

private:
	std::vector<T> m_data;
};
template <class T, class U>
class aggregateSet
{
	friend class setIterator<T, U, aggregateSet>;
public:
	void add(T a)
	{
		m_data.insert(a);
	}

	setIterator<T, U, aggregateSet> *create_iterator()
	{
		return new setIterator<T,U,aggregateSet>(this);
	}

	void Print()
	{
		copy(m_data.begin(), m_data.end(), std::ostream_iterator<T>(std::cout, "\n"));
	}

private:
	std::set<T,U> m_data;
};

#endif

/************************************************************************/
/* Iterator Test.cpp                                                    */
/************************************************************************/
#include <iostream>
#include <string>
#include "Aggregate.h"
using namespace std;

class Money
{
public:
	Money(int a = 0): m_data(a) {}

	void SetMoney(int a)
	{
		m_data = a;
	}

	int GetMoney()
	{
		return m_data;
	}

private:
	int m_data;
};

class Name
{
public:
	Name(string name): m_name(name) {}

	const string &GetName() const
	{
		return m_name;
	}

	friend ostream &operator<<(ostream& out, Name name)
	{
		out << name.GetName();
		return out;
	}

private:
	string m_name;
};

struct NameLess
{
	bool operator()(const Name &lhs, const Name &rhs) const
	{
		return (lhs.GetName() < rhs.GetName());
	}
};

int main()
{
	//sample 1
	cout << "________________Iterator with int______________________________________" << endl;
	aggregate<int> agg;

	for (int i = 0; i < 10; i++)
		agg.add(i);

	Iterator< int,aggregate<int> > *it = agg.create_iterator();
	for(it->first(); !it->isDone(); it->next())
		cout << *it->current() << endl;	

	//sample 2
	aggregate<Money> agg2;
	Money a(100), b(1000), c(10000);
	agg2.add(a);
	agg2.add(b);
	agg2.add(c);

	cout << "________________Iterator with Class Money______________________________" << endl;
	Iterator<Money, aggregate<Money> > *it2 = agg2.create_iterator();
	for (it2->first(); !it2->isDone(); it2->next())
		cout << it2->current()->GetMoney() << endl;

	//sample 3
	cout << "________________Set Iterator with Class Name______________________________" << endl;

	aggregateSet<Name, NameLess> aset;
	aset.add(Name("Qmt"));
	aset.add(Name("Bmt"));
	aset.add(Name("Cmt"));
	aset.add(Name("Amt"));

	setIterator<Name, NameLess, aggregateSet<Name, NameLess> > *it3 = aset.create_iterator();
	for (it3->first(); !it3->isDone(); it3->next())
		cout << (*it3->current()) << endl;
}

Console output:
________________Iterator with int______________________________________
0
1
2
3
4
5
6
7
8
9
________________Iterator with Class Money______________________________
100
1000
10000
________________Set Iterator with Class Name___________________________
Amt
Bmt
Cmt
Qmt

 Mediator 
Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from  referring to each other explicitly, and it lets you vary their interaction independently.

#include <iostream>
#include <string>
#include <list>

class MediatorInterface;

class ColleagueInterface {
		std::string name;
	public:
		ColleagueInterface (const std::string& newName) : name (newName) {}
		std::string getName() const {return name;}
		virtual void sendMessage (const MediatorInterface&, const std::string&) const = 0;
		virtual void receiveMessage (const ColleagueInterface*, const std::string&) const = 0;
};

class Colleague : public ColleagueInterface {
	public:
		using ColleagueInterface::ColleagueInterface;
		virtual void sendMessage (const MediatorInterface&, const std::string&) const override;
	private:
		virtual void receiveMessage (const ColleagueInterface*, const std::string&) const override;
};

class MediatorInterface {
    private:
		std::list<ColleagueInterface*> colleagueList;
    public:
    	const std::list<ColleagueInterface*>& getColleagueList() const {return colleagueList;}
		virtual void distributeMessage (const ColleagueInterface*, const std::string&) const = 0;
		virtual void registerColleague (ColleagueInterface* colleague) {colleagueList.emplace_back (colleague);}
};

class Mediator : public MediatorInterface {
    virtual void distributeMessage (const ColleagueInterface*, const std::string&) const override;
};

void Colleague::sendMessage (const MediatorInterface& mediator, const std::string& message) const {
	mediator.distributeMessage (this, message);
}

void Colleague::receiveMessage (const ColleagueInterface* sender, const std::string& message) const {
 	std::cout << getName() << " received the message from " << sender->getName() << ": " << message << std::endl;			
}

void Mediator::distributeMessage (const ColleagueInterface* sender, const std::string& message) const {
	for (const ColleagueInterface* x : getColleagueList())
		if (x != sender)  // Do not send the message back to the sender
			x->receiveMessage (sender, message);
}

int main() {
	Colleague *bob = new Colleague ("Bob"),  *sam = new Colleague ("Sam"),  *frank = new Colleague ("Frank"),  *tom = new Colleague ("Tom");
	Colleague* staff[] = {bob, sam, frank, tom};
	Mediator mediatorStaff, mediatorSamsBuddies;
	for (Colleague* x : staff)
		mediatorStaff.registerColleague(x);
	bob->sendMessage (mediatorStaff, "I'm quitting this job!");
	mediatorSamsBuddies.registerColleague (frank);  mediatorSamsBuddies.registerColleague (tom);  // Sam's buddies only
	sam->sendMessage (mediatorSamsBuddies, "Hooray!  He's gone!  Let's go for a drink, guys!");	
	return 0;
}

 Memento 
Without violating encapsulation the Memento Pattern will capture and externalize an object’s internal state so that the object can be restored to this state later. Though the Gang of Four uses friend as a way to implement this pattern it is not the best design^{[citation needed]}.  It can also be implemented using PIMPL (pointer to implementation or opaque pointer).  Best Use case is 'Undo-Redo' in an editor. 

The Originator (the object to be saved) creates a snap-shot of itself as a Memento object, and passes that reference to the Caretaker object.  The Caretaker object keeps the Memento until such a time as the Originator may want to revert to a previous state as recorded in the Memento object.

See memoize for an old-school example of this pattern.

#include <iostream>
#include <string>
#include <sstream>
#include <vector>

const std::string NAME = "Object";

template <typename T>
std::string toString (const T& t) {
	std::stringstream ss;
	ss << t;
	return ss.str();
}

class Memento;

class Object {
  	private:
    	    int value;
    	    std::string name;
    	    double decimal;  // and suppose there are loads of other data members
  	public:
	    Object (int newValue): value (newValue), name (NAME + toString (value)), decimal ((float)value / 100) {}
	    void doubleValue() {value = 2 * value;  name = NAME + toString (value);  decimal = (float)value / 100;}
	    void increaseByOne() {value++;  name = NAME + toString (value);  decimal = (float)value / 100;}
	    int getValue() const {return value;}
	    std::string getName() const {return name;}
	    double getDecimal() const {return decimal;}
	    Memento* createMemento() const;
	    void reinstateMemento (Memento* mem);
};

class Memento {
  	private:
 	    Object object;
  	public:
    	    Memento (const Object& obj):  object (obj) {}
    	    Object snapshot() const {return object;}  // want a snapshot of Object itself because of its many data members
};

Memento* Object::createMemento() const {
	return new Memento (*this);
}

void Object::reinstateMemento (Memento* mem) {
	*this = mem->snapshot();
}

class Command {
  	private:
	    typedef void (Object::*Action)();
	    Object* receiver;
	    Action action;
	    static std::vector<Command*> commandList;
	    static std::vector<Memento*> mementoList;
	    static int numCommands;
	    static int maxCommands;
  	public:
	    Command (Object *newReceiver, Action newAction): receiver (newReceiver), action (newAction) {}
	    virtual void execute() {
	    	if (mementoList.size() < numCommands + 1)
	    		mementoList.resize (numCommands + 1);
	        mementoList[numCommands] = receiver->createMemento();  // saves the last value
	    	if (commandList.size() < numCommands + 1)
	    		commandList.resize (numCommands + 1);
	        commandList[numCommands] = this;  // saves the last command
	        if (numCommands > maxCommands)
	          	maxCommands = numCommands;
	        numCommands++;
	        (receiver->*action)();
	    }
	    static void undo() {
	        if (numCommands == 0)
	        {
	            std::cout << "There is nothing to undo at this point." << std::endl;
	            return;
	        }
	        commandList[numCommands - 1]->receiver->reinstateMemento (mementoList[numCommands - 1]);
	        numCommands--;
	    }
	    void static redo() {
	        if (numCommands > maxCommands)
	        {
	            std::cout << "There is nothing to redo at this point." << std::endl;
	            return ;
	        }
	        Command* commandRedo = commandList[numCommands];
	        (commandRedo->receiver->*(commandRedo->action))();
	        numCommands++;
	    }
};

std::vector<Command*> Command::commandList;
std::vector<Memento*> Command::mementoList;
int Command::numCommands = 0;
int Command::maxCommands = 0;

int main()
{
	int i;
	std::cout << "Please enter an integer: ";
	std::cin >> i;
	Object *object = new Object(i);

	Command *commands[3];
	commands[1] = new Command(object, &Object::doubleValue);
	commands[2] = new Command(object, &Object::increaseByOne);

	std::cout << "0.Exit,  1.Double,  2.Increase by one,  3.Undo,  4.Redo: ";
	std::cin >> i;

	while (i != 0)
	{
		if (i == 3)
		  	Command::undo();
		else if (i == 4)
		  	Command::redo();
		else if (i > 0 && i <= 2)
		  	commands[i]->execute();
		else
		{
			std::cout << "Enter a proper choice: ";
			std::cin >> i;
			continue;
		}
		std::cout << "   " << object->getValue() << "  " << object->getName() << "  " << object->getDecimal() << std::endl;
		std::cout << "0.Exit,  1.Double,  2.Increase by one,  3.Undo,  4.Redo: ";
		std::cin >> i;
	}
}

 Observer 
The Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

 Problem 
 In one place or many places in the application we need to be aware about a system event or an application state change. We'd like to have a standard way of subscribing to listening for system events and a standard way of notifying the interested parties. The notification should be automated after an interested party subscribed to the system event or application state change. There also should be a way to unsubscribe.

 Forces 
 Observers and observables probably should be represented by objects. The observer objects will be notified by the observable objects.

 Solution 
  After subscribing the listening objects will be notified by a way of method call.

#include <list>
#include <algorithm>
#include <iostream>
using namespace std;

// The Abstract Observer
class ObserverBoardInterface
{
public:
    virtual void update(float a,float b,float c) = 0;
};

// Abstract Interface for Displays
class DisplayBoardInterface
{
public:
    virtual void show() = 0;
};

// The Abstract Subject
class WeatherDataInterface
{
public:
    virtual void registerOb(ObserverBoardInterface* ob) = 0;
    virtual void removeOb(ObserverBoardInterface* ob) = 0;
    virtual void notifyOb() = 0;
};

// The Concrete Subject
class ParaWeatherData: public WeatherDataInterface
{
public:
    void SensorDataChange(float a,float b,float c)
    {
        m_humidity = a;
        m_temperature = b;
        m_pressure = c;
        notifyOb();
    }

    void registerOb(ObserverBoardInterface* ob)
    {
        m_obs.push_back(ob);
    }

    void removeOb(ObserverBoardInterface* ob)
    {
        m_obs.remove(ob);
    }
protected:
    void notifyOb()
    {
        list<ObserverBoardInterface*>::iterator pos = m_obs.begin();
        while (pos != m_obs.end())
        {
            ((ObserverBoardInterface* )(*pos))->update(m_humidity,m_temperature,m_pressure);
            (dynamic_cast<DisplayBoardInterface*>(*pos))->show();
            ++pos;
        }
    }

private:
    float        m_humidity;
    float        m_temperature;
    float        m_pressure;
    list<ObserverBoardInterface* > m_obs;
};

// A Concrete Observer
class CurrentConditionBoard : public ObserverBoardInterface, public DisplayBoardInterface
{
public:
    CurrentConditionBoard(ParaWeatherData& a):m_data(a)
    {
        m_data.registerOb(this);
    }
    void show()
    {
        cout<<"_____CurrentConditionBoard_____"<<endl;
        cout<<"humidity: "<<m_h<<endl;
        cout<<"temperature: "<<m_t<<endl;
        cout<<"pressure: "<<m_p<<endl;
        cout<<"_______________________________"<<endl;
    }

    void update(float h, float t, float p)
    {
        m_h = h;
        m_t = t;
        m_p = p;
    }

private:
    float m_h;
    float m_t;
    float m_p;
    ParaWeatherData& m_data;
};

// A Concrete Observer
class StatisticBoard : public ObserverBoardInterface, public DisplayBoardInterface
{
public:
    StatisticBoard(ParaWeatherData& a):m_maxt(-1000),m_mint(1000),m_avet(0),m_count(0),m_data(a)
    {
        m_data.registerOb(this);
    }

    void show()
    {
        cout<<"________StatisticBoard_________"<<endl;
        cout<<"lowest  temperature: "<<m_mint<<endl;
        cout<<"highest temperature: "<<m_maxt<<endl;
        cout<<"average temperature: "<<m_avet<<endl;
        cout<<"_______________________________"<<endl;
    }

    void update(float h, float t, float p)
    {
        ++m_count;
        if (t>m_maxt)
        {
            m_maxt = t;
        }
        if (t<m_mint)
        {
            m_mint = t;
        }
        m_avet = (m_avet * (m_count-1) + t)/m_count;
    }

private:
    float m_maxt;
    float  m_mint;
    float m_avet;
    int m_count;
    ParaWeatherData& m_data;
};

int main(int argc, char *argv[])
{

    ParaWeatherData * wdata = new ParaWeatherData;
    CurrentConditionBoard* currentB = new CurrentConditionBoard(*wdata);
    StatisticBoard* statisticB = new StatisticBoard(*wdata);

    wdata->SensorDataChange(10.2, 28.2, 1001);
    wdata->SensorDataChange(12, 30.12, 1003);
    wdata->SensorDataChange(10.2, 26, 806);
    wdata->SensorDataChange(10.3, 35.9, 900);

    wdata->removeOb(currentB);

    wdata->SensorDataChange(100, 40, 1900);  

    delete statisticB;
    delete currentB;
    delete wdata;

    return 0;
}

 State 
The State Pattern allows an object to alter its behavior when its internal state changes. The object will appear as having changed its class.

#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>
#include <memory>

enum Input {DUCK_DOWN, STAND_UP, JUMP, DIVE};

class Fighter;
class StandingState;  class JumpingState;  class DivingState;

class FighterState {
	public:
		static std::shared_ptr<StandingState> standing;
		static std::shared_ptr<DivingState> diving;
		virtual ~FighterState() = default;
		virtual void handleInput (Fighter&, Input) = 0;
		virtual void update (Fighter&) = 0;
};

class DuckingState : public FighterState {
	private:
		int chargingTime;
		static const int FullRestTime = 5;
	public:
		DuckingState() : chargingTime(0) {}
		virtual void handleInput (Fighter&, Input) override;
		virtual void update (Fighter&) override;
};

class StandingState : public FighterState {
	public:
		virtual void handleInput (Fighter&, Input) override;
		virtual void update (Fighter&) override;
};

class JumpingState : public FighterState {
	private:
		int jumpingHeight;
	public:
		JumpingState() {jumpingHeight = std::rand() % 5 + 1;}
		virtual void handleInput (Fighter&, Input) override;
		virtual void update (Fighter&) override;
};

class DivingState : public FighterState {
	public:
		virtual void handleInput (Fighter&, Input) override;
		virtual void update (Fighter&) override;
};

std::shared_ptr<StandingState> FighterState::standing (new StandingState);
std::shared_ptr<DivingState> FighterState::diving (new DivingState);

class Fighter {
	private:
		std::string name;
		std::shared_ptr<FighterState> state;
		int fatigueLevel = std::rand() % 10;
	public:
		Fighter (const std::string& newName) : name (newName), state (FighterState::standing) {}
		std::string getName() const {return name;}
		int getFatigueLevel() const {return fatigueLevel;}
		virtual void handleInput (Input input) {state->handleInput (*this, input);}  // delegate input handling to 'state'.
		void changeState (std::shared_ptr<FighterState> newState) {state = newState;  updateWithNewState();}
		void standsUp() {std::cout << getName() << " stands up." << std::endl;}
		void ducksDown() {std::cout << getName() << " ducks down." << std::endl;}
		void jumps() {std::cout << getName() << " jumps into the air." << std::endl;}
		void dives() {std::cout << getName() << " makes a dive attack in the middle of the jump!" << std::endl;}
		void feelsStrong() {std::cout << getName() << " feels strong!" << std::endl;}
		void changeFatigueLevelBy (int change) {fatigueLevel += change;  std::cout << "fatigueLevel = " << fatigueLevel << std::endl;}
	private:
		virtual void updateWithNewState() {state->update(*this);}  // delegate updating to 'state'
};

void StandingState::handleInput (Fighter& fighter, Input input)  {
	switch (input) {
		case STAND_UP:  std::cout << fighter.getName() << " remains standing." << std::endl;  return;
		case DUCK_DOWN:  fighter.changeState (std::shared_ptr<DuckingState> (new DuckingState));  return fighter.ducksDown();
		case JUMP:  fighter.jumps();  return fighter.changeState (std::shared_ptr<JumpingState> (new JumpingState));
		default:  std::cout << "One cannot do that while standing.  " << fighter.getName() << " remains standing by default." << std::endl;
	}
}

void StandingState::update (Fighter& fighter) {
	if (fighter.getFatigueLevel() > 0)
		fighter.changeFatigueLevelBy(-1);
}

void DuckingState::handleInput (Fighter& fighter, Input input)  {
	switch (input) {
		case STAND_UP:  fighter.changeState (FighterState::standing);  return fighter.standsUp();
		case DUCK_DOWN:
			std::cout << fighter.getName() << " remains in ducking position, ";
			if (chargingTime < FullRestTime) std::cout << "recovering in the meantime." << std::endl;
			else std::cout << "fully recovered." << std::endl;
			return update (fighter);
		default:
			std::cout << "One cannot do that while ducking.  " << fighter.getName() << " remains in ducking position by default." << std::endl;
			update (fighter);
	}
}

void DuckingState::update (Fighter& fighter) {
	chargingTime++;
	std::cout << "Charging time = " << chargingTime << "." << std::endl;
	if (fighter.getFatigueLevel() > 0)
		fighter.changeFatigueLevelBy(-1);
	if (chargingTime >= FullRestTime && fighter.getFatigueLevel() <= 3)
		fighter.feelsStrong();
}

void JumpingState::handleInput (Fighter& fighter, Input input)  {
	switch (input) {
		case DIVE:  fighter.changeState (FighterState::diving);  return fighter.dives();
		default:
			std::cout << "One cannot do that in the middle of a jump.  " << fighter.getName() << " lands from his jump and is now standing again." << std::endl;
			fighter.changeState (FighterState::standing);
	}
}

void JumpingState::update (Fighter& fighter) {
	std::cout << fighter.getName() << " has jumped " << jumpingHeight << " feet into the air." << std::endl;
	if (jumpingHeight >= 3)
		fighter.changeFatigueLevelBy(1);
}

void DivingState::handleInput (Fighter& fighter, Input)  {
	std::cout << "Regardless of what the user input is, " << fighter.getName() << " lands from his dive and is now standing again." << std::endl;
	fighter.changeState (FighterState::standing);
}

void DivingState::update (Fighter& fighter) {
	fighter.changeFatigueLevelBy(2);
}

int main() {
	std::srand(std::time(nullptr));
	Fighter rex ("Rex the Fighter"), borg ("Borg the Fighter");
	std::cout << rex.getName() << " and " << borg.getName() << " are currently standing." << std::endl;
	int choice;
	auto chooseAction = [&choice](Fighter& fighter) {
		std::cout << std::endl << DUCK_DOWN + 1 << ") Duck down  " << STAND_UP + 1 << ") Stand up  " << JUMP + 1
			<< ") Jump  " << DIVE + 1 << ") Dive in the middle of a jump" << std::endl;
		std::cout << "Choice for " << fighter.getName() << "? ";
		std::cin >> choice;
		const Input input1 = static_cast<Input>(choice - 1);
		fighter.handleInput (input1);	
	};
	while (true) {
		chooseAction (rex);
		chooseAction (borg);
	}
}

 Strategy 
Defines a family of algorithms, encapsulates each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients who use it.

#include <iostream>
using namespace std;

class StrategyInterface
{
    public:
        virtual void execute() const = 0;
};

class ConcreteStrategyA: public StrategyInterface
{
    public:
        void execute() const override
        {
            cout << "Called ConcreteStrategyA execute method" << endl;
        }
};

class ConcreteStrategyB: public StrategyInterface
{
    public:
        void execute() const override
        {
            cout << "Called ConcreteStrategyB execute method" << endl;
        }
};

class ConcreteStrategyC: public StrategyInterface
{
    public:
        void execute() const override
        {
            cout << "Called ConcreteStrategyC execute method" << endl;
        }
};

class Context
{
    private:
        StrategyInterface * strategy_;

    public:
        explicit Context(StrategyInterface *strategy):strategy_(strategy)
        {
        }

        void set_strategy(StrategyInterface *strategy)
        {
            strategy_ = strategy;
        }

        void execute() const
        {
            strategy_->execute();
        }
};

int main(int argc, char *argv[])
{
    ConcreteStrategyA concreteStrategyA;
    ConcreteStrategyB concreteStrategyB;
    ConcreteStrategyC concreteStrategyC;

    Context contextA(&concreteStrategyA);
    Context contextB(&concreteStrategyB);
    Context contextC(&concreteStrategyC);

    contextA.execute(); // output: "Called ConcreteStrategyA execute method"
    contextB.execute(); // output: "Called ConcreteStrategyB execute method"
    contextC.execute(); // output: "Called ConcreteStrategyC execute method"

    contextA.set_strategy(&concreteStrategyB);
    contextA.execute(); // output: "Called ConcreteStrategyB execute method"
    contextA.set_strategy(&concreteStrategyC);
    contextA.execute(); // output: "Called ConcreteStrategyC execute method"

    return 0;
}

 Template Method 
By defining a skeleton of an algorithm in an operation, deferring some steps to subclasses, the Template Method lets subclasses redefine certain steps of that algorithm without changing the algorithm's structure.

#include <ctime>
#include <assert.h>
#include <iostream>

namespace wikibooks_design_patterns
{
/**
 * An abstract class that is common to several games in
 * which players play against the others, but only one is
 * playing at a given time.
 */

class Game
{
public:
    Game(): playersCount(0), movesCount(0), playerWon(-1)
    {
        srand( (unsigned)time( NULL));
    }

    /* A template method : */
    void playOneGame(const int playersCount = 0)
    {
        if (playersCount)
        {
            this->playersCount = playersCount;
        }

        InitializeGame();
        assert(this->playersCount);

        int j = 0;
        while (!endOfGame())
        {
            makePlay(j);
            j = (j + 1) % this->playersCount;
            if (!j)
            {
                ++movesCount;
            }
        }
        printWinner();
    }

protected:
    virtual void initializeGame() = 0;
    virtual void makePlay(int player) = 0;
    virtual bool endOfGame() = 0;
    virtual void printWinner() = 0;

private:
    void InitializeGame()
    {
        movesCount = 0;
        playerWon = -1;

        initializeGame();
    }

protected:
    int playersCount;
    int movesCount;
    int playerWon;
};

//Now we can extend this class in order 
//to implement actual games:

class Monopoly: public Game {

    /* Implementation of necessary concrete methods */
    void initializeGame() {
        // Initialize players
	playersCount = rand() * 7 / RAND_MAX + 2;
        // Initialize money
    }
    void makePlay(int player) {
        // Process one turn of player

	//	Decide winner
	if (movesCount < 20)
	    return;
	const int chances = (movesCount > 199) ? 199 : movesCount;
	const int random = MOVES_WIN_CORRECTION * rand() * 200 / RAND_MAX;
	if (random < chances)
	    playerWon = player;
    }
    bool endOfGame() {
        // Return true if game is over 
        // according to Monopoly rules
	return (-1 != playerWon);
    }
    void printWinner() {
	assert(playerWon >= 0);
	assert(playerWon < playersCount);

        // Display who won
	std::cout<<"Monopoly, player "<<playerWon<<" won in "<<movesCount<<" moves."<<std::endl;
    }

private:
    enum
    {
        MOVES_WIN_CORRECTION = 20,
    };
};

class Chess: public Game {

    /* Implementation of necessary concrete methods */
    void initializeGame() {
        // Initialize players
	playersCount = 2;
        // Put the pieces on the board
    }
    void makePlay(int player) {
	assert(player < playersCount);

        // Process a turn for the player

	//	decide winner
	if (movesCount < 2)
	    return;
	const int chances = (movesCount > 99) ? 99 : movesCount;
	const int random = MOVES_WIN_CORRECTION * rand() * 100 / RAND_MAX;
	//std::cout<<random<<" : "<<chances<<std::endl;
	if (random < chances)
	    playerWon = player;
    }
    bool endOfGame() {
        // Return true if in Checkmate or 
        // Stalemate has been reached
	return (-1 != playerWon);
    }
    void printWinner() {
	assert(playerWon >= 0);
	assert(playerWon < playersCount);

        // Display the winning player
	std::cout<<"Player "<<playerWon<<" won in "<<movesCount<<" moves."<<std::endl;
    }

private:
    enum
    {
	MOVES_WIN_CORRECTION = 7,
    };
};

}

int main()
{
    using namespace wikibooks_design_patterns;

    Game* game = NULL;

    Chess chess;
    game = &chess;
    for (unsigned i = 0; i < 100; ++i)
	 game->playOneGame();

    Monopoly monopoly;
    game = &monopoly;
    for (unsigned i = 0; i < 100; ++i)
	game->playOneGame();

    return 0;
}

 Visitor 
The Visitor Pattern will represent an operation to be performed on the elements of an object structure by letting you define a new operation without changing the classes of the elements on which it operates.

#include <string>
#include <iostream>
#include <vector>

using namespace std;

class Wheel;
class Engine;
class Body;
class Car;

// interface to all car 'parts'
struct CarElementVisitor 
{
  virtual void visit(Wheel& wheel) const = 0;
  virtual void visit(Engine& engine) const = 0;
  virtual void visit(Body& body) const = 0;

  virtual void visitCar(Car& car) const = 0;
  virtual ~CarElementVisitor() {};
};

// interface to one part
struct CarElement 
{
  virtual void accept(const CarElementVisitor& visitor) = 0;
  virtual ~CarElement() {}
};

// wheel element, there are four wheels with unique names
class Wheel : public CarElement
{
public:
  explicit Wheel(const string& name) :
    name_(name)
  {
  }
  const string& getName() const 
  {
    return name_;
  }
  void accept(const CarElementVisitor& visitor)  
  {
    visitor.visit(*this);
  }
private:
    string name_;
};

// engine
class Engine : public CarElement
{
public:
  void accept(const CarElementVisitor& visitor) 
  {
    visitor.visit(*this);
  }
};

// body
class Body : public CarElement
{
public:
  void accept(const CarElementVisitor& visitor) 
  {
    visitor.visit(*this);
  }
};

// car, all car elements(parts) together
class Car 
{
public:
  vector<CarElement*>& getElements()
  {
    return elements_;
  }
  Car() 
  {
    // assume that neither push_back nor Wheel(const string&) may throw
    elements_.push_back( new Wheel("front left") );
    elements_.push_back( new Wheel("front right") );
    elements_.push_back( new Wheel("back left") );
    elements_.push_back( new Wheel("back right") );
    elements_.push_back( new Body() );
    elements_.push_back( new Engine() );
  }
  ~Car()
  {
    for(vector<CarElement*>::iterator it = elements_.begin(); 
      it != elements_.end(); ++it)
    {
      delete *it;
    }
  }
private:
  vector<CarElement*> elements_;
};

// PrintVisitor and DoVisitor show by using a different implementation the Car class is unchanged
// even though the algorithm is different in PrintVisitor and DoVisitor.
class CarElementPrintVisitor : public CarElementVisitor 
{
public:
  void visit(Wheel& wheel) const
  { 
    cout << "Visiting " << wheel.getName() << " wheel" << endl;
  }
  void visit(Engine& engine) const
  {
    cout << "Visiting engine" << endl;
  }
  void visit(Body& body) const
  {
    cout << "Visiting body" << endl;
  }
  void visitCar(Car& car) const
  {
    cout << endl << "Visiting car" << endl;
    vector<CarElement*>& elems = car.getElements();
    for(vector<CarElement*>::iterator it = elems.begin();
      it != elems.end(); ++it )
    {
      (*it)->accept(*this);	// this issues the callback i.e. to this from the element  
    }
    cout << "Visited car" << endl;
  }
};

class CarElementDoVisitor : public CarElementVisitor 
{
public:
  // these are specific implementations added to the original object without modifying the original struct
  void visit(Wheel& wheel) const
  {
    cout << "Kicking my " << wheel.getName() << " wheel" << endl;
  }
  void visit(Engine& engine) const
  {
    cout << "Starting my engine" << endl;
  }
  void visit(Body& body) const
  {
    cout << "Moving my body" << endl;
  }
  void visitCar(Car& car) const
  {
    cout << endl << "Starting my car" << endl;
    vector<CarElement*>& elems = car.getElements();
    for(vector<CarElement*>::iterator it = elems.begin();
      it != elems.end(); ++it )
    {
      (*it)->accept(*this);	// this issues the callback i.e. to this from the element  
    }
    cout << "Stopped car" << endl;
  }
};

int main()
{
  Car car;
  CarElementPrintVisitor printVisitor;
  CarElementDoVisitor doVisitor;

  printVisitor.visitCar(car);
  doVisitor.visitCar(car);

  return 0;
}

 Model-View-Controller (MVC) 
A pattern often used by applications that need the ability to maintain multiple views of the same data. The model-view-controller pattern was until recently^{[citation needed]} a very common pattern especially for graphic user interlace programming, it splits the code in 3 pieces. The model, the view, and the controller. 

The Model is the actual data representation (for example, Array vs Linked List) or other objects representing a database. The View is an interface to reading the model or a fat client GUI. The Controller provides the interface of changing or modifying the data, and then selecting the "Next Best View" (NBV). 

Newcomers will probably see this "MVC" model as wasteful, mainly because you are working with many extra objects at runtime, when it seems like one giant object will do. But the secret to the MVC pattern is not writing the code, but in maintaining it, and allowing people to modify the code without changing much else. Also, keep in mind, that different developers have different strengths and weaknesses, so team building around MVC is easier. Imagine a View Team that is responsible for great views, a Model Team that knows a lot about data, and a Controller Team that see the big picture of application flow, handing requests, working with the model, and selecting the most appropriate next view for that client.

For example: A naive central database can be organized using only a "model", for example, a straight array. However, later on, it may be more applicable to use a linked list. All array accesses will have to be remade into their respective Linked List form (for example, you would change myarray[5] into mylist.at(5) or whatever is equivalent in the language you use).

Well, if we followed the MVC pattern, the central database would be accessed using some sort of a function, for example, myarray.at(5). If we change the model from an array to a linked list, all we have to do is change the view with the model, and the whole program is changed. Keep the interface the same but change the underpinnings of it. This would allow us to make optimizations more freely and quickly than before.

One of the great advantages of the Model-View-Controller Pattern is obviously the ability to reuse the application's logic (which is implemented in the model) when implementing a different view. A good example is found in web development, where a common task is to implement an external API inside of an existing piece of software. If the MVC pattern has cleanly been followed, this only requires modification to the controller, which can have the ability to render different types of views dependent on the content type requested by the user agent.

 Libraries 
Libraries allow existing code to be reused in a program. Libraries are like programs except that instead of relying on main() to do the work you call the specific functions provided by the library to do the work. Functions provide the interface between the program being written and the library being used. This interface is called Application Programming Interface or API.

Libraries should and tend to be domain specific as to permit greater mobility across applications, and provide extended specialization.
Libraries that are not, are often header only distribution, intended for static linking as to permit the compiler and the application, only to use the needed bits of code.

What is an API?
To a programmer, an operating system is defined by its API. API stands for Application Programming Interface. An API encompasses all the function calls that an application program can communicate with the hardware or the operating system, or any other application that provides a set of interfaces to the programmer (i.e.: a library), as well as definitions of associated data types and structures. Most APIs are defined on the application Software Development Kit (SDK) for program development.

In simple terms the API can be considered as the interface through which the user (or user programs) will be able interact with the operating system, hardware or other programs to make them to perform a task that may also result in obtaining a result message.

Can an API be called a framework?
No, a framework may provide an API, but a framework is more than a simple API. By default a framework also defines how the code is written, it is a set of solutions, even classes, that as a group addresses the handling of a limited set of related problems and provides not only an API but a default functionality, well designed frameworks enable its interchangeability for a similar framework, striving to provides the same API. 

As seen in the File organization Section, compiled libraries consists in C++ headers files that are included by the preprocessor and binary library files which are used by the linker to generate the resulting compilation. For a dynamically linked library, only the loading code is added to the compilation that uses them, the actual loading of the library is done in the memory at run-time.

Programs can make use of libraries in two forms, as static or dynamic depending on how the programmer decides to distribute its code or even due to the licensing used by third party libraries, the static and dynamic libraries section of this book will cover in depth this subject.

 Third party libraries 
Additional functionality that goes beyond the standard libraries (like garbage collection) are available (often free) by third party libraries, but remember that third party libraries do not necessarily provide the same ubiquitous cross-platform functionality or an API style conformant with as standard libraries. The main motivation for their existence is for preventing one tho reinvent the wheel and to make efforts converge; too much energy has been spent by generations of programmers to write safe and "portable" code.

There are several libraries a programmer is expected to know about or have at least a passing idea of what they are. Time, consistency and extended references will make a few libraries pop-out from the rest. One notable example is the highly respected collection of Boost libraries that we will examine ahead.

Licensing on third party libraries
The programmer may also be limited by the requirements of the license used on external libraries that he has no direct control, for instance the use of the GNU General Public License (GNU GPL) code in closed source applications isn't permitted to address this issue the FSF provides an alternative in the form of the GNU LGPL license that permits such uses but only in the  dynamically linked form, this is mirrored by several other legal requirements a programmer must attend and comply to.

Libraries come in two forms, either in source form or in compiled/binary form. Libraries in source-form must first be compiled before they can be included in another project. This will transform the libraries' cpp-files into a lib-file. If a program must be recompiled to run with a new version of a library, but does not need any further changes, the library is said to be source compatible. If a program does not need to be modified and recompiled to use a new version of a library, the library is then classified as being binary compatible.

 Static and Dynamic Libraries 

Advantages of using static binaries:
 Simplification of program distribution (fewer files).
 Code simplification (no version checks as required in dynamic libraries).
 Will only compile the code that is used. 

Disadvantages of using static binaries:
 Waste of resources: Generates larger binaries, since the library is compiled into the executable. Wastes memory as the library cannot be shared (in memory) between processes (depending on the operating system).
 Program will not benefit from bug fixes or extensions in the libraries without being recompiled.

Binary/Source Compatibility of libraries
A library is said to be binary compatible if the program that dynamically links to an earlier version of that library, continues to work using another versions of the same library. If a recompilation of the program is needed for it to run with each new version the library is said to be source compatible.

Producing binary compatible libraries is beneficial for distribution but harder to maintain by the programmer. It is often seen as a better solution to do static linking, if the library is only source compatible, since it will not cause problems to the end-user.  

Binary compatibility saves a lot of trouble and is a signal that the library reached a status of stability. It makes it easier to distribute software for a certain platform. Without ensuring binary compatibility between releases, people will be forced to offer statically linked binaries.

header-only libraries
Another distinction that is commonly made about libraries are on how they are distributed (regarding structure and use). A library that is contained only on header files is considered header-only library. Often this means that they are simpler and easy to use, however this will not be the ideal solution for complex code, it will not only hamper readability but result in larger compile times. Also depending on the compiler and it's optimizing capabilities (or options) can, due to the resulting inlining, generate larger binaries. This may not be as important in libraries mostly implemented with templates. Header-only libraries will always contain the source code to the implementation, commercial is rare.

 Example: Configuring MS Visual C++ to use external libraries 
The Boost library is used as example library.

Considering you already have decompressed and have the binary part of the Boost library built. There the steps which have to be performed:

 Include directory 
Set up the include directory. This is the directory that contains the header files (.h/hpp), which describes the library interface:

 Library directory 
Set up the library directory. This is the directory that contains the pre-compiled library files (.lib):

 Library files 
Enter library filenames in additional dependencies for the libraries to use:

Some libraries (such as e.g. Boost) use auto-linking to automate the process of selecting library files for linking, based on which header-files are included. Manual selection of library filenames are not required for such libraries if your compiler supports auto-linking.

 Dynamic libraries 
In case of dynamically loaded (.dll) libraries, one also has to place the DLL-files either in the same folder as the executable, or in the system PATH.

 Run-time library 
The libraries also have to be compiled with the same run-time library as the one used in your project. Many libraries therefore come in different editions, depending on whether they are compiled for single- or multi-threaded runtime and debug or release runtime, as well as whether they contain debug symbols or not.

 Boost Library 
The Boost library (http://www.boost.org/) provides free peer-reviewed , open source libraries that extend the functionality of C++. Most of the libraries are licensed under the Boost Software License, designed to allow Boost to be used with both open and closed source projects.

Many of Boost's founders are on the C++ standard committee and several Boost libraries have been accepted for incorporation into the Technical Report 1 of C++0x. Although Boost was begun by members of the C++ Standards Committee Library Working Group, participation has expanded to include thousands of programmers from the C++ community at large.

The emphasis is on libraries which work well with the C++ Standard Library. The libraries are aimed at a wide range of C++ users and application domains, and are in regular use by thousands of programmers. They range from general-purpose libraries like SmartPtr, to OS Abstractions like FileSystem, to libraries primarily aimed at other library developers and advanced C++ users, like MPL.

A further goal is to establish "existing practice" and provide reference implementations so that Boost libraries are suitable for eventual standardization. Ten Boost libraries will be included in the  C++ Standards Committee's upcoming  C++ Standard Library Technical Report as a step toward becoming part of a future C++ Standard.

In order to ensure efficiency and flexibility, Boost makes extensive use of templates.  Boost has been a source of extensive work and research into generic programming and metaprogramming in C++.

 extension libraries 

 Algorithms
 Concurrent programming (threads)
 Containers
array - Management of fixed-size arrays with STL container semantics
Boost Graph Library (BGL) - Generic graph containers, components and algorithms
multi-array - Simplifies creation of N-dimensional arrays
multi-index containers - Containers with built in indexes that allow different sorting and access semantics
pointer containers - Containers modeled after most standard STL containers that allow for transparent management of pointers to values
property map - Interface specifications in the form of concepts and a general purpose interface for mapping key values to objects
variant - A safe and generic stack-based object container that allows for the efficient storage of and access to an object of a type that can be chosen from among a set of types that must be specified at compile time.
 Correctness and testing
concept check - Allows for the enforcement of actual template parameter requirements (concepts)
static assert - Compile time assertion support
Boost Test Library - A matched set of components for writing test programs, organizing tests into test cases and test suites, and controlling their runtime execution
 Data structures
dynamic_bitset - Dynamic std::bitset-like data structure
 Function objects and higher-order programming
bind and mem_fn - General binders for functions, function objects, function pointers and member functions
function - Function object wrappers for deferred calls. Also, provides a generalized mechanism for callbacks
functional - Enhancements to the function object adapters specified in the C++ Standard Library, including:
function object traits
negators
binders
adapters for pointers to functions
adapters for pointers to member functions
hash - An implementation of the hash function object specified by the C++ Technical Report 1 (TR1). Can be used as the default hash function for unordered associative containers
lambda - In the spirit of lambda abstractions, allows for the definition of small anonymous function objects and operations on those objects at a call site, using placeholders, especially for use with deferred callbacks from algorithms. 
ref - Provides utility class templates for enhancing the capabilities of standard C++ references, especially for use with generic functions
result_of - Helps in the determination of the type of a call expression
signals and slots - Managed signals and slots callback implementation
 Generic programming
 Graphs
 Input/output
 Interlanguage support (for Python)
 Iterators
iterators
operators - Class templates that help with overloaded operator definitions for user defined iterators and classes that can participate in arithmetic computation.
tokenizer - Provides a view of a set of tokens contained in a sequence that makes them appear as a container with iterator access
 Math and Numerics
 Memory
pool - Provides a simple segregated storage based memory management scheme
smart_ptr - A collection of smart pointer class templates with different pointee management semantics
scoped_ptr - Owns the pointee (single object)
scoped_array - Like scoped_ptr, but for arrays
shared_ptr - Potentially shares the pointer with other shared_ptrs. Pointee is destroyed when last shared_ptr to it is destroyed
shared_array - Like shared_ptr, but for arrays
weak_ptr - Provides a "weak" reference to an object that is already managed by a shared_ptr
intrusive_ptr - Similared to shared_ptr, but uses a reference count provided by the pointee
utility - Miscellaneous support classes, including:
base from member idiom - Provides a workaround for a class that needs to initialize a member of a base class inside its own (i.e., the derived class') constructor's initializer list
checked delete - Check if an attempt is made to destroy an object or array of objects using a pointer to an incomplete type
next and prior functions - Allow for easier motion of a forward or bidirectional iterator, especially when the results of such a motion need to be stored in a separate iterator (i.e., should not change the original iterator)
noncopyable - Allows for the prohibition of copy construction and copy assignment
addressof - Allows for the acquisition of an object's real address, bypassing any overloads of operator&(), in the process
result_of - Helps in the determination of the type of a call expression
 Miscellaneous
 Parsers
 Preprocessor metaprogramming
 String and text processing
lexical_cast - Type conversions to/from text
format - Type safe argument formatting according to a format string
iostreams - C++ streams and stream buffer assistance for new sources/sinks, filters framework
regex - Support for regular expressions
Spirit - An object-oriented recursive-descent parser generator framework
string algorithms - A collection of various algorithms related to strings
tokenizer - Allows for the partitioning of a string or other character sequence into tokens
wave - Standards conformant implementation of the mandated C99 / C++ pre-processor functionality packed behind an easy to use interface
 Template metaprogramming
mpl - A general purpose high-level metaprogramming framework of compile-time algorithms, sequences and metafunctions
static assert - Compile time assertion support
type traits - Templates that define the fundamental properties of types
 Workarounds for broken compilers

The current Boost release contains 87 individual libraries, including the following three:

 noncopyable 
The boost::noncopyable utility class that ensures that objects of a class are never copied.

class C : boost::noncopyable
{
  ...
};

 Linear algebra – uBLAS 
Boost includes the uBLAS linear algebra library, with BLAS support for vectors and matrices. uBlas supports a wide range of linear algebra operations, and has bindings to some widely used numerics libraries, such as ATLAS, BLAS and LAPACK.

 Example showing how to multiply a vector with a matrix:

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>
#include <iostream>

using namespace boost::numeric::ublas;

/* "y = Ax" example */
int main () 
{
      vector<double> x(2);
      x(0) = 1; x(1) = 2;

      matrix<double> A(2,2);
      A(0,0) = 0; A(0,1) = 1;
      A(1,0) = 2; A(1,1) = 3;

      vector<double> y = prod(A, x);

      std::cout << y << std::endl;
      return 0;
}

 Generating random numbers – Boost.Random 
Boost provides distribution-independent pseudorandom number generators and PRNG-independent probability distributions, which are combined to build a concrete generator.
 Example showing how to sample from a normal distribution using the Mersenne Twister generator:

#include <boost/random.hpp>
#include <ctime>

using namespace boost;

double SampleNormal (double mean, double sigma)
{
    // Create a Mersenne twister random number generator
    // that is seeded once with #seconds since 1970
    static mt19937 rng(static_cast<unsigned> (std::time(0)));

    // select Gaussian probability distribution
    normal_distribution<double> norm_dist(mean, sigma);

    // bind random number generator to distribution, forming a function
    variate_generator<mt19937&, normal_distribution<double> >  normal_sampler(rng, norm_dist);

    // sample from the distribution
    return normal_sampler();
}

See Boost Random Number Library for more details.

 Multi-threading – Boost.Thread 
Example code that demonstrates creation of threads:

#include <boost/thread/thread.hpp>
#include <iostream>

using namespace std; 

void hello_world() 
{
  cout << "Hello world, I'm a thread!" << endl;
}

int main(int argc, char* argv[]) 
{
  // start two new threads that calls the "hello_world" function
  boost::thread my_thread1(&hello_world);
  boost::thread my_thread2(&hello_world);

  // wait for both threads to finish
  my_thread1.join();
  my_thread2.join();

  return 0;
}

See also Threading with Boost - Part I: Creating Threads

 Thread locking 
Example usage of a mutex to enforce exclusive access to a function:

#include <iostream>
#include <boost/thread.hpp>

void locked_function ()
{
    // function access mutex
    static boost::mutex m;
    // wait for mutex lock
    boost::mutex::scoped_lock lock(m);

    // critical section
    // TODO: Do something

    // auto-unlock on return
}

int main (int argc, char* argv[]) 
{
    locked_function();
    return 0;
}

Example of read/write locking of a property:

#include <iostream>
#include <boost/thread.hpp>

/** General class for thread-safe properties of any type. */
template <class T>
class lock_prop : boost::noncopyable {
public:
    lock_prop () {}

    /** Set property value. */
    void operator = (const T & v) {
        // wait for exclusive write access
        boost::unique_lock<boost::shared_mutex> lock(mutex);

        value = v;
    }

    /** Get property value. */
    T operator () () const {
        // wait for shared read access
        boost::shared_lock<boost::shared_mutex> lock(mutex);

        return value;
    }

private:
    /// Property value.
    T                           value;
    /// Mutex to restrict access
    mutable boost::shared_mutex mutex;
};

int main () {
    // read/write locking property
    lock_prop<int> p1;
    p1 = 10;
    int a = p1();

    return 0;
}

 Introduction to Boost.Threads in Dr. Dobb's Journal. (2002)
 What's New in Boost Threads? in Dr. Dobb's Journal. (2008)
 Boost.Threads API reference.
 threadpool library based on Boost.Thread
 Ceemple Boost included in Ceemple, a rapid JIT based C++ technical computing environment. 

 Cross-Platform development 
The section is to introduce programmer to programming with the aim of portability across several OSs environments.  In today’s world it does not seem appropriate to constrain applications to a single operating system or computer platform, and there is an increasing need to address programming in a cross platform manner.

 The Windows 32 API 
Win32 API is a set of functions defined in the Windows OS, in other words it is the Windows API, this is the name given by Microsoft to the core set of application programming interfaces available in the Microsoft Windows operating systems. It is designed for usage by C/C++ programs and is the most direct way to interact with a Windows system for software applications. Lower level access to a Windows system, mostly required for device drivers, is provided by the Windows Driver Model in current versions of Windows.

One can get more information about the API and support from Microsoft itself, using the MSDN Library ( http://msdn.microsoft.com/ ) essentially a resource for developers using Microsoft tools, products, and technologies. It contains a bounty of technical programming information, including sample code, documentation, technical articles, and reference guides. You can also check out Wikibooks Windows Programming book for some more detailed information that goes beyond the scope of this book.

A software development kit (SDK) is available for Windows, which provides documentation and tools to enable developers to create software using the Windows API and associated Windows technologies.
( http://www.microsoft.com/downloads/ )

 History 
The Windows API has always exposed a large part of the underlying structure of the various Windows systems for which it has been built to the programmer. This has had the advantage of giving Windows programmers a great deal of flexibility and power over their applications. However, it also has given Windows applications a great deal of responsibility in handling various low-level, sometimes tedious, operations that are associated with a Graphical user interface.

Charles Petzold, writer of various well read Windows API books, has said: "The original hello-world program in the Windows 1.0 SDK was a bit of a scandal. HELLO.C was about 150 lines long, and the HELLO.RC resource script had another 20 or so more lines. (...) Veteran C programmers often curled up in horror or laughter when encountering the Windows hello-world program.". A hello world program is a often used programming example, usually designed to show the easiest possible application on a system that can actually do something (i.e. print a line that says "Hello World").

Over the years, various changes and additions were made to the Windows Operating System, and the Windows API changed and grew to reflect this. The windows API for Windows 1.0 supported less than 450 function calls, where in modern versions of the Windows API there are thousands. In general, the interface has remained fairly consistent however, and a old Windows 1.0 application will still look familiar to a programmer who is used to the modern Windows API.

A large emphasis has been put by Microsoft on maintaining software backwards compatibility. To achieve this, Microsoft sometimes went as far as supporting software that was using the API in a undocumented or even (programmatically) illegal way. Raymond Chen, a Microsoft developer who works on the Windows API, has said that he "could probably write for months solely about bad things apps do and what we had to do to get them to work again (often in spite of themselves). Which is why I get particularly furious when people accuse Microsoft of maliciously breaking applications during OS upgrades. If any application failed to run on Windows 95, I took it as a personal failure."

 Variables and Win32
Win32 uses an extended set of data types, using C's typedef mechanism These include:
BYTE - unsigned 8 bit integer.
DWORD -	32 bit unsigned integer.
LONG - 32 bit signed integer.
LPDWORD - 32 bit pointer to DWORD.
LPCSTR - 32 bit pointer to constant character string.
LPSTR -	32 bit pointer to character string.
UINT - 32 bit unsigned int.
WORD - 16 bit unsigned int.
HANDLE - opaque pointer to system data.

Of course standard data types are also available when programming with Win32 API.

 Windows Libraries (DLLs) 
In Windows, library code exists in  a number of forms, and can be accessed in various ways.

Normally, the only thing that is needed is to include in the appropriate header file on the source code the information to the compiler, and linking  to the .lib file will occur during the linking phase.

This .lib file either contains code which is to be statically linked into compiled object code
or contains code to allow access to a dynamically link to a binary library(.DLL) on the system.

It is also possible to generate a binary library .DLL within C++ by including appropriate
information such as an import/export table when compiling and linking.

DLLs stand for Dynamic Link Libraries, the basic file of functions that are used in some programs. Many newer C++ IDEs such as Dev-CPP support such libraries.

Common libraries on Windows include those provided by the Platform Software Development Kit,
Microsoft Foundation Class and a C++ interface to .Net Framework assemblies.

Although not strictly use as library code, the Platform SDK and other libraries provide a set of standardized interfaces to objects accessible via the Component Object Model implemented as part of 
Windows. 

 API conventions and Win32 API Functions (by focus) 

 Time 
Time measurement has to come from the OS in relation to the hardware it is run, unfortunately  most computers don't have a standard high-accuracy, high-precision time clock that is also quick to access.

MSDN Time Functions ( http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/time_functions.asp )

Timer Function Performance ( http://developer.nvidia.com/object/timer_function_performance.html )

GetTickCount has a precision (dependent on your timer tick rate) of one millisecond, its accuracy typically within a 10-55ms expected error, the best thing is that it increments at a constant rate. (WaitForSingleObject uses the same timer).

GetSystemTimeAsFileTime has a precision of 100-nanoseconds, its accuracy is similar to GetTickCount.

QueryPerformanceCounter can be slower to obtain but has higher accuracy, uses the HAL (with some help from ACPI) a problem with it is that it can travel back in time on over-clocked PCs due to garbage on the LSBs, note that  the functions fail unless the supplied LARGE_INTEGER is DWORD aligned.

Performance counter value may unexpectedly leap forward ( http://support.microsoft.com/default.aspx?scid=KB;EN-US;Q274323& )

timeGetTime (via winmm.dll) has a precision of ~5ms.

 File System 
MakeSureDirectoryPathExists (via Image Help Library - IMAGHLP.DLL, #pragma comment( lib, "imagehlp.lib" ), #include <imagehlp.h> ) creates directories, only useful to create/force the existence of a given dir tree or multiple directories, or if the linking is already present, note that it is single threaded.

 Network 
Network applications are often built in C++ on windows utilizing the WinSock API functions.

 Resources 
Resources files are perhaps one of the most useful elements included on the WIN32 API, they are how we program menu's, add icons, backgrounds, music and many more aesthetically pleasing elements to our programs. Sadly the use in compilation use of resource files is today to those using the MS Visual Studio IDE (resource editor, resource structure understanding).

The resources are defined in a .rc file (resource c) and are included at the linking phase of compile. Resource files work hand in hand with a header file (usually called resource.h) which carries the definitions of each ID.

For example a simple RC file might contain a menu:

//////////////
IDR_MYMENU MENU
BEGIN
    POPUP "&File"
    BEGIN
         MENUITEM "&About", ID_FILE_ABOUT
        MENUITEM "E&xit", ID_FILE_EXIT
    END

    POPUP "&Edit"
    BEGIN
    // Insert menu here :p
    END

    POPUP "&Links"
    BEGIN
        MENUITEM "&Visit Lukem_95's Website", ID_LINK_WEBSITE
        MENUITEM "G&oogle.com", ID_LINK_GOOGLE
END
END
//////////////

And the corresponding H file:
#define IDR_MYMENU 9000
#define ID_FILE_EXIT 9001
#define ID_LINK_WEBSITE 9002
#define ID_LINK_GOOGLE 9003 #define ID_FILE_ABOUT 9004

 Win32 API Wrappers 
Since the Win32 API is C based and also a moving target and since some alterations are done in each OS version some wrappers were created, in this section you will find some of the approaches available to facilitate the use of the API in a C++ setup and provide abstraction from the low level stuff with higher level implementations of common needed features, dealing with the GUI, complex controls even communications and database access.

 Microsoft Foundation Classes (MFC); 
 a C++ library for developing Windows applications and UI components. Created by Microsoft for the C++ Windows programmer as an abstraction layer for the Win32 API, the use of the new STL enabled capabilities is scarce on the MFC. It's also compatible with Windows CE (the pocket PC version of the OS). MFC was designed to use the Document-View pattern a variant of the Model View Controller (MVC) pattern.
More info about MFC can be obtained on the Windows Programming Wikibook. 

 Windows Template Library (WTL); 
 a C++ library for developing Windows applications and UI components. It extends ATL (Active Template Library) and provides a set of classes for controls, dialogs, frame windows, GDI objects, and more. This library is not supported by Microsoft Services (but is used internally at MS and available for download at MSDN).

 Win32 Foundation Classes (WFC); 
 (http://www.samblackburn.com/wfc/) a library of C++ classes that extend Microsoft Foundation Classes (MFC) to do NT specific things.

 Borland Visual Component Library (VCL); 
 a Delphi/C++ library for developing Windows applications, UI components and different kinds of service applications. Created by Borland as an abstraction layer for the Win32 API, but also implementing many non-visual, and non windows-specific objects, like AnsiString class for example.

 Generic wrappers 
Generic GUI/API wrappers are programming libraries that provide a uniform platform neutral interface (API) to the operating system regardless of underlying platform. Such libraries greatly simplify development of cross-platform software.

Using a wrapper as a portability layer will offer applications some or all following benefits:

 Independence from the hardware.
 Independence from the Operating System.
 Independence from changes made to specific releases.
 Independence from API styles and error codes.

Cross-platform programming is more than only GUI programming. Cross-platform programming deals with the minimum requirements for the sections of code that aren't specified by the C++ Standard Language, so as programs can be compiled and run across different hardware platforms. 

Here is some cross-platform GUI toolkit:
 Gtkmm - an interface for the C GUI library GTK+. It is not cross-platform by design, but rather mutli-platform i.e. can be used on many platform.
 Qt (http://qt-project.org) - a cross-platform (Qt is the basis for the Linux KDE desktop environment and supports the X Window System (Unix/X11), Apple Mac OS X, Microsoft Windows NT/9x/2000/XP/Vista/7 and the Symbian OS), it is an object-oriented application development framework, widely used for the development of GUI programs (in which case it is known as a widget toolkit), and for developing non-GUI programs such as console tools and servers. Used in numerous commercial applications such as Google Earth, Skype for Linux and Adobe Photoshop Elements. Released under the LGPL or a commercial license.
 wxWidgets (http://wxwidgets.org/) - a widget toolkit for creating graphical user interfaces (GUIs) for cross-platform applications on Win32, Mac OS X, GTK+, X11, Motif, WinCE, and more using one codebase. It can be used from languages such as C++, Python, Perl, and C#/.NET. Unlike other cross-platform toolkits, wxWidgets applications look and feel native. This is because wxWidgets uses the platform's own native controls rather than emulating them. It's also extensive, free, open-source, and mature. wxWidgets is more than a GUI development toolkit it provides classes for files and streams, application settings, multiple threads, interprocess communication, database access and more.
 FLTK The "Fast, Light Toolkit"

 Multi-tasking 
Multi-tasking is a process by which multiple tasks (also known as processes), share common processing resources such as a CPU.

A computer with a single CPU, will only run one process at a time. By running it means that in a specific point in time, the CPU is actively executing instructions for that process. With a single CPU, systems using scheduling can achieve multi-tasking, by which the time of the processor is time-shared by several processes, permitting each to advance their computations, seemingly in parallel. A process runs for some time and another waiting gets a turn.

The act of reassigning a CPU from one task to another one is called a context switch. When context switches occur frequently enough, the illusion of parallelism is achieved.

Even on computers with more than one CPU, multiprocessor machines, multi-tasking allows many more tasks to be run than there are CPUs. 

Operating systems may adopt one of many different scheduling strategies, which generally fall into the following categories:
 In multiprogramming systems, the running task keeps running until it performs an operation that requires waiting for an external event (e.g. reading from a tape) or until the computer's scheduler forcibly swaps the running task out of the CPU. Multiprogramming systems are designed to maximize CPU usage.
 In time-sharing systems, the running task is required to relinquish the CPU, either voluntarily or by an external event such as a hardware interrupt. Time sharing systems are designed to allow several programs to execute apparently simultaneously.  The term time-sharing used to define this behavior is no longer in use, having been replaced by the term multi-tasking.
 In real-time systems, some waiting tasks are guaranteed to be given the CPU when an external event occurs. Real time systems are designed to control mechanical devices such as industrial robots, which require timely processing.

Multi-tasking has already been successfully integrated into current Operating Systems. Most computers in use today supports running several processes at a time. This is required for systems using symmetric multiprocessor (SMP) in distributed computing and multi-core or chip multiprocessors (CMPs) computing, where processors have gone from dual-core to quad-core and core number will continue to increase. Each technology has its specific limitations and applicability, but all these technologies share the common objective of performing concurrent processing.

 Processes 
Processes are independent execution units that contain their own state information, use their own address spaces, and only interact with each other via inter-process communication (IPC) mechanisms . A process can be said to at least contain one thread of execution (not to be confused to a complete thread construct). Processes are managed by the hosting OS in a process data structure. The maximum number of processes that can run concurrently, depend on the OS and on the available resources of that system.

 Child Process 
A child process (also spawn process), is a process that was created by another process (the parent process), inheriting most of the parent attributes, such as opened files. Each process may create many child processes but will have at most one parent process; if a process does not have a parent this usually indicates that it was created directly by the kernel.

In UNIX, a child process is in fact created (using fork) as a copy of the parent. The child process can then overlay itself with a different program (using exec) as required. The very first process, called init, is started by the kernel at booting time and never terminates; other parentless processes may be launched to carry out various daemon tasks in userspace. Another way for a process to end up without a parent is, if its parent dies leaving an orphan process; but in this case it will shortly be adopted by init.

 Inter-Process Communication (IPC) 
IPC is generally managed by the operating system.

 Shared Memory 
Most of more recent OSs provide some sort of memory protection. In a Unix system, each process is given its own virtual address space, and the system, in turn, guarantees that no process can access the memory area of another. If an error occurs on a process, only that process memory's contents can be corrupted. 

With shared memory, the need of enabling random-access to shared data between different processes is addressed. But declaring a given section of memory as simultaneously accessible by several processes raises the need for control and synchronization, since several processes might try to alter this memory area at the same time.

 Multi-Threading 
Until recently, the C++ standard did not include any specification or built-in support for multi-threading. Therefore, Threading had to be implemented using special threading libraries, which are often platform dependent, as an extension to the C++ standard.

Some popular C++ threads libraries include:

(This list is not intended to be complete.)

 Boost - This package includes several libraries, one of which is threads (concurrent programming). the boost threads library is not very full featured, but is complete, portable, robust and in the flavor of the C++ standard. Uses the boost license that is similar to the BSD license.
 Intel® Threading Building Blocks  (TBB) offers a rich approach to expressing parallelism in a C++ program. The library helps you take advantage of multi-core processor performance without having to be a threading expert. Threading Building Blocks is not just a threads-replacement library. It represents a higher-level, task-based parallelism that abstracts platform details and threading mechanism for performance and scalability and performance. It is an open source project under the GNU General Public License version two (GPLv2) with the runtime exception.
 Intel® Cilk™ Plus  (Intel® Cilk™ Plus) adds simple language extensions to the C and C++languages to express task and data parallelism. These language extensions are powerful, yet easy to apply and use in a wide range of applications.
 Adaptive Communication Environment (often referred to as ACE) - Another toolkit which includes a portable threads abstraction along with many many other facilities, all rolled into one library. Open source released under a nonstandard but nonrestrictive license.
 Zthreads - A portable thread abstraction library. This library is feature rich, deals only with concurrency and is open source licensed under the MIT license. 

Of course, you can access the full POSIX and the C language threads interface from C++ and on Windows the API. So why bother with a library on top of that?

The reason is that things like locks are resources that are allocated, and C++ provides abstractions to make managing these things easier. For instance, boost::scoped_lock<> uses object construction/destruction to insure that a mutex is unlocked when leaving the lexical scope of the object. Classes like this can be very helpful in preventing deadlock, race conditions, and other problems unique to threaded programs. Also, these libraries enable you to write cross-platform multi-threading code, while using platform-specific function cannot.

In any case when using threading methodology, dictates that you must identify hotspots, the segments of code that take the most execution time. To determine the best chance at achieving the maximum performance possible, the task can be approached from bottom-up and top-down to determine those code segments that can run in parallel.

In the bottom-up approach, one focus solely on the hotspots in the code. This requires a deep analysis of the call stack of the application to determine the sections of code that can be run in parallel and reduce hotspots. In hotspot sections that employ concurrency, it is still required to move that concurrency at a point higher up in the call stack as to increase the granularity of each thread execution.

Using the top-down approach, the focus is on all the parts of the application, in determining what computations can be coded to run in parallel, at a higher level of abstraction. Reducing the level of abstraction until the overall performance gains are sufficient to reach the necessary goals, the benefit being speed of implementation and code re-usability. This is also the best method for archiving a optimal level of granularity for all computations.

Threads vs. Processes
Both threads and processes are methods of parallelizing an application, its implementation may differ from one operating system to another. A process has always one thread of execution, also known as the primary thread. In general, a thread is contained inside a process (in the address space of the process) and different threads of the same process share some resources while different processes do not.

 Atomicity 
Atomicity refers to atomic operations that are indivisible and/or uninterruptible. Even on a single core, you cannot assume that an operation will be atomic. In that regard only when using assembler can one guarantee the atomicity of an operation. Therefore, the C++ standard provides some guarantees as do operating systems and external libraries.

An atomic operation can also be seen as any given set of operations that can be combined so that they appear to the rest of the system to be a single operation with only two possible outcomes: success or failure. This all depends on the level of abstraction and underlying guarantees.

All modern processors provide basic atomic primitives which are then used to build more complex atomic objects. In addition to atomic read and write operations, most platforms provide an atomic read-and-update operation like test-and-set or compare-and-swap, or a pair of operations like load-link/store-conditional that only have an effect if they occur atomically (that is, with no intervening, conflicting update). These can be used to implement locks, a vital mechanism for multi-threaded programming, allowing invariants and atomicity to be enforced across groups of operations.

Many processors, especially 32-bit ones with 64-bit floating point support, provide some read and write operations that are not atomic: one thread reading a 64-bit register while another thread is writing to it may see a combination of both "before" and "after" values, a combination that may never actually have been written to the register. Further, only single operations are guaranteed to be atomic; threads arbitrarily performing groups of reads and writes will also observe a mixture of "before" and "after" values. Clearly, invariants cannot be relied on when such effects are possible.

If not dealing with known guaranteed atomic operations, one should rely on the synchronization primitives at the level of abstraction that one is coding to.

Example - One process
For example, imagine a single process is running on a computer incrementing a value in a given memory location. To increment the value in that memory location:
 the process reads the value in the memory location;
 the process adds one to the value;
 the process writes the new value back into the memory location.

Example - Two processes
Now, imagine two processes are running incrementing a single, shared memory location:
 the first process reads the value in memory location;
 the first process adds one to the value;
but before it can write the new value back to the memory location it is suspended, and the second process is allowed to run:
 the second process reads the value in memory location, the same value that the first process read;
 the second process adds one to the value;
 the second process writes the new value into the memory location.
The second process is suspended and the first process allowed to run again:
 the first process writes a now-wrong value into the memory location, unaware that the other process has already updated the value in the memory location.

This is a trivial example. In a real system, the operations can be more complex and the errors introduced extremely subtle. For example, reading a 64-bit value from memory may actually be implemented as two sequential reads of two 32-bit memory locations. If a process has only read the first 32-bits, and before it reads the second 32-bits the value in memory gets changed, it will have neither the original value nor the new value but a mixed-up garbage value.

Furthermore, the specific order in which the processes run can change the results, making such an error difficult to detect and debug.

OS and portability
Considerations are not only necessary with regard to the underling hardware but also in dealing with the different OS APIs. When porting code across different OSs one should consider what guarantees are provided. Similar considerations are necessary when dealing with external libraries. 

 Race condition 
A race condition (data race, or simply race), occurs when data is accessed concurrently from multiple execution paths. It happens for instance when multiple threads have shared access to the same resource such as a file or a block of memory, and at least one of the accesses is a write. This can lead to interference with one another.

Threaded programming is built around predicates and shared data. It is necessary to identify all possible execution paths and identify truly independent computations. To avoid problems it is best to implement concurrency at the highest level possible.

Most race conditions occur due to an erroneous assumption about the order in which threads will run. When dealing with shared variables, never assume that a threaded write operation will precede a threaded read operation. If you need guarantees you should see if synchronization primitives are available, and if not, you should implement your own. 

 Locking 
Locking temporarily prevents un-shareable resources from being used simultaneously. Locking can be achieved by using a synchronization object.

One of the biggest problems with threading is that locking requires analysis and understanding of the data and code relationships. This complicates software development--especially when targeting multiple operating systems. This makes multi-threaded programming more like art than science.

The number of locks (depending on the synchronization object) may be limited by the OS. A lock can be set to protect more than one resource, if always accessed in the same critical region.

 Critical section 
A critical section is a region defined as critical to the parallelization of code execution. The term is used to define code  sections that need to be executed in isolation with respect to other code in the program.

This is a common fundamental concept. These sections of code need to be protected by a synchronization technique as they can create  race conditions.

 Deadlock 
A deadlock is said to happen whenever there is a lock operation that results in a never-ending waiting cycle among concurrent threads.

 Synchronization 
Except when used to guarantee the correct execution of a parallel computation, synchronization is an overhead. Attempt to keep it to a minimum by taking advantage of the thread's local storage or by using exclusive memory locations.

 Computation granularity 
Computation granularity is loosely defined as the amount of computation performed before any synchronization is needed. The longer the time between synchronizations, the less granularity the computation will have. When dealing with the requirements for parallelism, it will mean being easier to scale to an increased number of threads and having lower overhead costs. A high level of granularity can mean that any benefit from using threads will be lost due to the requirements of synchronization and general thread overhead.

 Mutex 
Mutex is an abbreviation for mutual exclusion. It relies on a synchronization facility supplied by the operating system (not the CPU). Since this system objects can only be owned by a single thread at any given time, the mutex object facilitates protection against data races and allows for thread-safe synchronization of data between threads. By calling one of the lock functions, the thread obtains ownership of a mutex object, it then relinquishes ownership by calling the corresponding unlock function. Mutexes can be either recursive or non-recursive, and may grant simultaneous ownership to one or many threads.

 Semaphore 
A semaphore is a yielding synchronization object that can be used to synchronize several threads. This is the most commonly used method for synchronization

 Spinlock 
Spinlocks are busy-wait synchronization objects, used as a substitute for Mutexes. They are an implementation of inter-thread locking using machine dependent assembly instructions (such as test-and-set) where a thread simply waits (spins) in a loop that repeatedly checks if the lock becomes available (busy wait). This is why spinlocks perform better if locked for a short period of time. They are never used on single-CPU machines.

 Threads 
Threads are by definition a coding construct and part of a program that enable it to fork (or split) itself into two or more simultaneously (or pseudo-simultaneously) running tasks. Threads use pre-emptive multi-tasking. 

The thread is the basic unit (the smallest piece of code) to which the operating system can allocate a distinct processor time (schedule) for execution. This means that, threads in reality, don't run concurrently but in sequence on any single core system.  Threads often depend on the OS thread scheduler to preempt a busy thread and resume another thread.

The thread today is not only a key concurrency model supported by most if not all modern computers, programming languages, and operating systems but is itself at the core of hardware evolution, such as symmetric multi-processors, understanding threads is now a necessity to all programmers.

The order of execution of the threads is controlled by the process scheduler of the OS, it is non-deterministic. The only control available to the programmer is in attributing a priority to the thread but never assume a particular order of execution.

 User Interface Thread 
This type of distinction is reserved to indicate that the particular thread implements a message map to respond to events and messages generated by user inputs as he interacts with the application. This is especially common when working with the Windows platform (Win32 API) because of the way it implements message pumps.

 Worker Thread 
This distinction serves to specify threads that do not directly depend or are part of the graphical user interface of the application, and run concurrently with the main execution thread.

 Thread local storage (TLS) 
The residence of thread local variables, a thread dedicated section of the global memory. Each thread (or fiber) will receive its own stack space, residing in a different memory location. This will consist of both reserved and initially committed memory. That is freed when the thread exits but will not be freed if the thread is terminated by other means.

Since all threads in a process share the same address space, it makes data in a static or global variable to be normally located at the same memory location, when referred to by threads from the same process. It is important for software to take in consideration hardware cache coherence. For instance in multiprocessor environments, each processor has a local cache. If threads on different processors modify variables residing on the same cache line, this will invalidate that cache line, forcing a cache update, hurting performance. This is referred to as false sharing.

This type of storage is indicated for variables that store temporary or even partial results, since condensing the needed synchronization of the partial results in as fewer and infrequent instances possible will contribute to the reduction of synchronization overhead.

 Thread Synchronization 
The synchronization can be defined in several steps the first is the process lock, where a process is made to halt execution due to find a protected resource locked, there is a cost for locking especially if the lock lasts for too long.

Obviously there is a performance hit if any synchronization mechanism is heavily used. Because they are an expensive operation, in certain cases, increasing the use of TLSs instead of relying only on shared data structures will reduce the need for synchronization.

Critical Section

Suspend and Resume

Synchronizing on Objects

Cooperative vs. Preemptive Threading

Thread pool
A simple thread pool. The task queue has many waiting tasks (blue circles). When a thread opens up in the queue (green box with dotted circle) a task comes off the queue and the open thread executes it (red circles in green boxes). The completed task then "leaves" the thread pool and joins the completed tasks list (yellow circles)..

 Fibers 
A fiber is a particularly lightweight thread of execution. Like threads, fibers share address space. However, fibers use co-operative multi-tasking, fibers yield themselves to run another fiber while executing.

Operating system support
Less support from the operating system is needed for fibers than for threads. They can be implemented in modern Unix systems using the library functions getcontext, setcontext and swapcontext in ucontext.h, as in GNU Portable Threads.

On Microsoft Windows, fibers are created using the ConvertThreadToFiber and CreateFiber calls; a fiber that is currently suspended may be resumed in any thread. Fiber-local storage, analogous to thread-local storage, may be used to create unique copies of variables.

Symbian OS uses a similar concept to fibers in its Active Scheduler. An Active object (Symbian OS) contains one fiber to be executed by the Active Scheduler when one of several outstanding asynchronous calls complete. Several Active objects can be waiting to execute (based on priority) and each one must restrict is own execution time.

 Exploiting parallelism 
Most of the parallel architecture research was done in the 1960s and 1970s, providing solutions for problems that only today are reaching general awareness. As the need of concurrent programming increases, mostly due to today's hardware evolution, we as programmers are pressed to implement programming models that ease the complicated process of dealing with the old thread model in a way it preserves development time by abstracting the problem. 

 OpenMP 
Chart of OpenMP constructs.

 Software Internationalization 
Internationalization and localization refer to how computer software is adapted for other locations, nations or cultures. This means specifically those that are non-native to the programmer(s) or the primary user group

In specific, internationalization deals with the process of designing a software application in a way that it can be configured or adapted to work with various languages and regions without heavy changes to the code base. On the other hand localization deals with the process of enabling the configuration or auto adaptation of the software to a specific region, timezone or language by adding locale-specific components and text translation.

Software developers must understand the intricacies of internationalization since they write the actual underlying code. How well they use established services to achieve mission objectives determines the overall success of the project. At a fundamental level, code and feature design affect how a product is translated and customized. Therefore, software developers need to understand key localization concepts.

 Text encoding 
Text, in particular the characters are used to generate readable text consists on the use of a character encoding scheme that pairs a sequence of characters from a given character set (sometimes referred to as code page) with something else, such as a sequence of natural numbers, octets or electrical pulses, in order to facilitate the use of its digital representation. 

A easy to understand example would be Morse code, which encodes letters of the Latin alphabet as series of long and short depressions of a telegraph key; this is similar to how ASCII, encodes letters, numerals, and other symbols, as integers.

 Text and data 
Probably the most important use for a byte is holding a character code. Characters typed at the keyboard, displayed on the screen, and printed on the printer all have numeric values. To allow it to communicate with the rest of the world, the IBM PC uses a variant of the ASCII character set. There are 128 defined codes in the ASCII character set. IBM uses the remaining 128 possible values for extended character codes including European characters, graphic symbols, Greek letters, and math symbols.

In earlier days of computing, the introduction of coded character sets such as ASCII (1963) and EBCDIC (1964) began the process of standardization. The limitations of such sets soon became apparent, and a number of ad-hoc methods developed to extend them. The need to support multiple writing systems (Languages), including the CJK family of East Asian scripts, required support for a far larger number of characters and demanded a systematic approach to character encoding rather than the previous ad hoc approaches.

 What's this about UNICODE? 
Unicode is an industry standard whose goal is to provide the means by which text of all forms and languages can be encoded for use by computers. Unicode 6.1 was released in January 2012 and is the current version. It currently comprises over 109,000 characters from 93 scripts. Since Unicode is just a standard that assigns numbers to characters, there also needs to be methods for encoding these numbers as bytes. The three most common character encodings are UTF-8, UTF-16, and UTF-32, of which UTF-8 is by far the most frequently used.

In the Unicode standard, planes are groups of numerical values (code points) that point to specific characters. Unicode code points are logically divided into 17 planes, each with 65,536 (= 2¹⁶) code points. Planes are identified by the numbers 0 to 16_decimal, which corresponds with the possible values 00-10_hexadecimal of the first two positions in six position format (hhhhhh). As of version 6.1, six of these planes have assigned code points (characters), and are named.

Plane 0 - Basic Multilingual Plane (BMP)

Plane 1 - Supplementary Multilingual Plane (SMP)

Plane 2 - Supplementary Ideographic Plane (SIP)

Planes 3–13 - Unassigned

Plane 14 - Supplementary Special-purpose Plane (SSP)

Planes 15–16 - Supplementary Private Use Area (S PUA A/B)

 BMP and SMP 

BMP
SMP

0000–0FFF 8000–8FFF 10000–10FFF 18000-18FFF

1000–1FFF 9000–9FFF 11000–11FFF 19000-19FFF

2000–2FFF A000–AFFF 12000–12FFF 1A000-1AFFF

3000–3FFF B000–BFFF 13000–13FFF 1B000-1BFFF

4000–4FFF C000–CFFF 14000-14FFF 1C000-1CFFF

5000–5FFF D000–DFFF 15000-15FFF 1D000–1DFFF

6000–6FFF E000–EFFF 16000–16FFF 1E000–1EFFF

7000–7FFF F000–FFFF 17000-17FFF 1F000–1FFFF

 ISP and SSP 

SIP
SSP

20000–20FFF 28000–28FFF E0000–E0FFF

21000–21FFF 29000–29FFF  

22000–22FFF 2A000–2AFFF  

23000–23FFF 2B000–2BFFF  

24000–24FFF    

25000–25FFF    

26000–26FFF    

27000–27FFF 2F000–2FFFF  

 PUA 

PUA

F0000–F0FFF F8000–F8FFF 100000–100FFF 108000–108FFF

F1000–F1FFF F9000–F9FFF 101000–101FFF 109000–109FFF

F2000–F2FFF FA000–FAFFF 102000–102FFF 10A000–10AFFF

F3000–F3FFF FB000–FBFFF 103000–103FFF 10B000–10BFFF

F4000–F4FFF FC000–FCFFF 104000–104FFF 10C000–10CFFF

F5000–F5FFF FD000–FDFFF 105000–105FFF 10D000–10DFFF

F6000–F6FFF FE000–FEFFF 106000–106FFF 10E000–10EFFF

F7000–F7FFF FF000–FFFFF 107000–107FFF 10F000–10FFFF

Currently, about ten percent of the potential space is used. Furthermore, ranges of characters have been tentatively mapped out for every current and ancient writing system (script) the Unicode consortium has been able to identify. While Unicode may eventually need to use another of the spare 11 planes for ideographic characters, other planes remain. Even if previously unknown scripts with tens of thousands of characters are discovered, the limit of 1,114,112 code points is unlikely to be reached in the near future. The Unicode consortium has stated that limit will never be changed.

The odd-looking limit (it is not a power of 2), is not due to UTF-8, which was designed with a limit of 2³¹ code points (32768 planes), and can encode 2²¹ code points (32 planes) even if limited to 4 bytes but is due to the design of UTF-16. In UTF-16 a "surrogate pair" of two 16-bit words is used to encode 2²⁰ code points 1 to 16, in addition to the use of single words to encode plane 0.

 UTF-8 
UTF-8 is a variable-length encoding of Unicode, using from 1 to 4 bytes for each character. It was designed for compatibility with ASCII, and as such, single-byte values represent the same character in UTF-8 as they do in ASCII. Because a UTF-8 stream doesn't contain '\0's, you may use it directly in your existing C++ code without any porting (except when counting the 'actual' number of character in it).

 UTF-16 
UTF-16 is also variable-length, but works in 16 bit units instead of 8, so each character is represented by either 2 or 4 bytes. This means that it is not compatible with ASCII.

 UTF-32 
Unlike the previous two encodings, UTF-32 is not variable-length: every character is represented by exactly 32-bits. This makes encoding and decoding easier, because the 4-byte value maps directly to the Unicode code space. The disadvantage is in space efficiency, as each character takes 4 bytes, no matter what it is.

 Optimizations 
Optimization can be regarded as a directed effort to increase the performance of something, an important concept in engineering, in particular, the case of Software engineering that we are covering. We will deal with specific computational tasks and best practices to reduce resources utilizations, not only of system resources but also of programmers and users, all based in optimal solutions evolved from the empirical validating of hypothesis and logical steps.

All optimization steps taken should have as a goal the reduction of requirements and the promotion of the program objectives. Any claims can only be substantiated by profiling the given problem and the applied solution. Without profiling any optimization is moot.

Optimization is often a topic of discussion among programmers and not all conclusions may be consensual, since they are very closely related to the goals, the programmer experience, and dependent of specific setups. The level of optimization will mostly depend directly from actions and decisions the programmer makes. Those can be simple things, from basic coding practices to the selection of the tools one choses to use to create the program.  Even selecting the right compiler will have an impact.  A good optimizing compiler permits the programmer to define his aspirations for the optimized outcome; how good the compiler is at optimizing depends on the level of satisfaction the programmer gets from the resulting compilation. 

 Code 
One of the safest ways of optimization is to reduce complexity, ease organization and structure and at the same time evading code bloat. This requires the capacity to plan without losing track of future needs, in fact it is a compromise the programmer makes between a multitude of factors. 

Code optimization techniques, fall into the categories of:
 High Level Optimization
 Algorithmic Optimization (Mathematical Analysis)
 Simplification

 Low Level Optimization
 Loop Unrolling
 Strength Reduction
 Duff's Device
 Clean Loops

 KISS 
The "keep it simple, stupid" (KISS) principle, calls for giving simplicity a high priority in development. It is very similar to a maxim from Albert Einstein's that states, "everything should be made as simple as possible, but no simpler.", the difficulty for many adopters have is to determine what level of simplicity should be maintained. In any case, analysis of basic and simpler system is always easier, removing complexity will also open the door for code reutilization and a more generic approach to tasks and problems.

 Code cleanup 
Most of the benefits of a code cleanup should be evident to the experienced programmer, they become a second nature due to the adoption of good programming style guidelines. But as in any human activity, errors will occur and exceptions made, so, in this section we will try to remember the small changes that can have an impact on the optimization of your code. 

the use of virtual member functions
Remember the cost on performance of virtual members functions (covered when introducing the virtual keyword). At the time optimization becomes an issue most project design change regarding optimization will not be possible, but artifacts may remain to be cleaned up. Guaranteeing that no superfluous use of virtual (like in the leaf nodes of your class/structure inheritance trees), will permit other optimizations to occur (i.e.: compiler optimized inline).

 The right data in the right container 
One of the top bottleneck on today's systems is dealing with memory caches, be it CPU cache or the physical memory resources, even if paging problems are becoming increasingly rare. Since the data (and the load level) a program will handle is highly predictable at the design level, the better optimizations still fall to the programmer.

One should store the appropriate data structure in the appropriate container, prefer storing pointers to objects rather than the objects themselves, use "smart" pointers (see the Boost library) and don't attempt to store auto_ptr<> in STL containers, it is not allowed by the Standard, but some implementations are known to incorrectly allow it.

Avoid removing and inserting elements in the middle of a container, doing it at the end of the container has less overhead. Use STL containers when the number of objects is unknown; use static array or buffer when it is known. This requires the 
understanding of not only each container, but its O(x) guarantees.

Take as an example the STL containers on the issue of using (myContainer.empty()) versus (myContainer.size() == 0), it is important to understand that depending on the container type or its implementation, the size member function might have to count the number of objects before comparing it to zero. This is very common with list type containers. 

While the STL attempts to provides optimal solutions to general cases, if performance does not match your requirements think about writing your own optimal solution for your case, maybe a custom container (probably based on vector) that does not call individual object destructors and uses custom allocators that avoid the delete time overhead. 

Using pre-allocation of memory can provide some speed gains and be as simple remember to use the STL vector<T>::reserve() if permitted.  Optimize the use system's memory and the target hardware.  In today's systems, with virtual memory, threads and multiple-cores (each with its own cache) where I/O operations on the main memory and the amount of time spent moving it around, can slow things down.  This can become a performance bottleneck.  Instead opt for array-based data structures (cache-coherent data structures), like the STL vector, because data is stored contiguously in memory, over pointer-linked data structures as in linked lists. This will avoid "death by swapping", as the program needs to access highly fragmented data, and will even help the memory pre-fetch that most modern processors do today.

Whenever possible avoid returning containers by value, pass containers by reference.

 Consider security costs 
Security always has a cost, even in programming. For any algorithm, adding checks, will result in increase the number of steps it takes to finish. As languages get more complex and abstract, understanding all the finer details (and remembering them) increases the time needed to obtain the required experience. Sadly, most of the steps taken by some of the implementors of the C++ language lack visibility to the programmer, and since they are outside of the standard language, aren't often learned. Remember to familiarize yourself with any extensions or particularities of the C++ implementation you are using.

As a language that puts the power of decision into the programmer's hands, C++ provides several instances where a similar result can be achieved by similar but distinct means. Understanding the sometimes subtle differences is important. For instance, when deciding the needed requirements in accessing members of a std::vector, you can chose [], at(), or an iterator. All have similar results but with distinct performance costs and security considerations.

 Code reutilization 
Optimization is also reflected on the effectiveness of a code. If you can use an already existing code base/framework that a considerable number of programmers have access to, you can expect it to be less buggy and optimized to solve your particular need.

Some of these code repositories are available to programmers as libraries. Be careful to consider dependencies and check how implementation is done: if used without considerations this can also lead to code bloat and increased memory footprint, as well as decrease the portability of the code. We will take a close look at them in the Libraries Section of the book.

To increase code reutilization you will probably fragment the code in smaller sections, files or code, remember to equate that more files and overall complexity also increases compile time.

 Function and algorithmic optimizations 
When creating a function or an algorithm to address a specific problem sometimes we are dealing with mathematical structures that are specifically indicated to be optimized by established methods of mathematical minimization, this falls into the specific field of Engineering analysis for optimization.

 Use of inline 
As seen before when examining the inline keyword, it allows the definition of an inline type of function, that works similarly to loop unwinding for increasing code performance. A non-inline function requires a call instruction, several instructions to create a stack frame, and then several more instructions to destroy the stack frame and return from the function. By copying the body of the function instead of making a call, the size of the machine code increases, but the execution time decreases. 

In addition to using the inline keyword to declare an inline function, optimizing compilers may decide to make other functions inline as well (see Compiler optimizations section).

 ASM 
If portability is not a problem and you are proficient with assembler you can use it to optimize computational bottlenecks, even looking at the output of a disassembler will often help looking for ways to improve it. Using ASM in your code brings to the table some other problems (maintainability for instance) so use it at a last resort in you optimization process, and if you use it be sure to document what you have done well.

The x86 Disassembly Wikibook provides some optimization examples using x86 ASM code.

 Reduction of compile time 
Some projects may take a long time to compile. To reduce the time it takes to finish compiling the first step is to check if you have the any Hardware deficiencies. You may be low in resources like memory or just have a slow CPU, even having your HD with a high level of fragmentation can increase compile time.

On the other side, problems may not be due to hardware limitations but in the tools you use, check if you are using the right tools for the job at hand, see if you have the latest version, or if do, if that is what is causing trouble, some incompatibilities may result from updates. In compilers new is always better, but you should check first what has changed and if it serves your purposes.

Experience tells that most likely if you are suffering from slow compile times, the program you are trying to compile was probably poorly designed, check the structure of object dependencies, the includes and take some the time to structure your own code to minimize re-compilation after changes if the compile time justifies it.

Use pre-compiled headers and external header guards this will reduce the work done by the compiler.

 Compiler optimizations 
Compiler optimization is the process of tuning, mostly automatically, the output of a compiler in an attempt to improve the operations the programmer has requested, so to minimize or maximize some attribute of an compiled program while ensuring the result is identical. By rilling in the compiler optimization programmers can write more intuitive code, and still have them execute in a reasonably fast way, for instance skipping the use of pre-increment/decrement operators.

Generally speaking, optimizations are not, and can not be, defined on the C++ standard. The standard sets rules and best practices that dictate a normalization of inputs and outputs. The C++ standard itself permits some latitude on how compilers perform their task since some sections are marked as implementation dependent but generally a base line is established, even so some vendors/implementors do creep in some singular characteristic apparently for security and optimization benefits.

One notion that is good to keep in mind is that there is not a perfect C++ compiler, but most recent compilers will do several simple optimizations by default, that attempt to abstract and take advantage of existing deeper hardware optimizations or specific characteristics of the target platform, most of these optimizations are almost always welcomed but it is up to the programmer still to have and idea of what is going on and if indeed they are beneficial. As a result, it is highly recommended to examine your compiler documentation on how it operates and what optimizations are under the programmer's control, just because a compiler can make some optimization in theory does not mean that it will or even that it will result in an optimization.   

The most common compiler optimizations options available to the programmer fall into three categories:
Speed; improving the runtime performance of the generated object code. This is the most common optimization
Space; reducing the size of the generated object code
Safety; reducing the possibility of data structures becoming corrupted (for example, ensuring that an illegal array element is not written to)

Unfortunately, many "speed" optimizations make the code larger, and many "space" optimizations make the code slower -- this is known as the space-time tradeoff.

 auto-inline 
Auto-inlining is similar to implicit inline. Inlining can be an optimization, or a pessimization depending on the code and optimization options selected.

 Making use of extended instructions sets 

 GPU 

 Run time 
As we have seen before runtime is the duration of a program execution, from beginning to termination. This is were all resources needed to run the compiled code are allocated and hopefully released, this is the final objective of any program to be executed, as such it should be the target for ultimate optimizations.   

 Memory footprint 
In the past computer memory has been expensive and technologically limited in size, and scarce resource for programmers.  Large amounts of ingenuity was spent in implement complex programs and process huge amounts of data using as little as possible of this resource.  Today, modern systems contain enough memory for most usages but capacity demands and expectations have increased as well; as such, techniques to minimize memory usage may still be essential and in fact operational performance has gained a new momentum with the increasing importance of mobile computing.

Measuring the memory usage of a program is difficult and time consuming, and the more complex the program is the harder it becomes to get good metrics. One other side of the problem is that there are no standard benchmarks (not all memory use is equal) or practices to deal with the problem beyond the most basic and generic considerations.  

Remember to use swap() on std::vector (or deque).
When attempting to reduce reduce (or zero) the size of a vector or deque using the swap(), on a standard container of that type, will guarantee that the memory is released and no overhead buffer for growth is used. It will also avoid the fallacy of using erase() or reserve() that will not reduce the memory footprint. 

 Lazy initialization 
It is always needed to maintain the balance between the performance of the system and the resource consumption. 
Lazy instantiation is one memory conservation mechanism, by which the object initialization is deferred until it is required.

Look at the following example:

#include <iostream> 

class Wheel {
        int speed;
    public:
        int getSpeed(){
            return speed;
        }
        void setSpeed(int speed){
            this->speed = speed;
        }
};

class Car{
    private:
        Wheel wheel;
    public:
        int getCarSpeed(){
            return wheel.getSpeed();
        }
        char const* getName(){
            return "My Car is a Super fast car";
        }
};

int main(){
    Car myCar;
    std::cout << myCar.getName() << std::endl;
}

Instantiation of class Car by default instantiates the class Wheel. The purpose of the whole class is to just print the name of the car.  Since the instance wheel doesn't serve any purpose, initializing it is a complete resource waste.

It is better to defer the instantiation of the un-required class until it is needed. Modify the above class Car as follows:

class Car{
    private:
        Wheel *wheel;
    public:
        Car() {
            wheel=NULL; // a better place would be in the class constructor initialization list
        }
        ~Car() {
            delete wheel;
        }
        int getCarSpeed(){
            if (wheel == NULL) {
                wheel = new Wheel(); 
            }
            return wheel->getSpeed();
        }
        char const* getName(){
            return "My Car is a Super fast car";
        }
};

Now the Wheel will be instantiated only when the member function getCarSpeed() is called.

 Parallelization 
As seen when examining threads, they can be a "simple" form of taking advantage of hardware resources and optimize the speed performance of a program. When dealing with thread you should remember that it has a cost in complexity, memory and if done wrong when synchronization is required it can even reduce the speed performance, if the design permits it is best to allow threads to run as unencumbered as possible.

 I/O reads and writes 
A Schematic of a Queue System

 Profiling 
Profiling is a form of dynamic program analysis (as opposed to static code analysis), consists in the study of program's behavior using information gathered as the program executes. its purpose is usually to determine which sections of a program to optimize. Mostly by determining which parts of a program are taking most of the execution time, causing bottleneck on accessing resources or the level of access to those resources.

Global clock execution time should be the bottom line when comparing applications performance. Select your algorithms by examining the asymptotic order of executions, as in a parallel setup they will continue to give the best performance. In the case you find an hotspot that can not be parallelized, even after examining higher levels on the call stack, then you should attempt to find a slower but parallelizable algorithm.

branch-prediction profiler

call-graph generating cache profiler

line-by-line profiling

heap profiler

 Profiler 
Free Profiling tools

Valgrind ( http://valgrind.org/ ) an instrumentation framework for building dynamic analysis tools. Includes a cache and branch-prediction profiler, a call-graph generating cache profiler, and a heap profiler. It runs on the following platforms: X86/Linux, AMD64/Linux, PPC32/Linux, PPC64/Linux, and X86/Darwin (Mac OS X). Open Source under the GNU General Public License, version 2.
GNU gprof ( http://www.gnu.org/software/binutils/ ) a profiler tool. The program was first introduced on the SIGPLAN Symposium on Compiler Construction in 1982, and is now part of the binutils that are available in mostly all flavors of UNIX. It is capable of monitoring time spent in functions (or even source code lines) and calls to/from them. Open Source  under the GNU General Public License.
Linux perf ( http://perf.wiki.kernel.org/ ) is a profiling tool which is part of the Linux kernel. It operates by sampling.

Commercial Profiling tools

Deleaker (http://deleaker.com/ ) a tool and Visual Studio extension to find memory leaks, handles, GDI and USER objects leaks. For Windows, supports x86 / x64. It is based on hooks and doesn't require code instrumentation.

 Further reading 

 Optimizing C++

 Modeling Tools 
Long gone are the days when you had to do all software designing planning with pencil and paper, it's known that bad design can impact the quality and maintainability of products, affecting time to market and long term profitability of a project.

The solution seems to be CASE and modeling tools which improve the design quality and help to implement design patterns with ease that in turn help to improve design quality, auto documentation and the shortening the development life cycles.

 UML (Unified Modeling Language) 
Since the late 80s and early 90s, the software engineering industry as a whole was in need of standardization, with the emergence and proliferation of many new competing software design methodologies, concepts, notations, terminologies, processes, and cultures associated with them, the need for unification was self evident by the sheer number of parallel developments. A need for a common ground on the representation of software design was badly needed and to archive it a standardization of  geometrical figures, colors, and descriptions.

The UML (Unified Modeling Language) was specifically created to serve this purpose and integrates the concepts of Booch (Grady Booch is one of the original developers of UML and is recognized for his innovative work on software architecture, modeling, and software engineering processes), OMT, OOSE, Class-Relation and OOramand by fusing them into a single, common and widely usable modeling language tried to be the unifying force, introducing a standard notation that was designed to transcend programming languages, operating systems, application domains and the needed underlying semantics with which programmers could describe and communicate. With its adoption in November 1997 by the OMG (Object Management Group) and its support it has become an industry standard. Since then OMG has called for information on object-oriented methodologies, that might create a rigorous software modeling language.  Many industry leaders had responded in earnest to help create the standard, the last version of UML (v2.0) was released in 2004.

UML is still widely used by the software industry and engineering community. In later days a new awareness has emerged (commonly called UML fever) that UML per se has limitations and is not a good tool for all jobs. Careful study on how and why it is used is needed to make it useful.

 Chapter Summary 
Resource Acquisition Is Initialization (RAII) 
Garbage Collection (GC) 
Design patterns  - Creational, Structural and Behavioral patterns. 
Libraries  - APIs vs Frameworks and Static and dynamic libraries.
Boost library 
Optimizing your programs 
Cross-platform development 
Win32 (aka WinAPI)  - including Win32 wrappers.
Cross-platform wrappers 
Multitasking 
Software internationalization 
Text encoding 
Unified Modeling Language (UML) 

 Appendix A: Internal References 
List of Keywords
[included next to The Compiler]
List of Standard Headers
[included in The preprocessor Chapter (next to the #include keyword)]
Table of Preprocessors
[included in The preprocessor Chapter]
Table of Operators
[included in the introduction to Operators]
Table of Data Types
[included in the introduction to Variables]

To prevent duplication of content references are removed you may find them on the given locations.

 Appendix B: External References 
Reference Sites

http://www.research.att.com/~bs/C++.html
Bjarne Stroustrup's C++ page.

http://www.open-std.org/jtc1/sc22/wg21/docs/library_technical_report.html 
C++ Standard Library Technical Report.

 http://www.open-std.org/jtc1/sc22/wg21/
C++ Standards Committee's official website, previously at http://anubis.dkuug.dk/jtc1/sc22/wg21/ , ISO/IEC JTC1/SC22/WG21 is the international standardization working group for the programming language C++.

http://www.sgi.com/tech/stl/index.html
The SGI Standard Template Library Programmer's Guide.

Compilers and IDEs
Free or with free versions

http://gcc.gnu.org/
GCC , the GNU Compiler Collection, which includes a compiler for C++.

http://www.mingw.org/
MinGW, a Win32 port of the GNU Compiler Collection and toolset designed for compatibility with the host OS.

http://sourceware.cygnus.com/cygwin
Cygwin, a Win32 port of GCC and GNU Utils designed to simulate a Unix-style environment.  

http://www.microsoft.com/visualstudio/en-us/products/2010-editions/visual-cpp-express
The Microsoft Visual C++ 2010 Express Edition. It also allows you to build applications that target the Common Language Runtime (CLR). You should read their license for yourself to make sure. MFC, ATL and the Windows headers/libraries are not included with this version. To create Windows programs, you will need to download the Microsoft Platform SDK as well (for the Windows headers and import libraries).

http://hpgcc.sourceforge.net/
 HP-GCC comprises the GNU C compiler targeted at the ARM processor of ARM-based HP calculators (like the HP49g+), HP specific libraries, a tool (ELF2HP) that converts the gcc produced binary to the appropriate format for the HP calculator, and an emulator (ARM Toolbox/ARM Launcher) that lets you execute ARM programs on your computer. At present, only a Windows version is available, but the site says that Linux and Mac OS X versions are "on the way".

http://www.ultimatepp.org/
 Ultimate++ a C++ cross-platform and Open Source rapid application development suite focused on programmers productivity. It includes a set of libraries (GUI, SQL, etc..), and an integrated development environment.
The IDE can work with GCC, MinGW and Visual C++ 7.1 or 8.0 compilers (including free Visual C++ Toolkit 2003 and Visual C++ 2005 Express Edition) and contains a full featured debugger.

http://www.codelite.org/
 CodeLite, open-source under the terms of the GPL license, cross platform IDE for the C/C++ programming languages (tested on Windows XP SP3, (K)Ubuntu 8.04, and Mac OSX 10.5.2).

http://www.codeblocks.org/
 Code::Blocks, C++ cross-platform and Open Source (GPL2) IDE, runs on Linux or Windows (uses wxWidgets), supports GCC (MingW/Linux GCC), MSVC++, Digital Mars, Borland C++ 5.5 and Open Watcom compilers. Offers syntax highlighting (customizable and extensible), code folding, tabbed interface, code completion, class browser, smart indent and a To-do list management with different users and more.

http://www.bloodshed.net/devcpp.html
Dev-C++, a free IDE including a distribution of MinGW. Delphi and C source code available.

http://wxdsgn.sourceforge.net/
wxDev-C++, an IDE/RAD tool resulting from extending Dev-C++. With all the features of the previous plus others. Uses GCC for the compiler, and adds an IDE and a form designer supporting wxWidgets.

http://quincy.codecutter.org/
Quincy 2005, a simple IDE for C and C++ under Windows. Installs the MinGW compiler and GDB debugger. Designed as a friendly learning environment. Public domain C++ source code.

http://www.delorie.com/djgpp/
Djgpp, a free compiler for C, C++, Forth, Pascal and more including C sources.  Runs under DOS.

http://www.digitalmars.com
Digital Mars, a free C and C++ Compiler for DOS, Win & NT by the author of Zortech C++.

http://developer.apple.com/tools/mpw-tools/
 Macintosh Programmer's Workshop (MPW). Same software and documentation as the "Tool Chest:Development Kits:MPW etc." folder on the August 2001 Developer CD.

http://www.openwatcom.org/
OpenWatcom, the Open Watcom is a joint effort between SciTech Software, Sybase®, and a select team of developers, which will bring the Sybase Watcom C, C++ and Fortran compiler products to the Open Source community.

http://msdn.microsoft.com/mobility/prodtechinfo/devtools/eVisualc/default.aspx
 Microsoft eMbedded Visual C++ allows you to develop for Windows CE. It includes an IDE, which includes an integrated debugger.

http://www.borland.com/products/downloads/download_cbuilder.html
 Borland C++Builder v5.5
http://www.eclipse.org/
 Eclipse, a multi-language IDE with support for C++ through the CDT plugin. It requires a GCC backend. There is a download specifically for C++ developers that does not include the Java libs.

Commercial

http://www.intel.com/software/products/compilers/
 Intel Compiler, a Intel® compilers. Compatible with the tools developers use, Intel compilers plug into popular development environments and feature source and binary compatibility with widely-used compilers. Every compiler purchase includes one year of Intel® Premier Support, providing updates, technical support and expertise for the Intel® architecture. [Intel CPUs ONLY]

http://comeaucomputing.com/
Comeau C/C++ Compiler. Available for purchase Comeau C/C++ supports Core C++03 language enhancements for all major and minor features of C++ and C, including export.

Misc. C++ Tools
Free or with a free version

http://www.stack.nl/~dimitri/doxygen/
Doxygen is a documentation system for C++, C, and other programming languages.

http://valgrind.kde.org/
Valgrind, a system for debugging and profiling applications at runtime. The system runs on nearly any x86 linux (sorry, no amd64 yet). It can detect memory leaks, illegal memory access, double deletes, cache misses, code coverage and much, much more.

http://msdn.microsoft.com/visualc/vctoolkit2003/
Microsoft Visual C++ Toolkit 2003, This is a free optimizing compiler provided by Microsoft that developers can use to develop and compile applications in C or C++. It is the same compiler that ships with the professional edition of Visual Studio. It ships with the standard library and sample code.

http://ccbuild.sourceforge.net/?page=home
ccbuild, a C++ source scanning build utility for code distributed over directories. Like a dynamic Makefile, ccbuild finds all programs in the current directory (containing "int main") and builds them. For this, it reads the C++ sources and looks at all local and global includes. All C++ files surrounding local includes are considered objects for the main program. The global includes lead to extra compiler arguments using a configuration file. Next to running g++ it can create simple Makefiles, A-A-P files, and graph dependencies using DOT (Graphviz) graphs. (Linux only)

Libraries
Free or with free versions

http://www.boost.org/
The Boost web site.  Boost is a large collection of high-quality libraries for C++, some of which are likely to be included in future C++ standards.

http://www.samblackburn.com/wfc/index.html/
The WFC (Win32 Foundation Classes) site.

http://sourceforge.net/projects/wtl/
The WTL site.

http://www.oonumerics.org/blitz/
Blitz++ is a C++ class library for scientific computing which provides performance on par with Fortran 77/90. It uses template techniques to achieve high performance. The current versions provide dense arrays and vectors, random number generators, and small vectors and matrices. Blitz++ is distributed freely under an open source license, and contributions to the library are welcomed.

http://www.bdsoft.com/tools/stlfilt.html
STLFilt is a STL Error Message Decryptor for C++. It simplifies and/or reformats long-winded C++ error and warning messages, with a focus on STL-related diagnostics.

http://www.swox.com/gmp/
GMP is a free library for arbitrary precision arithmetic, operating on signed integers, rational numbers, and floating point numbers. There is no practical limit to the precision except the ones implied by the available memory in the machine GMP runs on.

http://www.cryptopp.com/
Crypto++ Library is a free C++ class library of cryptographic schemes.

http://alleg.sourceforge.net/
Allegro is a game programming library for C/C++ developers distributed freely, supporting the following platforms: DOS, Unix (Linux, FreeBSD, Irix, Solaris, Darwin), Windows, QNX, BeOS and MacOS X. It provides many functions for graphics, sounds, player input (keyboard, mouse and joystick) and timers. It also provides fixed and floating point mathematical functions, 3d functions, file management functions, compressed datafile and a GUI.

http://fltk.org/
FLTK (pronounced "fulltick") is a cross-platform C++ GUI toolkit for UNIX®/Linux® (X11), Microsoft® Windows®, and MacOS® X. FLTK provides modern GUI functionality without the bloat and supports 3D graphics via OpenGL® and its built-in GLUT emulation. FLTK is designed to be small and modular enough to be statically linked, but works fine as a shared library. FLTK also includes an excellent UI builder called FLUID that can be used to create applications in minutes.

http://www.libsdl.org/
Simple DirectMedia Layer is a cross-platform multimedia library for C/C++. It provides low-level acces to 2D frame-buffer and hardware accelerated 3D graphics(using OpenGL), audio, threads, timers,user input and event handling. Other features are available through "plug-in libraries". Linux, Windows, BeOS, MacOS Classic, MacOS X, FreeBSD, OpenBSD, BSD/OS, Solaris, IRIX, and QNX are supported and there's some unofficial support for other platforms. SDL is available under the GNU LGPL license.

http://www.hpcfactor.com/developer/
 SDKs for older platforms and from third parties. Includes a redistributable that contains the MFC library's for Windows CE 1, 2, HPC Pro, Palm-Size PC 1.2, HPC2000 and a limited number from Windows CE 4.0.

http://qt.nokia.com
 Qt (pronounced "cute"), a multi-platform API that contains a UI toolkit as well as a core library. It is extremely modular, but to use it effectively, you should use at least UI+Core.

http://loki-lib.sourceforge.net/
 Loki is a C++ library which demonstrates and encourages the use of generic programming and design patterns. It was written to accompany the book entitled "Modern C++ Design." The library includes a parametrized smart pointer class, generalized functors, a multi-threading abstraction, and some help for important patterns. Open source released under the MIT license.

http://tinythread.sourceforge.net/
 TinyThread++, a light weight, portable C++ thread library that implements a subset of the C++0x standard, including the thread, mutex and condition_variable classes. Open source, released under the zlib/libpng License.

Commercial
http://pocoproject.org/
Poco C++ Libraries. Written in modern, standard ANSI C++, using the C++ Standard Library. Modular design, very few external dependencies, builds out-of-the-box. Good mix of "classic" object-oriented design with modern C++. Clean, easy-to-understand code, consistent coding style, comprehensive test suite.

C++ Coding Conventions
Source Code Formatting rules

http://www.cs.usyd.edu.au/~scilect/tpop/handouts/Style.htm
Kernighan and Ritchie (or K&R) style

http://www.nongnu.org/style-guide/
GNU Programmer's Style Guide

http://lxr.linux.no/source/Documentation/CodingStyle
Linux kernel coding style

Comprehensive Source Code Convention guidelines

http://quantlib.org/style.shtml
QuantLib Programming Style Guidelines

http://www.research.att.com/~bs/bs_faq2.html
Bjarne Stroustrup's C++ Style and Technique FAQ

http://www.artima.com/intv/goldilocks.html
The C++ Style Sweet Spot A Conversation with Bjarne Stroustrup, Part I by Bill Venners

http://developer.kde.org/documentation/other/binarycompatibility.html
KDE Binary Compatibility Issues With C++

https://developer.mozilla.org/en-US/docs/Mozilla/C%2B%2B_Portability_Guide
Mozilla C++ portability guide

http://www.chris-lott.org/resources/cstyle/Ellemtel-rules-mm.html
Programming in C++, Rules and Recommendations by FN/Mats Henricson and Erik Nyquist

http://www.chris-lott.org/resources/cstyle/Wildfire-C++Style.html
Wildfire C++ Programming Style With Rationale by Keith Gabryelski

http://www.kuro5hin.org/story/2002/5/9/205040/3918
Musings on Good C++ Style (Technology) by GoingWare

 http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml
 Google C++ Style Guide

https://www.securecoding.cert.org/confluence/pages/viewpage.action?pageId=637
CERT C++ Secure Coding Standard

 http://web.archive.org/web/20061230015340/http://www.research.att.com/~bs/JSF-AV-rules.pdf
 Joint Strike Fighter air vehicle: C++ coding standards 2005

 http://www.chris-lott.org/resources/cstyle/
 C and C++ Style Guides by Chris Lott, lists many popular C++ style guides.

 http://www.misra-cpp.org/
 MISRA C++: Guidelines for the use of the C++ language in critical systems published by The Motor Industry Software Reliability Association (MISRA) (based on a subset of C++).

 http://freeworld.thc.org/root/phun/unmaintain.html
A very funny satiric text that turns the tables on the issues concerning coding style by Roedy Green.

 Online C++ books, guides and general information 
 More C++ Idioms, covering modern C++ idioms.
 Windows Programming, a Wikibook on Windows API (C and VB Classic), MFC (C++), COM and creation of ActiveX modules.
 Optimizing C++, covering how C++ programmers can improve a program's performance. 
 Linux Applications Debugging Techniques, a hands-on guide to debugging applications under Linux.
 C++ In Action, by Bartosz Milewski
 Teach Yourself C++ in 21 Days, Second Edition
 More C++, by Tim Love, July 5, 2001
 Introduction to Object-Oriented Programming Using C++, by Peter Müller, 1997.
 C++ Programming for Scientists, by Roldan Pozo and Karin Remington
 C++ for Unix, a broken link, a quick reference, with C variations
 STL Quick Reference, probably by Pablo Halpern, 
 C++ A dialog, by Steve Heller
 Learning C++: An Index of Entry Points
 C++ Programming How-ToPDF, by Al Dev (Alavoor Vasudevan), 2001
 Think like a computer scientist: C++
 C++ Programming Tutorial for the beginners
References to other works that can be relevant to the topic:
 Kohl et al. 2004: C/C++ Reference at cppreference.com
 The C++ Annotations for C programmers, by Frank B. Brokken
 C / C++ Tutorials at pickatutorial.com, a collection of online C / C++ tutorials
 cplusplus.com, an open resource with various web discussion groups
 A web site of Scott Meyers, an expert on C++ software development. He wrote the best-selling Effective C++ series (Effective C++, More Effective C++, and Effective STL), wrote and designed Effective C++ CD
 Cprogramming.com, a web site designed to help you learn C or C++ and provide you with C and C++ programming resources.
 Misc. Books, News & Articles on C++, by orelily.com
 Frequently Asked Questions About Win32 Programming, from iseran.com
 CppHeresy at c2.com, guidelines about how to keep the C++ bits simple
 C++ FAQ at parashift.com, sometimes also called C++ FAQ Lite.
 Defective C++: a 2009 summary by Yossi Kreinin of the major defects he finds in the C++ programming language. (Related:  Particularities of the C programming language).
 The Boost C++ Libraries online book that introduces many Boost libraries in a tutorial style and complements the official documentation. Under a Creative Commons Attribution - NonCommercial - NoDerivatives 4.0 International License.

 Cplusplus Code Examples

 IRC 
#C at (irc://irc.tambov.ru)
C/C++ Channel (http://silversoft.net/) (Russian Channel)

#C++ at (irc://hub.ptnet.org)
C++ Channel (Portuguese Channel)

#C++ at (irc://irc.euirc.net)
C++ Channel (German Channel)

##C++ at (irc://irc.freenode.net)
C++ Channel

#c++newbie at (irc://irc.freenode.net)
Channel for those new to C++

#c++ at (irc://irc.dynastynet.net)
Channel on DynastyNet for discussing C++ topics.

 User Groups 
http://www.accu.org/
ACCU, formerly the Association for C and C++ Users, ACCU is a non-profit organization devoted to professionalism in programming at all levels. Although primarily focused on C and C++, have now interests in Java, C# and Python also.

 Newsgroups (NNTP) 
comp.std.c++ - FAQ
comp.lang.c++.leda
comp.lang.c++.moderated
comp.lang.c++
microsoft.public.vc.mfc
microsoft.public.vc.stl

 Blogs and Wikis 
http://www.codepedia.com/1/Cpp
a Wikipedia-like page with much code examples.

http://www.gnacademy.org/twiki/bin/view/CPP/TableOfContents%20GNAcademy.Org
TWiki C++ Web is a C++ wiki with GNU Free Documentation License

 http://cpp.wikia.com/
 Wikicities C++ is a multi-language C++ wiki (currently English and Polish).

 Mailing Lists 

http://www.oonumerics.org/mailman/listinfo.cgi/oon-list/
Object-Oriented Numerics List, forum for discussing scientific computing in object-oriented environments. An archive is available.

 Forums 
http://stackoverflow.com/questions/tagged/c%2b%2b
Stackoverflow is a knowledge sharing community including discussing C++ related topics.
Other (dead tree) books on C++
Introductory books
Thinking in C++, 2nd ed. Volume 1: Introduction to Standard C++ by Bruce Eckel, ISBN 0139798099 | ISBN-13: 978-0139798092. Available online and also as free downloadPDF.

Advanced topics
Thinking in C++, 2nd ed. Volume 2: Practical Programming by Bruce Eckel, 0139798099 | ISBN-13: 978-0139798092. Available online as free downloadPDF.
Effective C++ : 55 Specific Ways to Improve Your Programs and Designs, 3rd ed. by Scott Meyers, ISBN 0321334876

Reference books
C++ in a Nutshell by Ray Lischner, ISBN 059600298X

C++ Pocket Reference by Kyle Loudon, ISBN 0596004966

C++ FAQs by Marshall Cline, Greg Lomow, and Mike Girou, Addison-Wesley, 1999, ISBN 0-201-30983-1

 References 

Name	Size (bits)	Example
Bit	1	1
Nibble	4	0101
Byte	8	0000 0101
Word	16	0000 0000 0000 0101
Double Word	32	0000 0000 0000 0000 0000 0000 0000 0101

Type	Size in Bits	Comments	Alternate Names
Primitive Types
`char`	≥ 8	May or may not be signed, The choice is implementation dependent. The fundamental memory unit is the byte. A char is 8 bits or more, and at least big enough to contain UTF-8 or implementation's full character set, which ever is larger and any character encoding of 8 bits or less (e.g. ASCII). Logical and arithmetic operations outside the range 0 ←→ +127 may lack portability. All bits contribute to the value of the `char`, i.e. there are no "holes" or "padding" bits. a char will represent the same values as either signed char or unsigned char as defined by the implementation.	—
`signed char`	same as `char`	Characters stored like for type `char`. Can store integers in the range -128 to 127 portably^[1].	—
`unsigned` `char`	same as `char`	Characters stored like for type `char`. Can store integers in the range 0 to 255 portably.	—
`short`	≥ 16, ≥ size of `char`	Can store integers in the range -32767 ~ 32767 portably^[2]. Used to reduce memory usage (although the resulting executable may be larger and probably slower as compared to using `int`.	`short int`, `signed short`, `signed short int`
`unsigned` `short`	same as `short`	Can store integers in the range 0 ~ 65535 portably. Used to reduce memory usage (although the resulting executable may be larger and probably slower as compared to using `int`.	`unsigned` `short int`
`int`	≥ 16, ≥ size of `short`	Represents the "normal" size of data the processor deals with (the word-size); this is the integral data-type used normally. Can store integers in the range -32767 ~ 32767 portably^[2].	`signed`, `signed int`
`unsigned` `int`	same as `int`	Can store integers in the range 0 ~ 65535 portably.	`unsigned`
`long`	≥ 32, ≥ size of `int`	Can store integers in the range -2147483647 ~ 2147483647 portably^[3].	`long int`, `signed long`, `signed long int`
`unsigned` `long`	same as `long`	Can store integers in the range 0 ~ 4294967295 portably.	`unsigned` `long int`
`bool`	≥ size of `char`, ≤ size of `long`	Can store the constants `true` and `false`.	—
`wchar_t`	≥ size of `char`, ≤ size of `long`	Signedness is implementation-defined. Can store "wide" (multi-byte) characters, which include those stored in a `char` and probably many more, depending on the implementation. Integer operations are better not performed with `wchar_t`s. Use `int` or `unsigned` `int` instead.	—
`float`	≥ size of `char`	Used to reduce memory usage when the values used do not vary widely. The floating-point format used is implementation defined and need not be the IEEE single-precision format. `unsigned` cannot be specified.	—
`double`	≥ size of `float`	Represents the "normal" size of data the processor deals with; this is the floating-point data-type used normally. The floating-point format used is implementation defined and need not be the IEEE double-precision format. `unsigned` cannot be specified.	—
`long double`	≥ size of `double`	`unsigned` cannot be specified.	—
User Defined Types
`struct` or `class`	≥ sum of size of each member	Default access modifier for `struct`s for members and base classes is `public`. For `class`es the default is `private`. The convention is to use `struct` only for Plain Old Data types. Said to be a compound type.	—
`union`	≥ size of the largest member	Default access modifier for members and base classes is `public`. Said to be a compound type.	—
`enum`	≥ size of `char`	Enumerations are a distinct type from `int`s. `int`s are not implicitly converted to `enum`s, unlike in C. Also ++/-- cannot be applied to `enum`s unless overloaded.	—
`typedef`	same as the type being given a name	Syntax similar to a storage class like `static`, `register` or `extern`.	—
`template`	≥ size of `char`	—	—
Derived Types^[4]
`type&` (reference)	≥ size of `char`	References (unless optimized out) are usually internally implemented using pointers and hence they do occupy extra space separate from the locations they refer to.	—
`type*` (pointer)	≥ size of `char`	`0` always represents the null pointer (an address where no data can be placed), irrespective of what bit sequence represents the value of a null pointer. Pointers to different types may have different representations, which means they could also be of different sizes. So they are not convertible to one another. Even in an implementation which guarantees all data pointers to be of the same size, function pointers and data pointers are in general incompatible with each other. For functions taking variable number of arguments, the arguments passed must be of appropriate type, so even `0` must be cast to the appropriate type in such function-calls.	—
`type [integer]` (array)	≥ `integer` × size of `type`	The brackets (`[]`) follow the identifier name in a declaration. In a declaration which also initializes the array (including a function parameter declaration), the size of the array (the integer) can be omitted. `type []` is not the same as `type*`. Only under some circumstances one can be converted to the other.	—
`type (comma-delimited list of types/declarations)` (function)	—	The parentheses (`()`) follow the identifier name in a declaration, e.g. a 2-arg function pointer: `int (* fptr) (int arg1, int arg2)`. Functions declared without any storage class are `extern`.	—
`type aggregate_type::*` (member pointer)	≥ size of `char`	`0` always represents the null pointer (a value which does not point to any member of the aggregate type), irrespective of what bit sequence represents the value of a null pointer. Pointers to different types may have different representations, which means they could also be of different sizes. So they are not convertible to one another.	—

^[1] -128 can be stored in two's-complement machines (i.e. almost all machines in existence). In other memory models (e.g. 1's complement) a smaller range is possible, e.g. -127 ←→ +127.
^[2] -32768 can be stored in two's-complement machines (i.e. most machines in existence).
^[3] -2147483648 can be stored in two's-complement machines (i.e. most machines in existence).
^[4] The precedences in a declaration are:	`[]`, `()` (left associative)	— Highest
	`&`, ``, `::` (right associative)	— Lowest

Operators	Description	Example Usage	Associativity
Scope Resolution Operator			—
`::`	unary scope resolution operator for globals	`::NUM_ELEMENTS`
`::`	binary scope resolution operator for class and `namespace` members	`std::cout`

Function Call, Member Access, Post-Increment/Decrement Operators, RTTI and C++ Casts			Left to right
`()`	function call operator	`swap (x, y)`
`[]`	array index operator	`arr [i]`
`.`	member access operator for an object of class/union type or a reference to it	`obj.member`
`->`	member access operator for a pointer to an object of class/union type	`ptr->member`
`++ --`	post-increment/decrement operators	`num++`
`typeid()`	run time type identification operator for an object or type	`typeid (std::cout) typeid (std::iostream)`
`static_cast<>()` `dynamic_cast<>()` `const_cast<>()` `reinterpret_cast<>()`	C++ style cast operators for compile-time type conversion See Type Casting for more info	`static_cast<float> (i)` `dynamic_cast<std::istream> (stream)` `const_cast<char> ("Hello, World!")` `reinterpret_cast<const long> ("C++")`
`type()`	functional cast operator (`static_cast` is preferred for conversion to a primitive type)	`float (i)`
`type()`	also used as a constructor call for creating a temporary object, esp. of a class type	`std::string ("Hello, world!", 0, 5)`

Unary Operators			Right to left
`!`, not	logical not operator	`!eof_reached`
`~`, compl	bitwise not operator	`~mask`
`+ -`	unary plus/minus operators	`-num`
`++ --`	pre-increment/decrement operators	`++num`
`&`, bitand	address-of operator	`&data`
`*`	indirection operator	`*ptr`
`new` `new[]` `new()` `new()[]`	new operators for single objects or arrays	`new std::string (5, '*')` `new int [100]` `new (raw_mem) int new (arg1, arg2) int [100]`
`delete` `delete[]`	delete operator for pointers to single objects or arrays	`delete ptr` `delete[] arr`
`sizeof` `sizeof()`	`sizeof` operator for expressions or types	`sizeof` `123` `sizeof` `(int)`
`(type)`	C-style cast operator (deprecated)	`(float)i`

Member Pointer Operators			Right to left
`.*`	member pointer access operator for an object of class/union type or a reference to it	`obj.*memptr`
`->*`	member pointer access operator for a pointer to an object of class/union type	`ptr->*memptr`

Multiplicative Operators			Left to right
`* / %`	multiplication, division and modulus operators	`celsius_diff * 9 / 5`	Left to right

Additive Operators			Left to right
`+ -`	addition and subtraction operators	`end - start + 1`	Left to right

Bitwise Shift Operators			Left to right
`<<` `>>`	left and right shift operators	`bits << shift_len` `bits >> shift_len`	Left to right

Relational Inequality Operators			Left to right
`< > <= >=`	less-than, greater-than, less-than or equal-to, greater-than or equal-to	`i < num_elements`	Left to right

Relational Equality Operators			Left to right
`== !=`, not_eq	equal-to, not-equal-to	`choice != 'n'`	Left to right

Bitwise And Operator			Left to right
`&`, bitand		`bits & clear_mask_complement`	Left to right

Bitwise Xor Operator			Left to right
`^`, xor		`bits ^ invert_mask`	Left to right

Bitwise Or Operator			Left to right
`\|`, bitor		`bits \| set_mask`	Left to right

Logical And Operator			Left to right
`&&`, and		`arr != 0 && arr->len != 0`	Left to right

Logical Or Operator			Left to right
`\|\|`, or		`arr == 0 \|\| arr->len == 0`	Left to right

Conditional Operator			Right to left
`?:`		`size >= 0 ? size : 0`	Right to left

Assignment Operators			Right to left
`=`	assignment operator	`i = 0`
`+= -= = /= %=` `&=`, and_eq* \|=, or_eq `^=`, xor_eq `<<= >>=`	shorthand assignment operators (`foo op= bar` represents `foo = foo op bar`)	`num /= 10`

Exceptions			—
`throw`		`throw "Array index out of bounds"`	—

Comma Operator			Left to right
`,`		`i = 0, j = i + 1, k = 0`	Left to right

Index	Data
00	unspecified
01	unspecified
02	unspecified
03	unspecified
04	unspecified

Functions	Descriptions
abort	stops the program
abs	absolute value
acos	arc cosine
asctime	a textual version of the time
asin	arc sine
assert	stops the program if an expression isn't true
atan	arc tangent
atan2	arc tangent, using signs to determine quadrants
atexit	sets a function to be called when the program exits
atof	converts a string to a double
atoi	converts a string to an integer
atol	converts a string to a long
bsearch	perform a binary search
calloc	allocates and clears a two-dimensional chunk of memory
ceil	the smallest integer not less than a certain value
clearerr	clears errors
clock	returns the amount of time that the program has been running
cos	cosine
cosh	hyperbolic cosine
ctime	returns a specifically formatted version of the time
difftime	the difference between two times
div	returns the quotient and remainder of a division
exit	stop the program
exp	returns "e" raised to a given power
fabs	absolute value for floating-point numbers
fclose	close a file
feof	true if at the end-of-file
ferror	checks for a file error
fflush	writes the contents of the output buffer
fgetc	get a character from a stream
fgetpos	get the file position indicator
fgets	get a string of characters from a stream
floor	returns the largest integer not greater than a given value
fmod	returns the remainder of a division
fopen	open a file
fprintf	print formatted output to a file
fputc	write a character to a file
fputs	write a string to a file
fread	read from a file
free	returns previously allocated memory to the operating system
freopen	open an existing stream with a different name
frexp	decomposes a number into scientific notation
fscanf	read formatted input from a file
fseek	move to a specific location in a file
fsetpos	move to a specific location in a file
ftell	returns the current file position indicator
fwrite	write to a file
getc	read a character from a file
getchar	read a character from STDIN
getenv	get environment information about a variable
gets	read a string from STDIN
gmtime	returns a pointer to the current Greenwich Mean Time
isalnum	true if a character is alphanumeric
isalpha	true if a character is alphabetic
iscntrl	true if a character is a control character
isdigit	true if a character is a digit
isgraph	true if a character is a graphical character
islower	true if a character is lowercase
isprint	true if a character is a printing character
ispunct	true if a character is punctuation
isspace	true if a character is a space character
isupper	true if a character is an uppercase character
itoa	Convert a integer to a string
isxdigit	true if a character is a hexadecimal character
labs	absolute value for long integers
ldexp	computes a number in scientific notation
ldiv	returns the quotient and remainder of a division, in long integer form
localtime	returns a pointer to the current time
log	natural logarithm
log10	natural logarithm, in base 10
longjmp	start execution at a certain point in the program
malloc	allocates memory
memchr	searches an array for the first occurrence of a character
memcmp	compares two buffers
memcpy	copies one buffer to another
memmove	moves one buffer to another
memset	fills a buffer with a character
mktime	returns the calendar version of a given time
modf	decomposes a number into integer and fractional parts
perror	displays a string version of the current error to STDERR
pow	returns a given number raised to another number
printf	write formatted output to STDOUT
putc	write a character to a stream
putchar	write a character to STDOUT
puts	write a string to STDOUT
qsort	perform a quicksort
raise	send a signal to the program
rand	returns a pseudo-random number
realloc	changes the size of previously allocated memory
remove	erase a file
rename	rename a file
rewind	move the file position indicator to the beginning of a file
scanf	read formatted input from STDIN
setbuf	set the buffer for a specific stream
setjmp	set execution to start at a certain point
setlocale	sets the current locale
setvbuf	set the buffer and size for a specific stream
signal	register a function as a signal handler
sin	sine
sinh	hyperbolic sine
sprintf	write formatted output to a buffer
sqrt	square root
srand	initialize the random number generator
sscanf	read formatted input from a buffer
strcat	concatenates two strings
strchr	finds the first occurrence of a character in a string
strcmp	compares two strings
strcoll	compares two strings in accordance to the current locale
strcpy	copies one string to another
strcspn	searches one string for any characters in another
strerror	returns a text version of a given error code
strftime	returns individual elements of the date and time
strlen	returns the length of a given string
strncat	concatenates a certain amount of characters of two strings
strncmp	compares a certain amount of characters of two strings
strncpy	copies a certain amount of characters from one string to another
strpbrk	finds the first location of any character in one string, in another string
strrchr	finds the last occurrence of a character in a string
strspn	returns the length of a substring of characters of a string
strstr	finds the first occurrence of a substring of characters
strtod	converts a string to a double
strtok	finds the next token in a string
strtol	converts a string to a long
strtoul	converts a string to an `unsigned` long
strxfrm	converts a substring so that it can be used by string comparison functions
system	perform a system call
tan	tangent
tanh	hyperbolic tangent
time	returns the current calendar time of the system
tmpfile	return a pointer to a temporary file
tmpnam	return a unique filename
tolower	converts a character to lowercase
toupper	converts a character to uppercase
ungetc	puts a character back into a stream
va_arg	use variable length parameter lists
vprintf, vfprintf, and vsprintf	write formatted output with variable argument lists
vscanf, vfscanf, and vsscanf	read formatted input with variable argument lists

Mode	Meaning	Mode	Meaning
"r"	Open a text file for reading	"r+"	Open a text file for read/write
"w"	Create a text file for writing	"w+"	Create a text file for read/write
"a"	Append to a text file	"a+"	Open a text file for read/write
"rb"	Open a binary file for reading	"rb+"	Open a binary file for read/write
"wb"	Create a binary file for writing	"wb+"	Create a binary file for read/write
"ab"	Append to a binary file	"ab+"	Open a binary file for read/write

Name	Explanation
SEEK_SET	Seek from the start of the file
SEEK_CUR	Seek from the current location
SEEK_END	Seek from the end of the file

Control Character	Explanation
%c	a single character
%d	a decimal integer
%i	an integer
%e	scientific notation, with a lowercase "e"
%E	scientific notation, with an uppercase "E"
%f	a floating-point number
%g	use %e or %f, whichever is shorter
%G	use %E or %f, whichever is shorter
%o	an octal number
%x	`unsigned` hexadecimal, with lowercase letters
%X	`unsigned` hexadecimal, with uppercase letters
%u	an `unsigned` integer
%s	a string
%x	a hexadecimal number
%p	a pointer
%n	the argument shall be a pointer to an integer into which is placed the number of characters written so far
%%	a percent sign

Return value	Explanation
less than 0	buffer1 is less than buffer2
equal to 0	buffer1 is equal to buffer2
greater than 0	buffer1 is greater than buffer2

Input size	Initialized with a `for` loop	Initialized with memset()
1000	0.016	0.017
10000	0.055	0.013
100000	0.443	0.029
1000000	4.337	0.291

Return value	Explanation
less than 0	str1 is less than str2
equal to 0	str1 is equal to str2
greater than 0	str1 is greater than str2

Value	Description
LC_ALL	All of the locale
LC_TIME	Date and time formatting
LC_NUMERIC	Number formatting
LC_COLLATE	String collation and regular expression matching
LC_CTYPE	Regular expression matching, conversion, case-sensitive comparison, wide character functions, and character classification.
LC_MONETARY	For monetary formatting
LC_MESSAGES	For natural language messages

Code	Meaning
%a	abbreviated weekday name (e.g. Fri)
%A	full weekday name (e.g. Friday)
%b	abbreviated month name (e.g. Oct)
%B	full month name (e.g. October)
%c	the standard date and time string
%d	day of the month, as a number (1-31)
%H	hour, 24 hour format (0-23)
%I	hour, 12 hour format (1-12)
%j	day of the year, as a number (1-366)
%m	month as a number (1-12).
%M	minute as a number (0-59)
%p	locale's equivalent of AM or PM
%S	second as a number (0-59)
%U	week of the year, (0-53), where week 1 has the first Sunday
%w	weekday as a decimal (0-6), where Sunday is 0
%W	week of the year, (0-53), where week 1 has the first Monday
%x	standard date string
%X	standard time string
%y	year in decimal, without the century (0-99)
%Y	year in decimal, with the century
%Z	time zone name
%%	a percent sign

	private	protected	public
private inheritance	The member is inaccessible.	The member is private.	The member is private.
protected inheritance	The member is inaccessible.	The member is protected.	The member is protected.
public inheritance	The member is inaccessible.	The member is protected.	The member is public.

a	b	∧
1	1	1
1	0	0
0	1	0
0	0	0

a	b	∨
1	1	1
1	0	1
0	1	1
0	0	0

a	b	⊕
1	1	0
1	0	1
0	1	1
0	0	0

statement1	statement2	and
T	T	T
T	F	F
F	T	F
F	F	F

Binary	Oct	Dec	Hex	Glyph
010 0000	040	32	20	space
010 0001	041	33	21	!
010 0010	042	34	22	"
010 0011	043	35	23	#
010 0100	044	36	24	$
010 0101	045	37	25	%
010 0110	046	38	26	&
010 0111	047	39	27	'
010 1000	050	40	28	(
010 1001	051	41	29	)
010 1010	052	42	2A	*
010 1011	053	43	2B	+
010 1100	054	44	2C	,
010 1101	055	45	2D	-
010 1110	056	46	2E	.
010 1111	057	47	2F	/
011 0000	060	48	30	0
011 0001	061	49	31	1
011 0010	062	50	32	2
011 0011	063	51	33	3
011 0100	064	52	34	4
011 0101	065	53	35	5
011 0110	066	54	36	6
011 0111	067	55	37	7
011 1000	070	56	38	8
011 1001	071	57	39	9
011 1010	072	58	3A	:
011 1011	073	59	3B	;
011 1100	074	60	3C	<
011 1101	075	61	3D	=
011 1110	076	62	3E	>
011 1111	077	63	3F	?

Binary	Oct	Dec	Hex	Glyph
100 0000	100	64	40	@
100 0001	101	65	41	A
100 0010	102	66	42	B
100 0011	103	67	43	C
100 0100	104	68	44	D
100 0101	105	69	45	E
100 0110	106	70	46	F
100 0111	107	71	47	G
100 1000	110	72	48	H
100 1001	111	73	49	I
100 1010	112	74	4A	J
100 1011	113	75	4B	K
100 1100	114	76	4C	L
100 1101	115	77	4D	M
100 1110	116	78	4E	N
100 1111	117	79	4F	O
101 0000	120	80	50	P
101 0001	121	81	51	Q
101 0010	122	82	52	R
101 0011	123	83	53	S
101 0100	124	84	54	T
101 0101	125	85	55	U
101 0110	126	86	56	V
101 0111	127	87	57	W
101 1000	130	88	58	X
101 1001	131	89	59	Y
101 1010	132	90	5A	Z
101 1011	133	91	5B	[
101 1100	134	92	5C	\
101 1101	135	93	5D	]
101 1110	136	94	5E	^
101 1111	137	95	5F	_

Binary	Oct	Dec	Hex	Glyph
110 0000	140	96	60	`
110 0001	141	97	61	a
110 0010	142	98	62	b
110 0011	143	99	63	c
110 0100	144	100	64	d
110 0101	145	101	65	e
110 0110	146	102	66	f
110 0111	147	103	67	g
110 1000	150	104	68	h
110 1001	151	105	69	i
110 1010	152	106	6A	j
110 1011	153	107	6B	k
110 1100	154	108	6C	l
110 1101	155	109	6D	m
110 1110	156	110	6E	n
110 1111	157	111	6F	o
111 0000	160	112	70	p
111 0001	161	113	71	q
111 0010	162	114	72	r
111 0011	163	115	73	s
111 0100	164	116	74	t
111 0101	165	117	75	u
111 0110	166	118	76	v
111 0111	167	119	77	w
111 1000	170	120	78	x
111 1001	171	121	79	y
111 1010	172	122	7A	z
111 1011	173	123	7B	{
111 1100	174	124	7C	\|
111 1101	175	125	7D	}
111 1110	176	126	7E	~

Manipulator	Function
boolalpha	displays boolean values as 'true' and 'false' instead of as integers.
noboolalpha	forces bools to display as integer values
showuppercase	converts strings to uppercase before displaying them
noshowuppercase	displays strings as they are received, instead of in uppercase
fixed	forces floating point numbers to display with a fixed number of decimal places
scientific	displays floating point numbers in scientific notation

Name	description
`ios`	Supports the `ios` class from the old `iostream` library.
`streamoff`	Supports internal operations.
`streampos`	Holds the current position of the buffer pointer or file pointer.
`streamsize`	Specifies the size of the stream.
`wios`	Supports the `wios` class from the old `iostream` library.
`wstreampos`	Holds the current position of the buffer pointer or file pointer.

Name	description
`boolalpha`	Specifies that variables of type `bool` appear as true or false in the stream.
`dec`	Specifies that integer variables appear in base 10 notation.
`fixed`	Specifies that a floating-point number is displayed in fixed-decimal notation.
`hex`	Specifies that integer variables appear in base 16 notation.
`internal`	Causes a number's sign to be left justified and the number to be right justified.
`left`	Causes text that is not as wide as the output width to appear in the stream flush with the left margin.
`noboolalpha`	Specifies that variables of type `bool` appear as 1 or 0 in the stream.
`noshowbase`	Turns off indicating the notational base in which a number is displayed.
`noshowpoint`	Displays only the whole-number part of floating-point numbers whose fractional part is zero.
`noshowpos`	Causes positive numbers to not be explicitly signed.
`noskipws`	Cause spaces to be read by the input stream.
`nounitbuf`	Causes output to be buffered and processed when the buffer is full.
`nouppercase`	Specifies that hexadecimal digits and the exponent in scientific notation appear in lowercase.
`oct`	Specifies that integer variables appear in base 8 notation.
`right`	Causes text that is not as wide as the output width to appear in the stream flush with the right margin.
`scientific`	Causes floating point numbers to be displayed using scientific notation.
`showbase`	Indicates the notational base in which a number is displayed.
`showpoint`	Displays the whole-number part of a floating-point number and digits to the right of the decimal point even when the fractional part is zero.
`showpos`	Causes positive numbers to be explicitly signed.
`skipws`	Cause spaces to not be read by the input stream.
`unitbuf`	Causes output to be processed when the buffer is not empty.
`uppercase`	Specifies that hexadecimal digits and the exponent in scientific notation appear in uppercase.

Name	description
`basic_ios`	The template class describes the storage and member functions common to both input streams (of template class basic_istream) and output streams (of template class basic_ostream) that depend on the template parameters.
`fpos`	The template class describes an object that can store all the information needed to restore an arbitrary file-position indicator within any stream.
`ios_base`	The class describes the storage and member functions common to both input and output streams that do not depend on the template parameters.

BMP		SMP
0000–0FFF	8000–8FFF	10000–10FFF	18000-18FFF
1000–1FFF	9000–9FFF	11000–11FFF	19000-19FFF
2000–2FFF	A000–AFFF	12000–12FFF	1A000-1AFFF
3000–3FFF	B000–BFFF	13000–13FFF	1B000-1BFFF
4000–4FFF	C000–CFFF	14000-14FFF	1C000-1CFFF
5000–5FFF	D000–DFFF	15000-15FFF	1D000–1DFFF
6000–6FFF	E000–EFFF	16000–16FFF	1E000–1EFFF
7000–7FFF	F000–FFFF	17000-17FFF	1F000–1FFFF

SIP		SSP
20000–20FFF	28000–28FFF	E0000–E0FFF
21000–21FFF	29000–29FFF
22000–22FFF	2A000–2AFFF
23000–23FFF	2B000–2BFFF
24000–24FFF
25000–25FFF
26000–26FFF
27000–27FFF	2F000–2FFFF

PUA
F0000–F0FFF	F8000–F8FFF	100000–100FFF	108000–108FFF
F1000–F1FFF	F9000–F9FFF	101000–101FFF	109000–109FFF
F2000–F2FFF	FA000–FAFFF	102000–102FFF	10A000–10AFFF
F3000–F3FFF	FB000–FBFFF	103000–103FFF	10B000–10BFFF
F4000–F4FFF	FC000–FCFFF	104000–104FFF	10C000–10CFFF
F5000–F5FFF	FD000–FDFFF	105000–105FFF	10D000–10DFFF
F6000–F6FFF	FE000–FEFFF	106000–106FFF	10E000–10EFFF
F7000–F7FFF	FF000–FFFFF	107000–107FFF	10F000–10FFFF

C++ Programming

About the book

Foreword

Guide to readers

Reader comments

Copyright Notice

Authors

C++ a multi-paradigm language

Introducing C++

History and standardization

Overview

Why learn C++ ?

What is a programming language?

Low-level

High-level

Translating programming languages

Programming paradigms

Procedural programming

Statically typed

Type checking

Object-oriented programming

Objects and Classes

Encapsulation

Inheritance

Multiple inheritance

Polymorphism

Generic programming

Free-form

Language comparisons

Ideal language

Garbage collection

Why no finally keyword?

Mixing languages

C 89/99

Choosing C or C++

Java

Memory management

Libraries

Runtime

Miscellaneous

Performance

Comparing Imports vs Includes

C#

Managed C++ (C++/CLI)

D

Supported platforms

Compilers

Interfacing with C and C++

D features missing from C and C++

C++ features missing from D

Chapter summary

Fundamentals for getting started

The code

Programming

What is a program?

Types of programs

Types of instructions

Program execution

Core vs Standard Library

Program organization

Keywords and identifiers

ISO C++ keywords

C++ reserved identifiers

File organization

File names

Extensions

Source code

.cpp

.h

Object files

Object code

Libraries

Makefiles

Statements

Compound statement

Coding style conventions

25 lines 80 columns

Whitespace and indentation

Placement of braces (curly brackets)

Comments

Why no `finally` keyword?

`inline`

`typedef`

`namespace`

`static`