C++

appel du destructeur et opérateurs

Recherche :

Mot : Pseudo : Filtrer
Page : 1 2 Page Suivante Page Précédente Bas de page
Auteur	Sujet : appel du destructeur et opérateurs

in_your_phion

Bonjour,

je suis en train de faire des petites fonctions d'opérations basiques sur les matrices en c++.

en gros j'ai une classe Matrix, et pour l'instant je me contente de faire de la surcharge d'opérateurs : +, =, *

j'aurais deux petites questions siouplait...

1) j'ai fait un opérateur d'affectation = :

Code :

Matrix & operator=(const Matrix & m) {
_cols = m._cols; //le nombre de colonnes
_rows = m._rows; //le nombre de lignes
_data = new double [_cols*_rows]; //les données dans un tablo 1d
memcpy(_data, m._data, sizeof(double)*_cols*_rows );
return (*this) ;
}

est-ce bien comme ça qu'il faut faire ? e.g recopier les données de m dans l'instance qui est affecté par l'opérateur = ? Que se passe t'il si on redéfini pas =, c'est juste une copie membre à membre ? cad :

Code :

_cols=m._cols;
_rows=m._rows;
data=m->data;

2) Autrement j'ai une deuxième question ... là je comprend pas du tout... J'ai donc fait mes opérateurs et j'ai testé ça dans mon main :

Code :

Matrix m1(2,3) , m2(3,3), m3; //les matrices avec leurs tailles
m1.display(); //affiche
m2.display();
m3 = m1*m2; // ligne 3
//...
//d'autres opérations à caractère très très intéressant ...

ca marche, sauf que il y a deux appel au destructeur après la ligne 3 et je ne sais pas d'ou ils sortent :??:

j'obtiens donc ceci :

affichage de la matrice m1 ..

affichage de la matrice m2 ..

appel du constructeur de recopie
appel du destructeur
appel du destructeur

pourquoi ces appels au destructeur ..??

merci par avance..

Message cité 1 fois
Message édité par in_your_phion le 30-04-2008 à 23:16:46

Publicité

skeye

Les appels au destructeur sont faits automatiquement à la disparition de l'objet...

---------------
Can't buy what I want because it's free -

Joel F

Real men use unique_ptr

in_your_phion a écrit :

1) j'ai fait un opérateur d'affectation = :

Code :

Matrix & operator=(const Matrix & m) {
_cols = m._cols; //le nombre de colonnes
_rows = m._rows; //le nombre de lignes
_data = new double [_cols*_rows]; //les données dans un tablo 1d
memcpy(_data, m._data, sizeof(double)*_cols*_rows );
return (*this) ;
}

est-ce bien comme ça qu'il faut faire ? e.g recopier les données de m dans l'instance qui est affecté par l'opérateur = ?

Presque, là tu as au moins 2 raisons d'avoir des fuites mémoires.

Code :

Matrix & operator=(const Matrix & m)
{
if(m != *this)
{
_cols = m._cols; //le nombre de colonnes
_rows = m._rows; //le nombre de lignes
if(_data) delete[] _data;
_data = new double [_cols*_rows]; //les données dans un tablo 1d
memcpy(_data, m._data, sizeof(double)*_cols*_rows );
}
return (*this) ;
}

après bon, les tableaux 1D .... :cry:

in_your_phion a écrit :

Que se passe t'il si on redéfini pas =, c'est juste une copie membre à membre ?

Oui et c'ets MAL

in_your_phion a écrit :

2) Autrement j'ai une deuxième question ... là je comprend pas du tout... J'ai donc fait mes opérateurs et j'ai testé ça dans mon main :

Code :

Matrix m1(2,3) , m2(3,3), m3; //les matrices avec leurs tailles
m1.display(); //affiche
m2.display();
m3 = m1*m2; // ligne 3
//...
//d'autres opérations à caractère très très intéressant ...

ca marche, sauf que il y a deux appel au destructeur après la ligne 3 et je ne sais pas d'ou ils sortent :??:

j'obtiens donc ceci :

