C++ constructeur et destructeur...

Alors qu'est-ce qu'un constructeur ?
c'est en fait une fonction qui s'executer a chaque fois que tu crées une variable d'un certain type

exemple :
tu crées une classe voiture
et tu mets un constructeur dedans qui met des valeur par defaut dans la variable

en faisant la declaration de la variable x de type voiture

voiture x;
a ce moment la, le constructeur se lance et donc conformement a ce qui est mi dedans, il va mettre de valeur par defaut dans cette variable de type voiture.

> pour le destructeur c'est un peu le meme fonctionnement mais ca a la destruction de celle-ci.

Daccord mais pour le destructeur quelqun peut etre plus precis et me dire si on peut faire une implementation avec instruction sur celui ci si oui comment?

il faudrait voir sur un exemple ... mais généralement on met pas grand chose ds le destructeur: on peut y désallouer la mémoire allouée par le constructeur ...

Est ce que qu'elqun peut me donner un exemple pour desaluer la memoir fourni par le constructeur en utilisant une implementation sur le destructeur?

Pour l'instant mon livre me dit de ne rien mettre a l'interieur de l'implementation du destructeure,alors si je comprend bien sa ne sert a rien mon implementation sans instruction?
Mis a part le faite que le codesource soit plus inteligible?

Si vous avez du mal a repondre a ma question pouvez vous simplement me dire ce que vous faite vous avec le destructeur,lui donner vous des instruction?
Si oui lesquels?

Merci a tout ceux qui m'aide! :gg:

Personne ne peut donc m'expliquer le fonctionement des constructeur et destructeur d'une classe avec un exemple ou deux avec une implementation sur le destructeur en donnant une instruction a celui ci?:confused:

Il y a donc aucun programeur c++ qui ne c'est me repondre... :crying:

je t'ai pas oublié mais j'ai pas eu le temps ...

je cherche un exemple et je te poste ca .. ;-)

au passage qq cours de C et C++

edit:

cours sur les classes

un exemple simple serait que ta classe contienne un tableau comme attribut

dans ton constructeur, tu dois allouer de la mémoire à ce tableau pour que l'attribut soit utilisable lorsque tu y feras accès.

dans le destructeur, il faut désalouer cette mémoire afin qu'elle n'en occupe pas bêtement pour rien (ca t'évite les pb de manque de mémoire si l'application que tu programme est grande... et c'est une habitude à prendre...)

tout ce que tu a besoin de savoir entre le constructeur et le destructeur, c'est que c'est le constructeur qui est appelé automatiquement quand tu fait x = new MonObjet(....) et lorsque tu sors du bloc où x a été déclaré.

tiens, je viens de trouver cet exemple dans le bouquin de stroustrup (celui qui a fait c++):

class Name{
const char* s
....
}

class Table{
Name* p;
size_t sz;
public:
Table(size_t s = 15) // le constructeur
{ p = new Name [sz=s]; }
~Table() // le destructeur
{ delete [] p; }
....
}

un petit exemple définissant une classe pour les images:


//----------------------------------------------------
// déclaration de la classe CImage: CImage.h
//----------------------------------------------------

class CImage
{
int width;
int height;

public:
int *data; // tab contenant les valeurs des pixels

CImage();
CImage(int w, int h,int val);
~CImage();

void Affiche();
};


//----------------------------------------------------
// CImage.cpp
//----------------------------------------------------


// constructeur par défaut
CImage::CImage()
{
width = 256;
height = 256;
data = new int [width*height];
}

// constructeur d'une image de taille w*h ou tous les pixels valent val:
CImage(int w, int h,int val)
{
height = h;
width = w;
data = new int [width*height];

for(int i=0; i<width*height; i++)
data = val;
}

// destructeur
CImage::~CImage()
{
delete[] data;
}

void Affiche()
{
// a faire! -> affichage de largeur et hauteur
// ou affichage de l'image ds une fenetre
}