Différence entre déclarations d'objet

Signaler
Messages postés
2
Date d'inscription
samedi 1 décembre 2007
Statut
Membre
Dernière intervention
27 septembre 2010
-
Messages postés
3834
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
20 octobre 2021
-
Salut à toutes et à tous,

Je ne suis pas vraiment un débutant en C++, mais j'ai une question de débutant...

J'ai défini une classe Test comme ceci :

#ifndef _TEST_H
#define _TEST_H

class Test {
  int _a;
  int _b;

 public:
  Test(int a 0, int b 0);
  ~Test();
  inline int a() const { return _a; };
  inline void a(const int & a) { _a = a; };
  inline int b() const { return _b; };
  inline void b(const int & b) { _b = b; };
  void test (const Test & t);
};

#endif /* _TEST_H */


J'ai ensuite fait un main() qui ressemble à ça :
int
main(int argc, char ** argv) {
  Test * t1 = new Test(2, 2);
  Test * t2 = new Test();
  Test t3(32,41);
  
  std::cout << "t1 : a " << t1->a() << " et b " << t1->b() << std::endl;
  std::cout << "t2 : a " << t2->a() << " et b " << t2->b() << std::endl;
  std::cout << "t3 : a " << t3.a() << " et b " << t3.b() << "\n" << std::endl;
 
  t2->a(3); t2->b(4);

  std::cout << "t1 : a " << t1->a() << " et b " << t1->b() << std::endl;
  std::cout << "t2 : a " << t2->a() << " et b " << t2->b() << std::endl;
  std::cout << "t3 : a " << t3.a() << " et b " << t3.b() << "\n" << std::endl;

  t2->test(*t1);

  std::cout << "t1 : a " << t1->a() << " et b " << t1->b() << std::endl;
  std::cout << "t2 : a " << t2->a() << " et b " << t2->b() << std::endl;
  std::cout << "t3 : a " << t3.a() << " et b " << t3.b() << "\n" << std::endl;

  return EXIT_SUCCESS;
}


Et je ne me rappelle plus qu'elle est la différence entre déclarer un objet à la façon de t1 et celle de t3.

Toute aide est la bienvenue.
Merci

4 réponses

Messages postés
6414
Date d'inscription
mardi 8 mars 2005
Statut
Modérateur
Dernière intervention
29 juillet 2020
363
Le souvenir est un peu loin mais il me semble que quand tu fais Test * t1 = new Test(2, 2); il crée d'abord un objet vide puis ensuite il le remplace par Test(2, 2)

La manière pour t3 est donc la plus appropriée.
Messages postés
3834
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
20 octobre 2021
124
L'un (t1) crée un allocation dynamique qui devra être libérée à l'aide de "delete".
L'autre (t3) crée un élément sur la pile en local. Sa libération est automatique.

La version deux (t3) est à préférer dans le cas que tu présentes.
La version 1 (t1) est utile dans certains cas (héritage polymorphique, liste ou vecteur d'objet, éviter la copie, etc...).

@Julien39: L'objet n'est pas crée "vide" puis remplacé. Il est crée normalement en passant par le constructeur dans les deux cas. C'est juste que dans le premier cas, on doit gérer soi même la destruction de l'objet.

D'une manière générale, la première solution est toujours à privilégier si les deux écritures sont équivalentes.

________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
Messages postés
2
Date d'inscription
samedi 1 décembre 2007
Statut
Membre
Dernière intervention
27 septembre 2010

Merci pour vos réponses.

L'exemple que j'ai donné là, n'est qu'un exemple de test. Je voulais me rafraîchir la mémoire sur le passage des objets par référence.

Ca remonte à loin, surtout quand on a fait que du Java ou du C entre temps.

@CptPingu : Par contre, une autre petite question suite à ton message. Si jamais j'ai un vecteur d'objets Test à faire, il vaut mieux que je le déclare comme :
std::vector<Test *> _vecTest;

J'ai bien compris?
Messages postés
3834
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
20 octobre 2021
124
Ça dépend :)

Si tu as un tableau d'objet qui ne va pas être copié, dont les éléments ne sont pas lourds, qui ne nécessite pas de tri, alors je te conseille un:
std::vector<Test> _vecTest;

Si tu as un tableau que tu comptes copier (sans pour autant copier toutes les valeurs de chacune des cases avec), ou qui comporte de gros objets, ou que tu souhaites trier à l'aide un std::sort, alors je te conseille un:
std::vector<Test*> _vecTest;

C'est au cas par cas, mais dans le doute, utilise un: std::vector<Test*> _vecTest;

________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question