class Test
{
public:
    std::string F() const
    {
        return "F() const";
    }

    std::string F()
    {
        return "F()";
    }
};

int main()
{
    Test t1;
    cout << t1.F() << '\n'; // affiche "F()"

    const Test & t2 = t1;
    cout << t2.F() << '\n'; // affiche "F() const"
}

class A
{
public:
    // variable et fonction non statiques
    int var1;
    void f1() {};
    // variable et fonction statiques
    static int var2;
    static void f2() {};
};

// IMPORTANT : il faut définir la variable static
int A::var2 = 0;

int main()
{
    A a; // instance de A
    // var1 et f1 nécessitent une instance de A
    a.var1 = 1;
    a.f1();

    // var2 et f2 sont static et n'ont pas besoin d'instance
    A::var2 = 1;
    A::f2();
}

#include <iostream>
#include <string>

struct Base
{
    void F(int);
};

struct Derivee : Base
{
    void F(std::string);
};

Derivee d;
d.F("salut"); // Ok : appelle Derivee::F
d.F(5); // Erreur :  aucune fonction "F" prenant un int

struct Derivee : Base
{
    using Base::F;

    void F(std::string s);
};

Derivee d;
d.F("salut"); // Ok : appelle Derivee::F
d.F(5); // Ok : appelle Base::F

Derivee d;
d.Base::F(5); // Ok : appelle Base::F

DWORD WINAPI Fonction1( void *Param ) // Fonction globale 
{ 
    return 0; 
} 

DWORD WINAPI MaClasse::Fonction2( void *Param ) // Fonction membre de MaClasse 
{ 
    return 0; 
} 

MaClasse Param; 
CreateThread( NULL, 0, Fonction1, &Param, 0, NULL ); // OK 
CreateThread( NULL, 0, &MaClasse::Fonction2, &Param, 0, NULL ); // Erreur ! 

class MaClasse 
{ 
public : 

    static DWORD WINAPI StaticThreadFunc( void *Param ) 
    { 
        MaClasse* Obj = reinterpret_cast<MaClasse*>( Param ); 
        return Obj->ThreadFunc(); 
    } 

private : 

    DWORD ThreadFunc() 
    { 
        // ... 
        return 0; 
    } 
}; 

MaClasse Param; 
CreateThread( NULL, 0, &MaClasse::StaticThreadFunc, &Param, 0, NULL ); 

#include <iostream>

std::cout << x << y << z;

#include <vector>

class Polygon
{
pulic :

    Polygon& Add(int x, int y)
    {
        Points_.push_back(Point(x, y));

        return *this;
    }

private :

    std::vector<Point> Points_;
};

Polygon Poly;
Poly.Add(1, 2)
    .Add(5, 8)
    .Add(15, 19)
    .Add(0, 54);

#include <sstream>
#include <string>

class StringBuilder
{
pulic :

    template <typename T>
    StringBuilder& operator ()(const T& t)
    {
        std::ostringstream oss;
        oss << t;
        String_ += oss.str();

        return *this;
    }

private :

    std::string String_;
};

StringBuilder s;
s("salut j'ai ")(24)(" ans ");

#include <string>
#include <vector>

void FonctionPasOptimisee(std::vector<std::string> Tab)
{
    // ...
}

void FonctionOptimisee(const std::vector<std::string>& Tab)
{
    // ...
}

std::vector<std::string> v(5000, std::string(1000, '-')); // Tableau de 5000 chaînes de 1000 caractères

FonctionPasOptimisee(v); // recopie inutilement nos 5 millions de caractères
FonctionOptimisee(v); // ne recopie rien du tout

#include <string>
#include <vector>

void FonctionIncorrecte(std::string& s)
{
    // ...
}

void FonctionCorrecte(const std::string& s)
{
    // ...
}

std::string s1 = "salut";
std::string s2 = "hello";

FonctionIncorrecte(s1); // Ok
FonctionCorrecte(s1); // Ok

FonctionIncorrecte(s1 + s2); // Erreur : s1 + s2 est un temporaire
FonctionCorrecte(s1 + s2); // Ok

FonctionIncorrecte("bonjour"); // Erreur : "bonjour" est un temporaire
FonctionCorrecte("bonjour"); // Ok

void FonctionIncorrecte(char* s)
{
    // ...
}

void FonctionCorrecte(const char* s)
{
    // ...
}

FonctionIncorrecte("bonjour"); // Erreur : "bonjour" est un temporaire
FonctionCorrecte("bonjour"); // Ok

class MaClasse
{
    int abs(int x); // masque la fonction standard abs
}

int MaClasse::abs(int x)
{
    return ::abs(x); // fait appel à la fonction standard abs()
}