#include <cstdlib> 

int main() 
{ 
    // exécute la commande système "dir" 
    // le texte affiché dépend de l'OS 
    std::system( "dir" ); 
    // exécute le programme "toto.exe" 
    std::system( "toto.exe" ); 
}

#include <memory>

int main()
{
    std::tr1::shared_ptr<int> p( new int );
}

class Classe1; // pas d'inclusion de "Classe1.h"
class Classe2; // pas d'inclusion de "Classe2.h"

class MaClasse
{
    void Something(const Classe1& c);

    Classe2* c2;
};

#include "Classe1.h"
#include "Classe2.h"

void MaClasse::Something(const Classe1& c)
{
    // Ici on peut accéder aux membres de Classe1 et Classe2,
    // on a inclus leurs en-têtes
}

class MaClasseImpl;

class MaClasse
{
public :

    void Set(int);
    int Get() const;

private :

    MaClasseImpl* pImpl;
};

#include "MaClasseImpl.h"

void MaClasse::Set(int x)
{
    pImpl->Set(x);
}

int MaClasse::Get() const
{
    return pImpl->Get();
}

class MaClasseImpl
{
public :

    void Set(int);
    int Get() const;

private :

    int val;
};

#include "MaClasseImpl.h"

void MaClasseImpl::Set(int x)
{
    val = x;
}

int MaClasseImpl::Get() const
{
    return val;
}

#include <cmath> // pour std::abs
#include <limits> // pour std::numeric_limits

using namespace std;

float f1 = 0.1f;
float f2 = 1.1f;
float f3 = f2 - f1;

// Version incorrecte ne tenant pas compte des imprécisions
if (f3 == 1.0f)
{
    // Pratiquement jamais vrai !
}

// Version correcte tenant compte des imprécisions
// err est une variable choisie en fonction de l'erreur autorisée
if (abs(f3 - 1.0f) <= err * max(abs(f3), abs(1.0f)) * numeric_limits<float>::epsilon())
{
    // Ok
}

#if defined (linux)
    // Code spécifique à Linux
#elif defined (_WIN32)
    // Code spécifique à Windows
#else
    // Plateforme non gérée, on peut par exemple placer une erreur de compilation
    #error Plateforme non gérée
#endif

int n = 5; // n est une lvalue
Client& getClient() { /* ... */ }
getClient() = UnAutreClient; // getClient() désigne ici une lvalue car la référence renvoyée correspond à la définition d'une lvalue
 
std::string s = "C++"; // s est une lvalue
// ...

class car
{
  public:
    //constructeur
    car
    (
      const engine& e, //moteur
      const wheels& w, //roues
      const doors& d, //portières
      const steering_wheel& s //volant
      //etc...
    );

    //constructeur par copie
    car(const car& c);

    //destructeur
    ~car();

  private:
    engine engine_;
    wheels wheels_;
    doors doors_;
    steering_wheel steering_wheel_;
    //d'autres composants...
};

car::car
(
  const engine& e,
  const wheels& w,
  const doors& d,
  const steering_wheel& s
  //etc...
):
  engine_(e),
  wheels_(w),
  doors_(d),
  steering_wheel_(s)
  //etc...
{
  std::cout << "Appel au constructeur de car.\n";
}

car::car(const car& s):
  engine_(s.engine_),
  wheels_(s.wheels_),
  doors_(s.doors_),
  steering_wheel_(s.steering_wheel_)
  //etc...
{
  std::cout << "Appel au constructeur par copie de car.\n";
}

car::~car()
{
  std::cout << "Appel au destructeur de car.\n";
}

const car
build_sport_car()
{
  const engine e = build_sport_engine();
  const wheels w = build_sport_wheels();
  const doors d = build_sport_doors();
  const steering_wheel s = build_sport_steering_wheel();
  //fabrication des autres composants...

  return car(e, w, d, s);
}

int
main()
{
  car my_car = build_sport_car();

  std::cout << "Fin du programme.\n";
  return 0;
}