Montre moi le prototype de ton operateur *.
Je paries 50kg de carambar que tu passes tes operandes par copies et non par references.

Message cité 1 fois
Message édité par Joel F le 01-05-2008 à 10:45:52

skeye

ah tiens, j'avais mal compris la question, mais je comprends la réponse au moins .

Message édité par skeye le 01-05-2008 à 10:46:42

---------------
Can't buy what I want because it's free -

Ace17

Joel F a écrit :

Je paries 50kg de carambar que tu passes tes operandes par copies et non par references.

Le probleme ne serait-il pas plutot que l'operateur * renvoie un objet temporaire qui est detruit apres l'affectation?

Message cité 1 fois

Joel F

Real men use unique_ptr

ca expliquerait un appel au destructeur, le 2e viendrait d'où.
Anyway, je veut tout le code svp

in_your_phion

Ace17 a écrit :

Le probleme ne serait-il pas plutot que l'operateur * renvoie un objet temporaire qui est detruit apres l'affectation?

salut tout le monde!

merci pour vos réponses effectivement je pense que le premier appel au destructeur se fait car (m1*m2) est stocqué dans un objet temporaire qui est détruit après que m3 l'ai copié. Par contre pour le deuxième j'en ai toujours aucune idée.

Merci Joel pour l'explication sur l'opérateur =. Voici l'opérateur * que j'ai implémenté :

Code :

Matrix operator*(const Matrix & m) {
Matrix res;
if ( _cols == m._rows ) {
res._data = new double [_rows * m._cols];
res._cols = m._cols;
res._rows = _rows;
for (int i = 0; i< res._rows; ++i )
for (int j = 0; j< res._cols; ++j ) {
res._data[j + i*res._cols] = 0;
for (int k=0;k < _cols ; ++k )
res._data[j + i*res._cols] += _data[k + i*_cols] * m._data[j + k*m._cols] ;
}
}
return res;
}

j'ai bon ...? :sweat:

(edit : est ce qu'on peut surcharger un opérateur () et ensuite l'utiliser dans un autre surcharge d'opérateur ? par exemple dans mon cas ce serai plus pratique de faire m(i,j) plutot que m[j +i*m.cols] mais ça a pas l'air de marcher, y'a til un moyen ?)

Message édité par in_your_phion le 02-05-2008 à 00:46:33

Joel F

Real men use unique_ptr

operator* est canoniquement implanté sous forme 'une fonction libre et non d'une fonction membre.

Ensuite ... OMG punaise les lignes 7-9, quelle horreur !
Au lieu de faire péter ton encapsulation en accédant aux membre de ton res, tu pourrais pas proprement définir un constructeur qui prends une paire de paramètre et alloue une matrix de cette taille ? ou bien une méthode resize ?

Alors maintenant question :
c'est pr l'école ou c'est pour un vrai projet ?
si c'est pr l'école, y a du boulot, peut tu me montrer TOUT ton code qu'on t'inculque quelques bonnes manières.
si c'est pour du boulot sérieux, arrête de réinventer la roue : Blitz++, NT2, boost::array au choix

sinon oui operartor() se surcharge sans probleme.

Message cité 1 fois
Message édité par Joel F le 02-05-2008 à 08:34:45

Taz

bisounours-codeur

Un papier bien avec une exemple de multiplication de matrice efficace http://people.redhat.com/drepper/cpumemory.pdf §6.2

Déjà, si ton _data c'était un vector, t'aurais même pas à te poser la question d'operator=, etc

Message édité par Taz le 02-05-2008 à 13:14:35

in_your_phion

Joel F a écrit :

operator* est canoniquement implanté sous forme 'une fonction libre et non d'une fonction membre.

sinon oui operartor() se surcharge sans probleme.

salut,

merci pour vos réponses encore 1 fois :jap: En fait, ce n'est ni pour l'école ni pour un vrai projet de boulot ... c'est juste pour moi et apprendre le c++. Donc c'est pour ca que je ne fais pas de STL pour le moment, j'essaie de comprendre en partant de zéro, une fois que je me sentirai à l'aise je passerai à la stl [:arg]

@Joel F

ok pour les lignes 7 à 9 ... en fait mon constructeur initialise la matrice avec un rand donc c'est pour ca que je l'ai pas appelé dans operator* ... dans ce cas c'est peut etre mon constructeur qui est foireux 'cf plus bas).

