Répertoire d'articles
1. Résumé du constructeur et du destructeur
Supposons qu'il existe une telle classe
#include <string>
class Stock // class declaration
{
private:
std::string company;
long shares;
double share_val;
double total_val;
void set_tot() {
total_val = shares * share_val; }
public:
void acquire(const std::string & co, long n, double pr);
void buy(long num, double price);
void sell(long num, double price);
void update(double price);
void show();
}; // note semicolon at the end
L'un des objectifs de C ++ est de rendre l'utilisation des objets de classe comme celle des types standard. Cependant, jusqu'à présent, le code fourni dans ce chapitre ne
vous permet pas d'initialiser l'objet Stock comme int ou structure.
En d'autres termes, la syntaxe d'initialisation normale ne s'applique pas au type Stock:
int year = 2001; // valid initialization
struct thing {
char *pn;
int m:
};
thing amabob = {
"wodge", -23}; // valid initialization
Stock hot = {
"sukie's Autos, Inc ", 200, 50.25 }; //NO! compile error
La raison pour laquelle l'objet Stock ne peut pas être initialisé comme ci-dessus est que l'état d'accès de la partie de données est privé, ce qui signifie que le programme ne peut pas accéder directement aux données membres. Comme vous l'avez vu, les programmes peuvent uniquement accéder aux données membres via des fonctions membres, vous devez donc concevoir des fonctions membres appropriées pour initialiser correctement l'objet (si vous rendez le membre de données public au lieu de privé, vous pouvez l'initialiser comme il vient d'être décrit. Objet de classe , mais rendre les données publiques viole l'une des principales intentions originales de la classe: le masquage des données).
D'une manière générale, il est préférable d'initialiser l'objet lors de sa création. Par exemple, considérez le code suivant:
Stock gift;
gift.buy(10, 24.75);
En ce qui concerne l'implémentation actuelle de la classe Stock, la société membre de l'objet cadeau n'a aucune valeur. La conception de la classe suppose que l'utilisateur appelle acquiert () avant d'appeler toute autre fonction membre, mais cette hypothèse ne peut pas être imposée.
Une façon d'éviter ce problème consiste à initialiser automatiquement l'objet lors de sa création.
À cette fin, C ++ fournit une fonction membre spéciale, un type de constructeur, spécifiquement utilisé pour construire de nouveaux objets et attribuer des valeurs à leurs données membres. Plus précisément, C ++ fournit des noms et une syntaxe d'utilisation pour ces fonctions membres, et les programmeurs doivent fournir des
définitions de méthode.
Le nom est le même que le nom de la classe. Par exemple, un constructeur possible pour la classe Stock est une fonction membre nommée Stock (). Le prototype et l'en-tête de fonction du constructeur ont une fonctionnalité intéressante - bien qu'ils n'aient pas de valeur de retour, ils ne sont pas déclarés comme des types vides. En fait, le constructeur ne
déclare pas de type.
1. Déclarez et définissez le constructeur
Vous devez maintenant créer le constructeur Stock.
Puisque vous devez fournir 3 valeurs pour l'objet Stock, vous devez fournir 3 paramètres pour le constructeur (la 4ème valeur, le membre total_val, est calculée en fonction des partages et de share_val, il n'est donc pas nécessaire de fournir cette valeur pour le constructeur.) Les
programmeurs peuvent simplement vouloir définir le membre de la société et définir d'autres valeurs sur 0: cela peut être fait en utilisant les paramètres par défaut (voir le chapitre 8).
Le prototype ressemble donc à ceci:
// constructor prototype with some default arguments
Stock(const string &co, long n=0, double pr =0.0);
Le premier paramètre est un pointeur vers une chaîne utilisée pour initialiser la société membre. Les paramètres n et p fournissent des valeurs pour les membres partages et share_val. Notez qu'il n'y a pas de type de retour. Le prototype est dans la partie publique de la déclaration de classe.
Voici une définition possible du constructeur
Stock::Stock(const string & co, long n, double pr)
{
company = co;
if (n < 0) {
std::cerr <<"Number of shares can't be negative;"
<< company << "shares set to 0. \n";
shares =0;
} else {
shares = n;
}
share_val = pr;
set_tot();
}
Le code ci-dessus est le même que la fonction Acquérir () plus haut dans ce chapitre.
La différence est que lorsque le programme déclare l'objet, il appellera automatiquement le constructeur
2. Utilisez le constructeur
C ++ fournit deux façons d'utiliser des constructeurs pour initialiser des objets.
La première façon est d'appeler explicitement le constructeur:
Stock food = Stock("World Cabbage", 250, 1.25);
Cela définit le membre société de l'objet alimentaire sur la chaîne "World Cabbage '", le membre partages sur 250, etc.
Une autre méthode consiste à appeler le constructeur implicitement:
Stock garment("Furry Mason", 50, 2.5);
Ce format est plus compact et équivaut à l'appel explicite suivant
Stock garment = Stock("Furry Mason", 50, 2.5);
Chaque fois que vous créez un objet de classe (même allouez dynamiquement de la mémoire à l'aide de new), C ++ utilise le constructeur de classe. Voici comment utiliser le constructeur avec new:
Stock *pstock= new Stock("Electroshock Games", 18, 19.0);
Cette instruction crée un objet Stock, l'initialise à la valeur fournie par le paramètre et attribue l'adresse de l'objet au pointeur de stock. Dans ce cas, l'objet n'a pas de nom, mais des pointeurs peuvent être utilisés pour gérer l'objet. Nous discuterons plus en détail des pointeurs d'objet dans le chapitre 11.
La façon dont le constructeur est utilisé est différente des autres méthodes de classe. En général, utilisez des objets pour appeler des méthodes:
stock1.show(); //stock1 object invokes show() method
Mais vous ne pouvez pas utiliser l'objet pour appeler le constructeur, car l'objet n'existe pas avant que le constructeur ne l'ait construit. Par conséquent, le constructeur est utilisé pour créer un objet et ne peut pas être appelé via l'objet.
Le constructeur est une fonction membre de classe spéciale, qui est appelée lorsque l'objet de classe est créé.
Le nom du constructeur est le même que le nom de la classe, mais par surcharge de fonctions, plusieurs constructeurs avec le même nom peuvent être créés, à condition que la signature (liste de paramètres) de chaque fonction soit différente. De plus, le constructeur ne déclare pas de type.
Habituellement, le constructeur est utilisé pour initialiser les membres de l'objet de classe et l'initialisation doit correspondre à la liste de paramètres du constructeur. Par exemple, supposons que le prototype du constructeur de la classe Bozo soit le suivant:
Bozo(const char * fname,const char * lname); // constructor prototype
vous pouvez l'utiliser pour initialiser de nouveaux objets:
Bozo bozetta = bozo("Bozetta","Biggens"); // primary form
Bozo fufu("Fufu","O'Dweeb"); // short form
Bozo *pc = new Bozo("Popo","Le Peu"); // dynamic object
si le compilateur prend en charge C ++ 11, vous pouvez utiliser l'initialisation de liste:
Bozo bozetta = {
"Bozetta","Biggens"}; //C++11
Bozo fufu("Fufu","O'Dweeb") // C++11;
Bozo *pc = new Bozo{
"Popo","Le Peu"); //C++11
Si le constructeur n'a qu'un seul paramètre, le constructeur sera appelé lorsque l'objet est initialisé à une valeur du même type que le paramètre. Par exemple, supposons qu'il existe un tel prototype de constructeur:
bozo(int i)
vous pouvez utiliser l'une des formes suivantes pour initialiser l'objet:
Bozo dribble =bozo(44) // primary form
Bozo roon(66); // secondary form
Bozo tubby = 32; // special form for one-argument constructors
En fait, le troisième exemple est un nouveau contenu, pas un contenu de critique, mais le moment est venu de le présenter. Le chapitre 11 présentera un moyen de désactiver cette fonctionnalité, car elle peut apporter des surprises désagréables.
Attention: les constructeurs qui acceptent un paramètre permettent d'initialiser l'objet à une valeur en utilisant la syntaxe d'affectation:
Classname object = value;
cette fonctionnalité peut poser des problèmes, mais comme nous le présenterons au chapitre 11, cette fonctionnalité peut être désactivée.
3. Exemple de constructeur acceptant un paramètre
constructor.cpp
#include <iostream>
/*
author:梦悦foundation
公众号:梦悦foundation
可以在公众号获得源码和详细的图文笔记
*/
using std::cout;
using std::endl;
class Bozo {
public:
int iVar;
Bozo(int i) {
cout << "i = " << i << endl;
this->iVar = i;
}
void show();
};
void Bozo::show()
{
cout << "iVar = " << this->iVar <<endl;
}
int main()
{
cout << "---------------开始--->公众号:梦悦foundation---------------" << endl;
Bozo dribble = Bozo(44); // primary form
Bozo roon(66); // secondary form
Bozo tubby = 32; // special form for one-argument constructors
dribble.show();
roon.show();
tubby.show();
cout << "---------------结束--->公众号:梦悦foundation---------------" << endl;
}
résultat de l'opération:
meng-yue@ubuntu:~/MengYue/c++/object_class/02$ ./constructor
---------------开始--->公众号:梦悦foundation---------------
i = 44
i = 66
i = 32
iVar = 44
iVar = 66
iVar = 32
---------------结束--->公众号:梦悦foundation---------------
meng-yue@ubuntu:~/MengYue/c++/object_class/02$
Comme vous pouvez le voir, il est également possible d'attribuer un entier directement à l'instance de classe.
Le constructeur par défaut n'a pas de paramètres, donc si l'objet n'est pas explicitement initialisé lors de sa création, le constructeur par défaut sera appelé.
Si aucun constructeur n'est fourni dans le programme, le compilateur définira un constructeur par défaut pour le programme; sinon, vous devez fournir vous-même le constructeur par défaut.
Pour les objets non initialisés, le programme utilisera le constructeur par défaut pour créer:
Bozo bubi;// use default
Bozo *pb = new Bozo; // use default
Tout comme le programme appellera le constructeur lorsque l'objet est créé, le programme appellera le destructeur lorsque l'objet est supprimé.
Chaque classe ne peut avoir qu'un seul destructeur. Le destructeur n'a pas de type de retour (pas même void) ni de paramètres. Son nom est préfixé par le nom de la classe ~. Par exemple, le prototype du destructeur de la classe Bozo est le suivant:
// class destructor
~Bozo();
Si le constructeur utilise new, vous devez fournir un destructeur à l'aide de delete.