Appel au constructeur de car. (1)
Appel au constructeur par copie de car. (2)
Appel au destructeur de car. (3)
Appel au constructeur par copie de car. (4)
Appel au destructeur de car. (5)
Fin du programme.
Appel au destructeur de car. (6)

Appel au constructeur de car.
Fin du programme.
Appel au destructeur de car.

const car
build_sport_car()
{
  const engine e = build_sport_engine();
  const wheels w = build_sport_wheels();
  const doors d = build_sport_doors();
  const steering_wheel s = build_sport_steering_wheel();
  //fabrication des autres composants...

  car sport_car(e, w, d, s); //l'instance est nommée
  sport_car.price(75000);
  sport_car.build_date(today());

  return sport_car;
}

const car
build_car(const bool type_sport = true)
{
  if(type_sport)
  {
    const engine e = build_sport_engine();
    const wheels w = build_sport_wheels();
    const doors d = build_sport_doors();
    const steering_wheel s = build_sport_steering_wheel();
    //fabrication des autres composants...

    car sport_car(e, w, d, s); //une première instance…

    sport_car.price(75000);

    return sport_car; //un premier point de sortie…
  }
  else
  {
    const engine e = build_town_engine();
    const wheels w = build_town_wheels();
    const doors d = build_town_doors();
    const steering_wheel s = build_town_steering_wheel();
    //fabrication des autres composants...

    car town_car(e, w, d, s); //une autre instance…

    town_car.price(28000);

    return town_car; //un autre point de sortie…
  }
}

const car
build_car(const bool sport_type = true)
{
  std::auto_ptr<engine> e;
  std::auto_ptr<wheels> w;
  std::auto_ptr<doors> d;
  std::auto_ptr<steering_wheel> s;

  if(sport_type)
  {
    e = std::auto_ptr<engine>(new engine(build_sport_engine()));
    w = std::auto_ptr<wheels>(new wheels(build_sport_wheels()));
    d = std::auto_ptr<doors>(new doors(build_sport_doors()));
    s = std::auto_ptr<steering_wheel>(new steering_wheel(build_sport_steering_wheel()));
    //fabrication des autres composants...
  }
  else
  {
    e = std::auto_ptr<engine>(new engine(build_town_engine()));
    w = std::auto_ptr<wheels>(new wheels(build_town_wheels()));
    d = std::auto_ptr<doors>(new doors(build_town_doors()));
    s = std::auto_ptr<steering_wheel>(new steering_wheel(build_town_steering_wheel()));
    //fabrication des autres composants...
  }

  car new_car(*e, *w, *d, *s); //une seule instance
  new_car.price(sport_type ? 75000 : 28000);

  return new_car; //un seul point de sortie
}

int
main()
{
  copy_and_modify_car(build_car()); //on passe directement le retour de la fonction build_car()
  std::cout << "Fin du programme.\n";
  return 0;
}

void
copy_and_modify_car(const car& const_c)
{
  car c(const_c);
  //modifier c...
}

Appel au constructeur de car.
Appel au constructeur par copie de car.
Appel au destructeur de car.
Fin du programme.
Appel au destructeur de car.

void
copy_and_modify_car(car c)
{
  //modifier c...
}

Appel au constructeur de car.
Fin du programme.
Appel au destructeur de car.

int
main()
{
  car c = build_car();
  copy_and_modify_car(c); //pas d'optimisation liée à la (N)RVO…

  //… étant donné que c peut toujours être utilisé dans la suite du programme

  return 0;
}

class Gadget
{
public:
void attendre()
{
while (! _drapeau)
{
dormir(1000); // attend 1000 ms
}
}
void seLever()
{
_drapeau = true;
}
...
private:
volatile bool _drapeau;
};

class C {
  int const TAILLE_MAX;
//[...]
};

int longueur(std::string const & chaine)
{
//[...]
}

class chaine {
public:
int longueur() const;
[...]
};