MAis sinon je comprends toujours pas pourquoi j'ai deux appels au destructeur .. :cry:

ps : pour operator(), je voulais savoir si je peux l'utiliser dans operator*

merki!

ps : voici TOUT mon code (dans le .h) :

Code :

#include <iostream>
#include <string>
using namespace std;
const int N = 100;
class my_exception : public exception {
public:
my_exception(const char * txt ) {
msg = new char [strlen(txt) +1];
strcpy_s(msg,strlen(txt)+1,txt);
}
virtual const char * what () const throw() {
return this->msg;
}
private:
char * msg;
};
class Matrix {
public:
Matrix() : _cols(0), _rows(0), _data(0) { };
~Matrix () {
cout << "appel du destructeur" << endl;
if (_data)
delete [] _data;
} ;
Matrix(int r, int c) {
//if ( r <= 0 && c <= 0) throw BadIndex (" Matrix has wrong size." ) ;
_data = new double [r * c ];
for (int i=0; i< r*c; ++i)
_data[i] = (double) rand()/( RAND_MAX+1.0 )*N ;
_rows=r;
_cols=c;
}
//constructeur de copie
Matrix (const Matrix & m) {
cout << "appel du constructeur de recopie" << endl;
if (m._data) {
_rows = m._rows;
_cols = m._cols;
_data = new double [_rows * _cols ];
memcpy(_data, m._data, sizeof(double)*_rows*_cols );
}
}
double operator()(int i, int j) const {
//throw exeption
return _data[j + i*_cols] ;
}
double& operator()(int i, int j) {
//throw exeption
return _data[j + i*_cols] ;
}
Matrix & operator=(const Matrix & m) {
if (m != *this) {
_cols = m._cols;
_rows = m._rows;
if (_data)
delete [] _data;
_data = new double [_cols*_rows];
memcpy(_data, m._data, sizeof(double)*_cols*_rows );
}
return (*this) ;
}
Matrix operator+(const Matrix & m) {
Matrix res;
res._data = new double [m._rows * m._cols] ;
res._cols = _cols;
res._rows = _rows;
for (int i=0;i<_rows;++i)
for (int j=0;j<_cols;++j)
res._data[j + i*_cols] = _data[j + i*_cols] + m._data[j + i*_cols] ;
return res;
}
Matrix operator*(const Matrix & m) {
Matrix res;
if ( _cols == m._rows ) {
res._data = new double [_rows * m._cols];
res._cols = m._cols;
res._rows = _rows;
for (int i = 0; i< res._rows; ++i )
for (int j = 0; j< res._cols; ++j ) {
res._data[j + i*res._cols] = 0;
for (int k=0;k < _cols ; ++k )
res._data[j + i*res._cols] += _data[k + i*_cols] * m._data[j + k*m._cols] ;
}
}
return res;
}
void display() const {
if (_data != 0) {
cout.precision(4);
cout << "size=(" << _rows << ',' << _cols << ')' << endl;
for (int i=0;i<_rows;++i) {
for (int j=0;j<_cols;++j)
cout << fixed << _data[j + i*_cols] << '\t' ;
cout << endl;
}
cout << endl;
}
else
cout << "Matrix is empty." << endl;
}
//void showadd() { cout << _data << endl; }
private:
int _rows, _cols;
double * _data;
};

ps : la ligne 82 me génère l'erreur suivante :

error C2678: binary '!=' : no operator found which takes a left-hand operand of type 'const Matrix' (or there is no acceptable conversion)

ce serait pas plutot

Code :

if ( &m != this)

Message édité par in_your_phion le 02-05-2008 à 18:10:57

Publicité

Joel F

Real men use unique_ptr

je réponds plus tant que tu arretera pas d'utiliser char* et T* au lieu de string et de vector<T>.

