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