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
    // ...
};