class MaClasse {
    // .... 
    MaClasse();
    // .... 
};

void f()
{
  list x;    // objet local nommé x (de la classe list)
  // ...
}

void g()
{
  list x();   // fonction nommée x (qui retourne une list)
  // ...
}

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);  // this line does NOT help initialize this object !!
   ...
 }

class Foo {
 public:
   Foo(char x, int y=0);  // this line combines the two constructors
   ...
 };

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 <math.h>    // 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 méthodes 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
}

Fred.h
class Fred {
    public:
      Fred();
      // ...
    private:
      int i_;
      static int j_;
};

Fred.cpp
Fred::Fred()
      : i_(10)  // OK : vous pouvez (et vous devriez) initialiser les données membres de cette façon
        j_(42)  // Error : vous ne pouvez pas initialiser une donnée static comme ça.
{
      // ...
}

// Vous devez définir les données statiques de cette façon :
int Fred::j_ = 42;

Fred.h
class Fred {
    public:
        ...
    private:
        static int j_;   // Declare la donnée membre static Fred::j_
        ...
 };

Fred.cpp
#include "Fred.h"
 
int Fred::j_ = some_expression_evaluating_to_an_int;
 
// A côté de ça, si vous souhaitez utiliser la valeur implicite des entiers static :
// int Fred::j_;

x.cpp
#include "Fred.hpp"

Fred x;

y.cpp
#include "Barney.hpp"

Barney y;

Barney.cpp
#include "Barney.hpp"

Barney::Barney()
{
    // ...
    x.goBowling();
    // ...
}

x.cpp
#include "Fred.hpp"

Fred& x()
{
    static Fred* ans = new Fred();
    return *ans;
}

Barney.cpp
#include "Barney.hpp"

Barney::Barney()
{
    // ...
    x().goBowling();
    // ...
}

x.cpp
#include "Fred.hpp"
 
 Fred& x()
 {
   static Fred ans;  // was static Fred* ans = new Fred();
   return ans;       // was return *ans;
 }

• est construit avant sa toute première utilisation
• n'a pas besoin d'être détruit après sa dernière utilisation

static Fred* ans = new Fred();

static Fred ans;

x.hpp
class X {
    public:
        ...
 
    private:
        static Fred x_;
};

x.cpp
#include "X.hpp"
 
Fred X::x_;

void X::someMethod()
{
    x_.goBowling();
}

x.hpp
class X {
    public:
        ...
 
    private:
        static Fred& x();
};

x.cpp
#include "X.hpp"
 
Fred& X::x()
{
    static Fred* ans = new Fred();
    return *ans;
}

void X::someMethod()
{
    x().goBowling();
}

void X::someMethod()
{
    static Fred& x = X::x();
    x.goBowling();
}

#include <iostream>
 
int f();  // forward declaration
int g();  // forward declaration
 
int x = f();
int y = g();
 
int f()
{
   std::cout << "using 'y' (which is " << y << ")\n";
   return 3*y + 7;
}
 
int g()
{
   std::cout << "initializing 'y'\n";
   return 5;
}

#include <iostream>
 
int f();  // forward declaration
int g();  // forward declaration
 
int& x()
{
   static int ans = f();
   return ans;
}
 
int& y()
{
   static int ans = g();
   return ans;
}
 
int f()
{
   std::cout << "using 'y' (which is " << y() << ")\n";
   return 3*y() + 7;
}
 
int g()
{
   std::cout << "initializing 'y'\n";
   return 5;
}

#include <iostream>
 
int& y();  // forward declaration
 
int& x()
{
   static int ans;
 
   static bool firstTime = true;
   if (firstTime) {
     firstTime = false;
     std::cout << "using 'y' (which is " << y() << ")\n";
     ans = 3*y() + 7;
   }
 
   return ans;
}
 
int& y()
{
   static int ans;
 
   static bool firstTime = true;
   if (firstTime) {
     firstTime = false;
     std::cout << "initializing 'y'\n";
     ans = 5;
   }
 
   return ans;
}

int& y();  // forward declaration
 
int& x()
{
   static int ans = 3*y() + 7;
   return ans;
}
 
int& y()
{
   static int ans = 5;
   return ans;
}

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