Ca sert à rien d'attendre pour utiliser la STL à part se faire chier

Message cité 1 fois

in_your_phion

Joel F a écrit :

je réponds plus tant que tu arretera pas d'utiliser char* et T* au lieu de string et de vector<T>.

Ca sert à rien d'attendre pour utiliser la STL à part se faire chier

ouaiiii ...bon ....

que penses tu de ma brand new version tunée avec la STL alors ????

Code :

const int N = 100;
class my_exception : public exception {
public:
my_exception(const char * txt ) {
msg.assign(txt);
}
virtual const char * what () const throw() {
return this->msg.data();
}
private:
string msg;
};
class Matrix {
public:
Matrix() : _cols(0), _rows(0) { };
~Matrix () { cout << "appel du destructeur" << endl; }
Matrix(int r, int c) {
//if ( r <= 0 && c <= 0) throw BadIndex (" Matrix has wrong size." ) ;
for (int i= 0; i< r*c; ++i)
_data.push_back ( (double) rand()/( RAND_MAX+1.0 )*N );
_rows=r;
_cols=c;
}
/* plus besoin d'un constructeur de copie ? */
double operator()(int i, int j) const {
//throw exeption
return _data[j + i*_cols] ;
}
double& operator()(int i, int j) {
//throw exeption
return _data[j + i*_cols] ;
}
Matrix & operator=(const Matrix & m) {
if ( &m != this ) {
_cols = m._cols;
_rows = m._rows;
_data = m._data;
}
return (*this) ;
}
Matrix operator+(const Matrix & m) {
try {
if ( m._rows != _rows || m._cols != _cols )
throw my_exception("Matrices have different size" );
} catch (my_exception & e) { cout << e.what() << endl; }
Matrix res;
res._data = _data ;
res._cols = _cols;
res._rows = _rows;
for (int i=0;i<_rows;++i)
for (int j=0;j<_cols;++j)
res._data[j + i*_cols] = _data[j + i*_cols] + m._data[j + i*_cols] ;
return res;
}
Matrix operator*(const Matrix & m) {
Matrix res(*this);
if ( _cols == m._rows ) {
for (int i = 0; i< res._rows; ++i )
for (int j = 0; j< res._cols; ++j ) {
res._data[j + i*res._cols] = 0;
for (int k=0;k < _cols ; ++k )
res._data[j + i*res._cols] += _data[k + i*_cols] * m._data[j + k*m._cols] ;
}
}
return res;
}
void display() const {
if ( _data.size() ) {
cout.precision(4);
cout << "size=(" << _rows << ',' << _cols << ')' << endl;
int k=0;
for (vector<double>::const_iterator i=_data.begin(); i != _data.end() ;++i) {
cout << fixed << *i << '\t' ;
++k;
if (k == _cols) {
k=0;
cout << endl;
}
}
cout << endl;
}
else
cout << "Matrix is empty." << endl;
}
//void showadd() { cout << _data << endl; }
private:
int _rows, _cols;
vector<double> _data;
};

ça envoie ...?

Taz

bisounours-codeur

Si tu veux persister dans cette voie là, il manque des tas de const.

Message cité 1 fois

Joel F

Real men use unique_ptr

et je maintiens que * est canoniquement une fonction libre qui utilise la fonction membre +=

Message cité 1 fois

Taz

bisounours-codeur

Joel F a écrit :

et je maintiens que * est canoniquement une fonction libre qui utilise la fonction membre +=

bah je suis d'accord avec ça mais:
- y a quoi comme papier pour vraiment appuyer ça ? vu que les deux sont légaux, à part le poids des arguments techniques (operator ? est une opération externe, c'est meilleur d'implémenter operator ? à partir de operator ?=), j'arrive pas à trouver une vraie recommandation là dessus (style goto considered harmful).
- imagine que tu implémentes une classe Matrice 2D *=(const Matrice& ) ça n'a pas trop de sens. Alors du coup tu implémentes * en fonction libre, mais là tu te retrouves peut-être à devoir mettre un friend.

Parce qu'au final on a pas réussi à convaincre i_p_h a changer son implémentation. Mauvais arguments ?

