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
class car 
{ 
public: 
    //constructeur 
    car 
    ( 
        const engine& e, //moteur 
        const wheels& w, //roues 
        const doors& d, //porti�res 
        const steering_wheel& s //volant 
        // etc. 
    ); 
  
    // constructeur par copie 
    car(const car& c); 
  
    // destructeur 
    ~car(); 
  
private: 
    engine engine_; 
    wheels wheels_; 
    doors doors_; 
    steering_wheel steering_wheel_; 
    // d'autres composants... 
};

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
car::car 
( 
    const engine& e, 
    const wheels& w, 
    const doors& d, 
    const steering_wheel& s 
    // etc. 
): 
  engine_(e), 
  wheels_(w), 
  doors_(d), 
  steering_wheel_(s) 
  // etc. 
{ 
    std::cout << "Appel au constructeur de car.\n"; 
} 
  
car::car(const car& s): 
  engine_(s.engine_), 
  wheels_(s.wheels_), 
  doors_(s.doors_), 
  steering_wheel_(s.steering_wheel_) 
  // etc. 
{ 
    std::cout << "Appel au constructeur par copie de car.\n"; 
} 
  
car::~car() 
{ 
    std::cout << "Appel au destructeur de car.\n"; 
}

1
2
3
4
5
6
7
8
9
10
const car build_sport_car() 
{ 
    const engine e = build_sport_engine(); 
    const wheels w = build_sport_wheels(); 
    const doors d = build_sport_doors(); 
    const steering_wheel s = build_sport_steering_wheel(); 
    //fabrication des autres composants... 
  
    return car(e, w, d, s); 
}

1
2
3
4
5
6
7
int main() 
{ 
    car my_car = build_sport_car(); 
  
    std::cout << "Fin du programme.\n"; 
    return 0; 
}

1
2
3
4
5
6
7
Appel au constructeur de car. (1) 
Appel au constructeur par copie de car. (2) 
Appel au destructeur de car. (3) 
Appel au constructeur par copie de car. (4) 
Appel au destructeur de car. (5) 
Fin du programme. 
Appel au destructeur de car. (6)

1
2
3
Appel au constructeur de car. 
Fin du programme. 
Appel au destructeur de car.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const car build_sport_car() 
{ 
    const engine e = build_sport_engine(); 
    const wheels w = build_sport_wheels(); 
    const doors d = build_sport_doors(); 
    const steering_wheel s = build_sport_steering_wheel(); 
    // fabrication des autres composants... 
  
    car sport_car(e, w, d, s); //l'instance est nomm�e 
    sport_car.price(75000); 
    sport_car.build_date(today()); 
  
    return sport_car; 
}

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
const car build_car(const bool type_sport = true) 
{ 
    if(type_sport) 
    { 
        const engine e = build_sport_engine(); 
        const wheels w = build_sport_wheels(); 
        const doors d = build_sport_doors(); 
        const steering_wheel s = build_sport_steering_wheel(); 
        // fabrication des autres composants... 
  
        car sport_car(e, w, d, s); //une premi�re instance. 
  
        sport_car.price(75000); 
  
        return sport_car; //un premier point de sortie. 
    } 
    else 
    { 
        const engine e = build_town_engine(); 
        const wheels w = build_town_wheels(); 
        const doors d = build_town_doors(); 
        const steering_wheel s = build_town_steering_wheel(); 
        // fabrication des autres composants... 
  
        car town_car(e, w, d, s); // une autre instance. 
  
        town_car.price(28000); 
  
        return town_car; // un autre point de sortie. 
    } 
}

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
const car 
build_car(const bool sport_type = true) 
{ 
    std::unique_ptr<engine> e; 
    std::unique_ptr<wheels> w; 
    std::unique_ptr<doors> d; 
    std::unique_ptr<steering_wheel> s; 
  
    if(sport_type) 
    { 
        e = std::unique_ptr<engine>(new engine(build_sport_engine())); 
        w = std::unique_ptr<wheels>(new wheels(build_sport_wheels())); 
        d = std::unique_ptr<doors>(new doors(build_sport_doors())); 
        s = std::unique_ptr<steering_wheel>(new steering_wheel(build_sport_steering_wheel())); 
        // fabrication des autres composants... 
    } 
    else 
    { 
        e = std::unique_ptr<engine>(new engine(build_town_engine())); 
        w = std::unique_ptr<wheels>(new wheels(build_town_wheels())); 
        d = std::unique_ptr<doors>(new doors(build_town_doors())); 
        s = std::unique_ptr<steering_wheel>(new steering_wheel(build_town_steering_wheel())); 
        // fabrication des autres composants... 
    } 
  
    car new_car(*e, *w, *d, *s); // une seule instance 
    new_car.price(sport_type ? 75000 : 28000); 
  
    return new_car; // un seul point de sortie 
}

1
2
3
4
5
6
int main() 
{ 
    copy_and_modify_car(build_car()); //on passe directement le retour de la fonction build_car() 
    std::cout << "Fin du programme.\n"; 
    return 0; 
}

1
2
3
4
5
void copy_and_modify_car(const car& const_c) 
{ 
    car c(const_c); 
    // modifier c... 
}

1
2
3
4
5
Appel au constructeur de car. 
Appel au constructeur par copie de car. 
Appel au destructeur de car. 
Fin du programme. 
Appel au destructeur de car.

1
2
3
4
void copy_and_modify_car(car c) 
{ 
    // modifier c... 
}

1
2
3
Appel au constructeur de car. 
Fin du programme. 
Appel au destructeur de car.

1
2
3
4
5
6
7
8
9
int main() 
{ 
    car c = build_car(); 
    copy_and_modify_car(c); //pas d'optimisation li�e � la (N)RVO. 
  
    // �tant donn� que c peut toujours �tre utilis� dans la suite du programme 
  
    return 0; 
}