FAQ C++Consultez toutes les FAQ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class rectangle  
{ 
protected: 
    double width; 
    double height; 
  
public: 
    virtual void set_width(double x){width=x;} 
    virtual void set_height(double x){height=x;} 
    double area() const {return width*height;} 
  
}; 
  
class square : public rectangle 
{ 
/* L'invariant d'un carré est que à tout moment, width=height*/ 
    void INVARIANT() {assert(width==height);} 
public: 
    void set_width(double x) 
    { 
        INVARIANT();  
        rectangle::set_width(x); 
        rectangle::set_height(x);   
        INVARIANT(); 
    } 
    void set_height(double x) 
    { 
        INVARIANT(); 
        rectangle::set_width(x); 
        rectangle::set_height(x); 
        INVARIANT(); 
    } 
}; 
  
void foo(rectange& r) 
{ 
    r.set_height(4); 
    r.set_width(5); 
    assert(r.area() == 20); 
}

1
2
3
4
5
6
7
8
9
10
11
12
class A 
{ // Déclaration de A... 
}; 
class B : public A 
{ // Déclaration de B... 
}; 
  
// ... 
// Quelque part dans le code : 
{ 
    std::auto_ptr<A> ptr_a(new B); 
} // Destruction à partir du type statique A avec un type dynamique B !

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Bienvenue // classe abstraite 
{ 
public: 
    // le "= 0" à la fin indique que c'est 
    // une fonction virtuelle pure 
    virtual void Message() = 0; 
}; 
  
class BienvenueEnFrancais : public Bienvenue 
{ 
public: 
    void Message() 
    { 
        std::cout << "Bienvenue !\n"; 
    } 
}; 
  
class BienvenueEnAnglais : public Bienvenue 
{ 
public: 
    void Message() 
    { 
        std::cout << "Welcome !\n"; 
    } 
};

1
2
3
class A{}; 
class B{}; 
class C: public A,public B{};

1
2
3
4
class V { protected:int i;/* ... */ }; 
class A :  public V { /* ... */ }; 
class B :  public V { /* ... */ }; 
class C : public A, public B { /* ... */ };

void C::f(){std::cout << &(A::i) << "/" << &(B::i) << std::endl;}

1
2
3
4
5
6
7
8
9
10
11
class V  
{  
   protected:int i; 
   /* ... */  
}; 
class A : virtual public V  
{ /* ... */ }; 
class B : virtual public V  
{ /* ... */ }; 
class C : public A, public B  
{ /* ... */ };

void C::f(){std::cout << &(A::i) << "/" << &(B::i) << std::endl;}

1
2
class C : public A, public B, public V  
{ /* ... */ };

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
#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; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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; 
}

1
2
3
4
5
A 
B 
Membre1 
Membre2 
C

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
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; 
}

1
2
3
4
5
6
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

1
2
3
4
5
class IInterface 
{ 
public : 
    virtual void Action(); // éventuellement pure (=0) 
};

1
2
3
4
5
6
7
8
class IInterface 
{ 
public : 
    void Action(); 
  
private: 
    virtual void DoAction(); // =0 
};

1
2
3
4
5
6
7
8
void IInterface::Action() 
{ 
    // mise en place des préconditions de DoAction 
    // éventuellement en mode debug, tests des préconditions 
    DoAction(); 
    // éventuellement en mode debug, tests des postconditions 
    // traitements supplémentaires si besoin pour garantir les postconditions de Action() 
}

1
2
3
4
5
6
7
8
void IInterface::Action() 
{ 
    Log::Report("Entrée IInterface::Action"); 
    Duree temps(Duree::maintenant); 
    DoAction1(); 
    temps.Stop(); 
    Log::Report("Temps d'exécution : ", temps.LireDuree()); 
}

1
2
3
4
5
6
7
8
9
10
void IInterface::Action() 
{ 
    // Première partie de traitements 
    DoAction1(); 
    // Traitements suivants 
    DoAction2(); 
    // Traitements suivants.. 
    DoAction3(); 
    // fin des traitements 
}

1
2
3
4
5
6
7
8
9
10
class IInterface 
{ 
public : 
    void Action(); 
  
private: 
    virtual void DoAction1(); // =0 
    virtual void DoAction2(); // =0 
    virtual void DoAction3(); // =0 
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class Widget 
{ 
  public: 
  virtual ~Widget() { /* ... */ } 
  void show() 
  { 
    // ... 
    do_show(); 
    // ... 
  } 
  // ... 
  
  private :  
    virtual void do_show()=0; // fonction virtuelle pure 
}; 
  
class Button : public Widget 
{ 
  private :  
    virtual void do_show() { std::cout << "Button" << std::endl; } 
  // ... 
}; 
  
class Textfield : public Widget 
{ 
  private :  
    virtual void do_show() { std::cout << "Textfield" << std::endl; } 
  // ... 
}; 
  
void show_widget(Widget& w) 
{ 
    w.show(); 
} 
  
// ... 
  
Button b; 
Textfield t; 
  
show_widget(b); // affiche "Button" 
show_widget(t); // affiche "Textfield"

A* a = new B();

1
2
3
4
class A {}; 
class B : public A {}; 
  
A* ptr = new B; // le type statique l'objet est A mais son type dynamique est B

1
2
x = 10; 
x = "Hello World";

auto s = "blabla"; // ici s est de type const char* alors qu'on aurait voulu l'avoir de type std::string