Joel F

Real men use unique_ptr

pour le papier j'en cherche encore. Si j'en trouve pas j'en ecrirais un
sinon, en quoi *= n'a pas de sens ?

Taz

bisounours-codeur

Pour une matrice, bah oui ça peut, mais ça change pas mal la tronche de matrice, tu ne peux pas faire la multiplication sur place

Joel F

Real men use unique_ptr

Certes, je sais plus comment j'ai contourner le probleme dans NT2

Taz

bisounours-codeur

Ouais enfin bon, tu vois le dilemne operator?= / operator? / friend / etc

Taz

bisounours-codeur

bref tu vois quoi comme forme canonique quand operator?= ne s'implémente en fait qu'en utilisant operator? ?

Joel F

Real men use unique_ptr

enumerons les cas :

* operator(X) s'ecrit comme appel à operator(+)=
* operator(X)= s'ecrit comme appel à operator(+)
* operator(X)= et operator(X) ont rien à voir entre eux

En gros ?

Taz

bisounours-codeur

oui

Joel F

Real men use unique_ptr

bah voila en gros :
si il y a "dependance" des appels entre (X)= et (X) tu écris l'une en fonction de l'autre de manière naturelle.
Dans le cas ou les deux sont décorrellés, bah à part dupliquer du code je vois pas ce que tu peut faire.

L'argument de dire (X) s'écrit en appelant (X)= reste celui là : réduire la code duplication

Taz

bisounours-codeur

nan mais ça je sais bien. Mais si tu dois écrire operator?= en fonction de operator?, bah il ne vaudrait alors pas mieux mettre operator?= en fonction membre plutôt qu'en friend libre ?

in_your_phion

Taz a écrit :

Si tu veux persister dans cette voie là, il manque des tas de const.

ah ? où est ce que je devrais mettre des const ? sinon, c'est la bonne méthode ou pas ?

merci :sweat:

Taz

bisounours-codeur

ton operator+ par exemple

Message cité 1 fois

in_your_phion

Taz a écrit :

ton operator+ par exemple

salut,
je vois pas :cry: ... il manque un const dans operator+ ? ou ca ??

Joel F

Real men use unique_ptr

Matrix operator+(const Matrix & m) const

tout simplement.
Une méthode qui ne modifie pas l'état d'un objet est par def. const.

Message cité 1 fois

jesus_christ

votre nouveau dieu

j'ai pas tout lu, mais :

if(_data) delete[] _data;

beurk !
delete fait lui-même la vérif du pointeur NULL, ici c'est redondant et useless. C'est valable aussi pour free() en C.

Joel F

Real men use unique_ptr

c'est pas prévu par le standard. gcc le fait mais pas VC++ (ou l'inverse)

jesus_christ

votre nouveau dieu

euh, il me semble que si, la verif de delete et delete[] le fait en standard. Je vais aller vérifier ça, et j'espère ne pas me tromper car je fais des delete NULL assez souvent.

jesus_christ

votre nouveau dieu

http://www.cplusplus.com/doc/tutorial/dynamic.html

argument to delete must be either a pointer to a memory block previously allocated with new, or a null pointer (in the case of a null pointer, delete produces no effect).

jesus_christ

votre nouveau dieu

et même chez microsoft :

Using delete on a pointer to an object not allocated with new gives unpredictable results. You can, however, use delete on a pointer with the value 0.

http://msdn.microsoft.com/en-us/li [...] S.80).aspx

Joel F

Real men use unique_ptr

ah ok ^^ c'est le delete d'un unallocated pointer qui chouine, OK c'est noté

jesus_christ

votre nouveau dieu

ah oui, c'est sûr que :

int* t;
delete t;

