Discussion :

[membreComplexe12]

Bonjour tous,

pour commencer: je suis débutant en C++.

J'ai un problème sur la syntaxe à utiliser pour l'appel à un objet, je ne comprends pas trop comment ca fonctionne..

==> j'ai un fichier main.cpp et un AAA.cpp, AAA.cpp permet de lire un fichier texte et de sauvegarder le contenu dans des variables.

1°) voici comment je l'aurais codé en C (et j'ai donc fait la meme chose en cpp):

main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
include <iostream>  
#include "AAA.h"
int main()
{
    AAA();
}

AAA.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
include <iostream>  
#include "AAA.h"
 
void BBB();
 
void AAA()
{
    "fait certaines choses";
    "fait appel a void BBB pour d'autres choses"
 
}
 
void BBB()
{
     fait des trucs
}

et tout cela fonctionne tres bien

2°) la personne qui me manage sur ce projet m'a dit: on programme en C++ donc il faut utiliser les objets et m'a dit de faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
include <iostream>  
#include "AAA.h"
using namespace std;
int main()
{
    AAA *aaa = new AAA();
    delete aaa;
}

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include <iostream>
#include "AAA.h"
using namespace std;
AAA::AAA()
{
"la personne met ici le contenu de ma fonction AAA.cpp"
"et fait appel à BBB"
}
 
void AAA::BBB()
{
     fait des trucs
}

à présent je ne comprends plus grand chose car en C++ je n'ai jamais utiliser le constructeur pour faire de telles choses mais plutot pour générer des objet. Ici j'ai l'impression que mon construcuteur sert de fonction...

De plus je ne comprends pas pourquoi il fait appel à l'objet de cette facon... new ne sert pas à allouer de la memoire dynamiquement? pourquoi faire le delete ensuite???

==> d'habitude quand je fait appel un constructeur j'utilise simplement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

aaa(variable1, variable2)

et le constructeur me créer un objet avec ces valeurs comme attributs donc pour quoi faire ici appel à "new" et mettre un pointeur.... ??


je suis totalement perdu

[exe2bin]

Salut ,
faire AAA *aaa = new AAA c'est juste pour instancier un objet de la
classe AAA de façon dynamique (et non statique)

[membreComplexe12]

salut, merci d'avoir pris le temps de repondre !

Salut ,
faire AAA *aaa = new AAA c'est juste pour instancier un objet de la
classe AAA de façon dynamique (et non statique)

et quel est l'intérêt de faire cela pour un objet? d'habitude quand "j'appel" un constructeur je ne le fait pas et je fais seulement quelque chose du type:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

aaa(x,y,z)

?

edit:
pourquoi il utilise un pointeur dans ce cas là?

[exe2bin]

Exactement la même utilité qu'un passage par pointeur comme paramètre de
fonction en C par exemple !

[membreComplexe12]

Exactement la même utilité qu'un passage par pointeur comme paramètre de
fonction en C par exemple !

ce qui me parait bizarre est que lorsque j'utilise un pointeur c'est que j'ai renvoyé à une fonction une adresse avec le signe & or ici il n'y a aucune adresse renvoyée...?

et en ce qui concerne l'allocation dynamique, pourrais tu me dire qu'es ce que tu en pense (cf. question ci dessus)

[exe2bin]

Lorsque tu passe une variable à une fonction par exemple :
foo(int);
tu passes uniquement une copie de la valeur entière .
alors si ta fonction a pour but de changer la valeur de l'int il faudra que tu
lui passe l'adresse de celui-ci et non plus sa copie : foo(int *);
Je pense que tu le sais déjà .
Aussi ,un entier représente (en général) 4 octets en memoire et ne pose pas de problème à copier .
Par contre une classe composée d'attributs et de methodes en grands nombres
(de pointeurs aussi) est impossible à transmettre par valeur !!
En ce cas il faut bien passer l'adresse d'une classe et non une copie .

[membreComplexe12]

Lorsque tu passe une variable à une fonction par exemple :
foo(int);
tu passes uniquement une copie de la valeur entière .
alors si ta fonction a pour but de changer la valeur de l'int il faudra que tu
lui passe l'adresse de celui-ci et non plus sa copie : foo(int *);
Je pense que tu le sais déjà .
Aussi ,un entier représente (en général) 4 octets en memoire et ne pose pas de problème à copier .
Par contre une classe composée d'attributs et de methodes en grands nombres
(de pointeurs aussi) est impossible à transmettre par valeur !!
En ce cas il faut bien passer l'adresse d'une classe et non une copie .

en effet, merci pour ces precisions, je crois avoir saisi.

A+

[jblecanard]

si ta fonction a pour but de changer la valeur de l'int il faudra que tu lui passe l'adresse de celui-ci et non plus sa copie : foo(int *);

Ce n'est pas tout à fait juste. En C++, il existence pour cela le mécanisme des références. Essayez ce code par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <iostream>
 
// Passage par copie
void fonction1(int a)
{
	a++;
}
 
// Passage par référence
void fonction2(int& a)
{
	a++;
}
 
 
int main(int argc, char * argv[])
{
	int i = 1;
	std::cout << i << std::endl;
	fonction1(i);
	std::cout << i << std::endl;
	fonction2(i);
	std::cout << i << std::endl;
    return 0;
}

L'allocation dynamique est utile pour plusieurs raisons dont (ce n'est pas exhaustif) :
- On veut que l'objet existe toujours en dehors du scope de création (impossible avec l'allocation statique)
- On veut allouer beaucoup de mémoire : la pile n'est pas faite pour ça, il faut donc allouer dans le tas.

Ta question est pertinente 21did21 car dans ton exemple, utiliser une allocation dynamique est inutile (dans ce cas précis).

De plus, tu remarques que faire le traitement dans le constructeur et détruire l'objet juste après est bizarre. Et tu as raison, ce n'est pas une bonne manière de faire.

Pour faire cela à la sauce objet, il y a deux manières :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
 
// interface
class AAA
{
public:
	// ctor
	AAA();	
	// dtor
	~AAA();
 
	void traitement();
};
 
// Implémentation
AAA::AAA()
{}
 
AAA::~AAA()
{}
 
void AAA::traitement()
{
	std::cout << "J'effectue quelque chose" << std::endl;
}
 
int main(int argc, char * argv[])
{
	AAA monObjet;
	monObjet.traitement();
    return 0;
}

Eventuellement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
int main(int argc, char * argv[])
{
	AAA * monObjet = new AAA();
	monObjet->traitement();
	delete monObjet;
    return 0;
}

Mais cela semble inutile ici. Ou alors, une méthode qui fait crier certains puristes mais je ne lui ai toujours pas trouvé de défaut majeur, c'est utiliser une classe de services statiques. Cela revient au même que que créer une fonction libre, mais ça permet de cloisonner et de regrouper ensemble les fonctions qui ont un sens.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
 
// interface
class AAA
{
public:
	static void traitement();
 
private:
	AAA();	
	~AAA();
};
 
// Implémentation
void AAA::traitement()
{
	std::cout << "J'effectue quelque chose" << std::endl;
}
 
int main(int argc, char * argv[])
{
	AAA::traitement();
    return 0;
}

Bien entendu, la bonne méthode à choisir dépend de ton traitement réel, dont je n'ai pas connaissance ici.

[membreComplexe12]

merci beaucoup pour toutes ces precisions jblecanard!
il me semblait bien qu'il y avait un truc bizarre