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

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

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

    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>

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);
       //...assume there is no default constructor in class Fred...
};
 
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)
         };
 
   // The 10 Fred objects in array a will be initialized with Fred(5,7).
   //...
}

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

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

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

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)); 
}

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);
         // sets all the default values for each data member
      OpenFile& readonly();  // changes readonly_ to true
      OpenFile& createIfNotExist();
      OpenFile& blockSize(unsigned nbytes);
      ...
   private:
      friend File;
      bool readonly_;       // defaults to false [for example]
      ...
      unsigned blockSize_;  // defaults to 4096 [for example]
      ...
 };

class File {
    public:
        File(const OpenFile& params);
        // vacuums the actual params out of the OpenFile object
        ...
};