class MaClasse
{
public:
    MaClasse();
};

class MaClasse1
{
public:
    MaClasse1(); // ceci est le constructeur par défaut
};

class MaClasse2
{
public:
    MaClasse2( int i = 1 ); // ceci est le constructeur par défaut 
};

class MaClasse3
{
public:
    MaClasse3( int i ); // ceci n'est pas le constructeur par défaut 
};

class MaClasse
{
public:
    MaClasse( const MaClasse & ); // ceci est le constructeur de copie
};

T * t = new T();
t->init(); // peut lever une exception, parce que la clé de connection n'est pas valide...
return t;

MaClasse x;
MaClasse y();

#include "MaClasse.h"

int main()
{
    MaClasse x; // ok
    MaClasse y(); // déclaration de la fonction y !
}

line Foo( x, 0 );

Foo::Foo(char,int)

Foo::Foo( char, int )

class Foo
    {
    public:
        Foo( char x );
        Foo( char x, int y );
    };
 
    Foo::Foo( char x )
    {
        Foo( x, 0 );  // Cette ligne n'initialise pas l'objet !
    }

class Foo
    {
    public:
        Foo( char x, int y = 0 );  // cette ligne combine les 2 constructeurs
 };

class Foo
    {
    public:
        Foo( char x );
        Foo( char x, int y );

    private:
        void init( char x, int y );
 };
 
    Foo::Foo( char x )
    {
        init( x, int( x ) + 7 );
    }
 
    Foo::Foo( char x, int y )
    {
       init( x, y );
    }
 
    void Foo::init( char x, int y )
    {
    }

class Fred
    {
    public:
        Fred();   // constructeur par défaut : peut s'appeler sans args
    };

class Fred
{
public:
    Fred( int i = 3, int j = 5 ); // constructeur par défaut : peut s'appeler sans args
};

class Fred
{
public:
    Fred( int i, int j );
    // Suppose qu'il n'y a aucun constructeur par défaut
};

int main()
{
    Fred a[ 10 ];    // ERREUR : Fred n'a pas de constructeur par défaut
    Fred * p = new Fred[ 10 ]; // ERREUR : Fred n'a pas de constructeur par défaut
}

#include <vector>

int main()
{
    std::vector <Fred> a(10, Fred(5,7));
    //  10 objets Fred dans le vecteur a seront initialisés avec Fred(5,7)
}

class Fred
{
public:
    Fred(int i, int j);
    // suppose qu'il n'y a aucun constructeur par défaut
};
 
int main()
{
    Fred a[10] = {
        Fred(5,7), Fred(5,7), Fred(5,7), Fred(5,7), Fred(5,7),
        Fred(5,7), Fred(5,7), Fred(5,7), Fred(5,7), Fred(5,7)
        };
    //  10 objets Fred dans le tableau a seront initialisés avec Fred(5,7) 
}

