Introduction au constructeur en C
Un constructeur en C est utilisé dans la gestion de la mémoire de la programmation C ++. Il permet des types de données intégrés comme int, float et des types de données définis par l'utilisateur tels que class. Le constructeur dans la programmation orientée objet initialise la variable d'un type de données défini par l'utilisateur. Le constructeur aide à la création d'un objet. Le nom du constructeur est le même que le nom de l'objet mais il n'a pas de type de retour. Un constructeur est exécuté automatiquement lorsqu'un objet ou un membre spécial est créé. Il alloue la mémoire pour le nouvel objet créé et il peut être surchargé.
Code
// class with Constructor
class integer
(
int a, b;
public:
integer (void);
// declaration of Constructor
);
integer :: integer (void)
// constructor defined
(
a = 0, b = 0;
)
Utilisations du constructeur
- Il s'agit d'une méthode spéciale qui détient le même nom que le nom de classe et initialise l'objet chaque fois qu'il est créé. Il est donc simple et facile à exécuter.
- Il est principalement utilisé pour la gestion de la mémoire. Ils sont utilisés pour initialiser et supprimer le bloc de mémoire lorsqu'il n'est plus requis en ayant les options Nouveau et Supprimer comme spécifié par le programmeur
- Le compilateur crée un constructeur par défaut chaque fois que l'objet est créé. Lorsque vous ne déclarez pas le constructeur, le compilateur en crée un. C'est utile car l'objet et la fonction du programme savent que l'objet existe
- Un constructeur pour un objet est créé lorsqu'une instance est un objet déclaré. Une classe peut avoir plusieurs constructeurs pour différentes situations. La surcharge des constructeurs augmente la polyvalence de la classe en ayant plusieurs constructeurs dans une classe individuelle.
Overclass X's a, b value:: 0, 0
Overclass X1's a, b value:: 4, 5
Overclass X2's a, b value:: 6, 12
Par conséquent, le constructeur est surchargé de valeurs différentes.
Types de constructeur en C
Les principaux types de constructeur sont expliqués comme suit,
1. Constructeur par défaut
Un constructeur par défaut n'a pas de paramètre ou le paramètre actuel a des valeurs par défaut. Si aucun constructeur défini par l'utilisateur n'est présent dans la classe, le compilateur en crée un nouveau si nécessaire et qui est appelé comme constructeur par défaut. Il s'agit d'un membre public en ligne de la classe. Ce constructeur aura un corps complet et aucun initialiseur. Le constructeur par défaut ne fournit rien de spécifique, il alloue simplement de la mémoire à l'objet. Un constructeur de classe X est superficiel si toutes les affirmations suivantes sont vraies. Il est défini implicitement. Si X n'a pas de classes et de fonctions de base virtuelles. Toutes les classes de base et non les membres statiques de X ont des constructeurs triviaux.
2. Constructeurs paramétrés
Le constructeur qui peut accepter les arguments est appelé constructeurs paramétrisés. Il peut spécifier l'argument chaque fois qu'il est nécessaire.
Code
class X (
int i;
public:
void abc(void);
void xyz(void);
// member function definitions
)
X 0b 1;
// default constructor for creating 0b1. hence user can use it,
// implicitly define default constructor is public
// member of the class
0b1. abc();
0b1. xyz();
3. Copier le constructeur
Il est utilisé pour initialiser et déclarer un objet à partir d'un autre objet
integer 10(12);
définirait l'objet 10 et l'initialisait en même temps à la valeur 12. Une autre forme de cette instruction est
integer 10 = 12;
Le processus est appelé initialisation de la copie. Un constructeur de copie est utilisé chaque fois que l'objet temporaire est créé. Les applications du constructeur de copie sont les suivantes; Retour de l'objet comme valeur de fonction Initialisation de l'objet par un autre objet de la même classe
Syntaxe
class_name :: class_name(class_name &ptr)
class
(
//data
public: game(arguments); // parameterized constructor
………
………
);
Code
class school
(
char name(25);
int rno;
public: school(char, int); //parameterized constructor
);
school :: school (char n, int r)
(
name=n;
rno=r;
)
4. Surcharge du constructeur
Lorsque plusieurs constructeurs sont utilisés dans la même classe, cela s'appelle la surcharge du constructeur. Il nous donne plusieurs façons d'initialiser des objets dans une classe. Il augmente la flexibilité en ayant plusieurs constructeurs dans une seule classe.
Code
#include
#include
using namespace std;
class student
(
int score;
char name(30);
public:
student(int x, char y())
// parameterized constructor
(
score =x;
strcpy(name, y);
)
student()
// normal constructor
(
score =100;
strcpy(name, "y");
)
void input_data()
(
cout<>score;
cout<>name;
)
void show_data()
(
cout<<"\n score :"< cout<<"\n Name :"< )
);
int main()
(
student s(10, "z");
s.show_data();
getch();
return 0;
)#include
#include
using namespace std;
class student
(
int score;
char name(30);
public:
student(int x, char y())
// parameterized constructor
(
score =x;
strcpy(name, y);
)
student()
// normal constructor
(
score =100;
strcpy(name, "y");
)
void input_data()
(
cout<>score;
cout<>name;
)
void show_data()
(
cout<<"\n score :"< cout<<"\n Name :"< )
);
int main()
(
student s(10, "z");
s.show_data();
getch();
return 0;
)#include
#include
using namespace std;
class student
(
int score;
char name(30);
public:
student(int x, char y())
// parameterized constructor
(
score =x;
strcpy(name, y);
)
student()
// normal constructor
(
score =100;
strcpy(name, "y");
)
void input_data()
(
cout<>score;
cout<>name;
)
void show_data()
(
cout<<"\n score :"< cout<<"\n Name :"< )
);
int main()
(
student s(10, "z");
s.show_data();
getch();
return 0;
)
5. Constructeur bidimensionnel
C'est comme un tableau de structure et contient des lignes et des colonnes. Il contient un tableau de chaînes où une ligne représente une chaîne et une colonne représente une valeur de chaîne.
Code
// overloading class constructors
#include
using namespace std;
class CRectangle
(
int width, height;
public:
CRectangle ();
CRectangle (int, int);
int area (void)
(
return (width*height);
)
);
CRectangle::CRectangle ()
(
width = 7;
height = 5;
)
CRectangle::CRectangle (int a, int b)
(
width = a;
height = b;
)
int main ()
(
CRectangle rect (7, 5);
CRectangle rectb;
cout << "rect area: " << rect.area() << endl;
cout << "rectb area: " << rectb.area() << endl;
return 0;
)
Syntaxe
char arrayname(x)(y);
où 'x' est le nombre de lignes 'y' est le nombre de colonnes.
Le nombre de lignes doit être le même que le nombre de chaînes dans ce tableau. Le numéro de la colonne doit être supérieur ou égal à la longueur de la chaîne ou il peut être plus un
Exemple
S'il y a 8 chaînes dans le tableau et que la longueur de la chaîne la plus longue est 10, le tableau est défini comme suit
Char days(8)(11);
6. Constructeur privé
Il est utilisé pour créer un objet de classe pour une seule fois. Il est défini que la classe n'a pas plusieurs instances de la classe. C'est le même que les autres constructeurs mais défini comme privé. Il ne peut accéder qu'à l'objet de cette classe définie.
Code
classroom()
(
private:
Seule cette partie du programme peut être consultée et définie dans la section privée uniquement
Conclusion - Constructeur en C
Un constructeur peut prendre null ou plusieurs paramètres. Une classe peut définir un ou plusieurs constructeurs. C'est à nous de décider quel constructeur exécuter lors de la création d'objet en passant une liste d'arguments appropriée au constructeur en définissant la valeur par défaut pour le paramètre constructeur. Les pointeurs ne peuvent pas être utilisés sur les constructeurs car leurs adresses ne peuvent pas être prises en compte. Les constructeurs ne peuvent pas être déclarés comme statiques, const ou volatils.
Articles recommandés
Ceci est un guide du constructeur en C. Ici, nous discutons de l'utilisation du constructeur, des types de constructeur avec des exemples, du code et des sorties. Vous pouvez également consulter nos autres articles connexes pour en savoir plus-
- Copier le constructeur en Java
- Tableaux en programmation C
- Constructeur en Python
- Constructeur en JavaScript
- C Multiplication de la matrice de programmation