ça marche pas trop. D'ailleurs j'espère qu'aucun compilo n'accepte ça. Par contre comme sous windows noyau NT (et +) la mémoire est initialisée avec des 0, ça marche en pratique. Mais pas sous Windows noyau 95 (jusqu'à Me).

D'où le fait que perso, qd je code sous Win, je teste toujours en parallèle sous un vieux Win98. Et en même temps ça teste le respect de qlq limites historiques du noyau Win32 (pas de HBITMAP > 16Mo, pas de LABEL > 64Ko, tout ça...).

in_your_phion

Joel F a écrit :

Matrix operator+(const Matrix & m) const

tout simplement.
Une méthode qui ne modifie pas l'état d'un objet est par def. const.

ok merci pour vos réponses. Puisqu'on parle de la STL, j'ai une petite autre question siouplé... :whistle:

j'aimerai savoir si c'est la bonne manière de déclarer un tableau 2D de vector avec la stl. Et surtout, est ce que ca a du sens de déclarer un pointeur vers un vecteur, car dans mon exemple c'est pas un pointeur mais je sais pas comment faire si c'est un pointeur. Voila l'exemple :

Code :

#include <iostream>
#include <iomanip>
#include <vector>
using namespace std;
class tablo2dint {
public:
tablo2dint (size_t x=0, size_t y=0) : _sx(x), _sy(y) {
data.resize ( _sy ) ;
for (int i=0;i<_sy;++i)
data[i].resize( _sx ) ;
for (int i=0;i<_sy;++i)
for (int j=0;j<_sx;++j )
data[i][j] = 2;
}
void display() {
cout << "display" << endl;
for (int i=0;i<_sy;++i) {
for (int j=0;j<_sx;++j )
cout << setw(3) << data[i][j] ;
cout << endl;
}
}
private:
int _sx;
int _sy;
vector<vector<int> > data;
};
int main() {
tablo2dint A(3,2);
A.display();
return 0;
}

display
2 2 2
2 2 2

je voudrais savoir si ca a du sens de faire :

Code :

vector<vector<int> > * data; // au lieu de vector<vector<int> > data;

si oui comment je peux initialiser ce pointeur ...

merci d'avance :hello:

Message édité par in_your_phion le 10-05-2008 à 02:59:49

Joel F

Real men use unique_ptr

vector<vector<int> > suffit, mais c'est inefficace, mattes du coté de boost::multi_array

jesus_christ

votre nouveau dieu

Code :

tablo2dint(size_t x=0, size_t y=0)
: _sx(x)
, _sy(y)
, data( x, std::vector< int >( y, 2 ) )
{
}

Ton constructeur, mais en 3 lignes.

Pour un tableau (X x Y) rempli avec des 2. Et en C++ on ne remplit pas avec des boucles for, on utilise std::fill ou std::fill_n.
Pour du dimention 2, il y a aussi les std::valarray, ça a peut-être déjà été dit.

Message cité 1 fois
Message édité par jesus_christ le 10-05-2008 à 10:07:28

in_your_phion

jesus_christ a écrit :

Code :

tablo2dint(size_t x=0, size_t y=0)
: _sx(x)
, _sy(y)
, data( x, std::vector< int >( y, 2 ) )
{
}

:sweat:

ok merci pour le constructeur ...

valarray je connaissais pas, je ne vois pas de documentation sur cpp.com ou sgi http://www.cplusplus.com/query/search.cgi?q=valarray

...

jesus_christ

votre nouveau dieu

un petit exemple là, mais valarray est peu documenté et assez dur à utiliser, mais les implémentations sont très performantes.

http://www.josuttis.com/libbook/num/gslice1.cpp.html

Publicité

Page : 1 2

Page Suivante

Page Précédente

Haut de page

FORUM HardWare.fr

Programmation

C++

appel du destructeur et opérateurs

Sujets relatifs
Appel aux pros de GTK et manipulation des images. J'avance pas !	problème débutant: appel méthode
Appel dll VB depuis VC++	[RESOLU] "applet not initiated" : quelle erreur dans le code HTML ?
appel d'un exécutable	[C++] Destructeur ? Comprends pas..
[resolu] CSS - Appel d'un div codé ailleurs	surcharge d'opérateurs
est-il possible de faire un appel dynamique à une procédure??	appel d'un executable
Plus de sujets relatifs à : appel du destructeur et opérateurs

Page générée en 0.157 secondes