Fred::Fred() : x_(n'importe quoi) 
{ 
}

Fred::Fred() : x_() 
{ 
    x_ = n'importe quoi;
}

A* a = new B();

class Point
{
public:
    Point(float x, float y);  // Coordonnées rectangulaires
    Point(float r, float a);  // Coordonnées polaires (distance et angle)
    // ERREUR : Surcharge ambiguë: Point::Point(float, float)
};

int main()
{
    Point p = Point(5.7, 1.2); // Ambigu : De quel système de coordonnées parle-t-on ?
}

#include <cmath>    // Pour avoir sin() et cos()

class Point
{
public:
    static Point rectangular(float x, float y);      // Coords rectangulaires
    static Point polar(float radius, float angle);   // Coords polaires
    // Ces fonctions static sont les "constructeurs nommés"
    // ...
private:
    Point(float x, float y);  // coordonnées rectangulaires
    float x_, y_;
};

inline Point::Point(float x, float y)
    : x_(x), y_(y) 
{ 
}

inline Point Point::rectangular(float x, float y)
{ 
    return Point(x, y); 
}

inline Point Point::polar(float radius, float angle)
{ 
    return Point( radius * cos(angle), radius * sin(angle) ); 
}

int main()
{
    Point p1 = Point::rectangular(5.7, 1.2);  // Evidemment rectangulaire
    Point p2 = Point::polar(5.7, 1.2); // Evidemment polaire
}

File f = OpenFile("foo.txt");

File f = OpenFile("foo.txt").
            readonly().
            createIfNotExist().
            appendWhenWriting().
            blockSize(1024).
            unbuffered().
            exclusiveAccess();

class File;
 
class OpenFile
{
public:
    OpenFile(const string& filename); // initialise chaque donnée membre à sa valeur par défaut
      OpenFile& readonly();  // change readonly_ à true
      OpenFile& createIfNotExist();
      OpenFile& blockSize( unsigned nbytes );
      // ...
   private:
      friend File;
      bool readonly_;       // false par défaut [exemple]
      unsigned blockSize_;  // 4096 par défaut [exemple]
      // ...
 };

class File
{
public:
    File(const OpenFile& params);
    // s'initialise à partir des paramètres de l'objet OpenFile reçu
    // ...
};

 
#include <iostream>
#include <string>
 
struct MembreA{
   MembreA(){std::cout<<"MembreA"<<std::endl;}
};
struct A {
   A(){std::cout<<"A"<<std::endl;} 
   MembreA m;
};
struct MembreB{
   MembreB(){std::cout<<"MembreB"<<std::endl;}
};
struct B : A {
   B(){std::cout<<"B"<<std::endl;} 
   MembreB m;
};
struct MembreC{
   MembreC(){std::cout<<"MembreC"<<std::endl;}
};
struct C : A {
   C(){std::cout<<"C"<<std::endl;}
   MembreC m;
};
struct MembreD{
   MembreD(){std::cout<<"MembreD"<<std::endl;}
};
struct D : B, C {D(){
   std::cout<<"D"<<std::endl;}
   MembreD m;
};
struct MembreE{MembreE(){
   std::cout<<"MembreE"<<std::endl;}
};
struct E : virtual A {E(){
   std::cout<<"E"<<std::endl;}
   MembreE m;
};
struct MembreF{MembreF(){
   std::cout<<"MembreF"<<std::endl;}
};
struct F : virtual A {
   F(){std::cout<<"F"<<std::endl;}
   MembreF m;
};
struct MembreG{
   MembreG(){std::cout<<"MembreG"<<std::endl;}
};
struct G {
   G(){std::cout<<"G"<<std::endl;}
   MembreG m;
};
struct MembreH{
   MembreH(){std::cout<<"MembreH"<<std::endl;}
};
struct H : G, F {
   H(){std::cout<<"H"<<std::endl;}
   MembreH m;
};
struct MembreI{
   MembreI(){std::cout<<"MembreI"<<std::endl;}
};
struct I : E, G, F {
   I(){std::cout<<"I"<<std::endl;}
   MembreI m;
};
 
 
template<class T> void Creation()
{
   std::cout<<"Creation d'un "<<typeid(T).name()<<" : "<<std::endl;
   T t;
}
 
int main()
{
   Creation<A>();
   Creation<B>();
   Creation<C>();
   Creation<D>();
   Creation<E>();
   Creation<F>();
   Creation<G>();
   Creation<H>();
   Creation<I>();
   return 0;
}
 

 
Creation d'un struct A :
MembreA
A
Creation d'un struct B :
MembreA
A
MembreB
B
Creation d'un struct C :
MembreA
A
MembreC
C
Creation d'un struct D :
MembreA
A
MembreB
B
MembreA
A
MembreC
C
MembreD
D
Creation d'un struct E :
MembreA
A
MembreE
E
Creation d'un struct F :
MembreA
A
MembreF
F
Creation d'un struct G :
MembreG
G
Creation d'un struct H :
MembreA
A
MembreG
G
MembreF
F
MembreH
H
Creation d'un struct I :
MembreA
A
MembreE
E
MembreG
G
MembreF
F
MembreI
I
 

 
struct Membre1
{
   Membre1(){std::cout<<"Membre1"<<std::endl;}
};
struct Membre2
{
   Membre2(){std::cout<<"Membre2"<<std::endl;}
};
struct A {
   A(){std::cout<<"A"<<std::endl;} 
};
struct B {
   B(){std::cout<<"B"<<std::endl;} 
};
struct C : A,B {
   C()
      :m2(),B(),m1(),A()
   {std::cout<<"C"<<std::endl;}
   Membre1 m1;
   Membre2 m2;
};
int main()
{
   C c;
   return 0;
}
 

 
A
B
Membre1
Membre2
C
 

 struct A
{
   A(std::string appelant_="defaut")
   {
      std::cout<<"A construit par "<<appelant_<<std::endl;
   }
};
 
struct B : virtual A
{
   B()
      :A("B")
   {
   }
};
 
struct C : B
{
   C()
   {
   }
};
 
struct D : B
{
   D()
      :A("D")
   {
   }
};
 
template<class T> void Creation()
{
   std::cout<<"Creation d'un "<<typeid(T).name()<<" : "<<std::endl;
   T t;
}
 
int main()
{
   Creation<B>();
   Creation<C>();
   Creation<D>();
   return 0;
} 

 Creation d'un struct B :
A construit par B
Creation d'un struct C :
A construit par defaut
Creation d'un struct D :
A construit par D