Aujourdhui je vient de m’apercevoir que je pouvais appeler une fonction d’une classe perso de deux maniere differente , et … je voudrais juste comprendre la difference ?
La classe :
[cpp]
class Fichier
{
public: /* Constructeur */
Fichier(void);
/* Destructeur */
~Fichier(void);
/* Fonction qui dit si un fichier passer en parametre existe
* en retournant vrai ou faux
*/
BOOL EstCeQueFichierExiste (LPCSTR szNomFichier);
};
[/cpp]
Je peut faire une verification comme cela :
[cpp]
CSBFile i_CSBFile;
if (i_CSBFile.EstCeQueFichierExiste (_T(“C:\fichier.txt”)))
AfxMessageBox(“OK!”);
[/cpp]
Mais aussi comme cela :
[cpp]
Fichier *i_Fichier = new Fichier();
if (i_Fichier->EstCeQueFichierExiste (_T(“C:\fichier.txt”)))
AfxMessageBox(“OK!”);
delete i_Fichier;
[/cpp]
Ces deux methode marche, l’une instancie un objet dans une variable de type fichier, et appele la fonction de la classe, l’autre instancie une objet sur lequel je travaille via un pointeur, que je libere apres, d’apres ce que j’en comprends…
Mais il doit bien y avoir d’autre difference nan ? ( niveau perf, ou que sais je …)
Il faut que tu revois ton cours sur les pointeurs. La différence saute aux yeux.
Sinon, on utilise presque toujours des pointeurs. Et dans les langages plus récents, même si ils n’existent plus directement, c’est leur principe de mise en oeuvre qu’on applique.
En fait tout fonctionne avec des pointeurs, mais le développeur n’a plus à gérer l’aspect mémoire.
J’avoue rester couac et ne pas etre plus avancé… pourrais tu me donner plus de precision sur la difference ? ( Ca doit sans doute vous paraitre simple, mais cela fait tout juste un mois que je suis remis a la programmation …)
Lorsque tu dit que desormais on ne se soucis plus de l’aspect memoire, tu fait allusion aux allocations qui sont desormais faite “en cachette” comme par exemple dans les MFC genre CString ?
Je comprend pas trop la question perso.
Tu utilise deux class differentes (mise a part la difference pointeur / pas pointeur) pour tes exemples, et tu as le meme resultat ?. Ca doit etre une erreur je pense.
Autrement pour la difference entre pointeur et variable “normal”, tu peux simplement retenir qu’une variable dite “normal” est en fait “allouée” (c’est très très simplifié ce que je dit là) par le compilateur, et que donc tu ne t’occupe pas de ça vie, tandis qu’un pointeur doit etre alloué (et libéré) par tes soins.
Les pointeurs sont tres utiles, notamment pour tout ce qui est polymorphisme dynamique.
désolé pour le retard j’ete malade et sans ordinateur.
Gruiik > en fait les deux marche correctement et je voulait juste comprendre la difference mais
Fluff vient de dire que les deux methode ete equivalentes donc voila une reponse a ma question.
Sinon juste pour aller un peu plus loin, et pour comprendre ce qu’il vas se passer au moment de la compilation, j’aimerais compprendre comment se traduit ces deux methodes . ( Je prends comme exemple celui de ffluff, modifier pour qu’il puisse compiler :
[cpp]
class A{
public :
void foo() {return;};
};
void main () {
A objA;
objA.foo();
// est équivalent à :
A* objA2 = new A;
objA2->foo();
}
[/cpp]
)
Lorsque j’essaye de debugger le programme j’ai l’impression que la seconde maniere fait bcp plus de “travail” , … comment ca s’explique ? keskise passe dans la becane ?
[EDIT]
Plus precisement, pour le premier, j’ai l’impression que c’est transparent, il appel la fonction de la classe et retourne rien,
pour la deuxieme, il fait appelle a new, alloue de la memoire, pis la… je sais pas trop ce qu’il fait , ya plein de code qui defile, j’ai meme l’impression que l’allocation echoue ( d’apres les commentaire dans le fichier DBGHEAP.C ) …
Enfin jy comprend po grand chose… si qqun sy connait pour expliquer un peu ?
Qu’est qui prend le plus de ressource/temps ? la premiere ou deuxieme methode ?
En fait c’est bien ce que je pensai.
La différence c’est que dans l’un des cas tu utilises un pointeur contenant l’adresse de ton objet. Dans l’autre une variable du type de ton objet.
pourquoi new ?
Parceque lorsque tu déclares un pointeur vers un objet, l’espace mémoire pour cet objet n’est pas alloué.
new alloue la mémoire et appelle le constructeur spécifié.
Place l’objet construit en mémoire, et l’adresse de cet objet dans le pointeur.
Donc pour bien comprendre la différence relis ton cours sur les pointeurs en C++.
en regardant les cours a ma disposition ( sur le net ) , ce que j’en comprends c’est que le compilateur alloue automatiquement l’espace pour un type qu’il connait, j’entend pas la un type “natif”, pour une structure/classe/objet, c’est au programmeur de s’occupper de l’allocation/desallocation .
mais pourtant, une variable du type de mon objet, pour le compilateur , est ce qu’il interprete ca comme un pointeur ? logiquement oui.
Peut on donc dire que , a la compilation et a l’execution, le code generé sera semblable ? ( la difference sera donc seulement au niveau du code source, ou la methode par pointeur via le new, exigera de la part du programmeur plus de code, notemment s’occuper de la partie allocation/dessalocation)
J’espere que je ne suis pas trop lourd, car je vois bien que ca fait deux fois que tu me dit de relire les cours sur les pointeurs … j’essaye juste de comprendre, mais c’est vrai que defois faut m’expliquer longtemps lol
En tout cas merci pour vos reponses, … et votre patience
int main(int argc, char *argv[])
{
Point p;
p.x = 1;
p.y = 3;
cout << sizeof§ << endl;
Point pp; // ici pp ne contient rien, comme une variable initialisée mais non définie.
pp = new Point(); // la je suis plus sur si faut l’ ou pas
pp->x = 1;
pp->y = 3;
[cpp]
class A{
public :
void foo() {;}; //void donc pas de returne :o
};
void main () {
A objA;
objA.foo();
// est équivalent à :
A* objA2 = new A;
objA2->foo();
delete objA2;
}
[/cpp]
Lors de la compilation le compilateur connais exactement la place que vas occuper un objet de type A. En faisant :
1°) A objA; c’est lors de la compilation que la mémoire est alloué.
2°) A* objA2= new A; c’est lors de l’execution que la mémoire est alloué.
Entre l’écriture 1 et 2 il y a beaucoup de différence pour le programmeur ainsi que pour l’exécution.
Dans le 1°) tu dis de facon implicite de construire un objet de type avec le constructeur par défaut et pour l’allocation tu laisse le compilo faire
Dans le 2°) tu dis : “je veux un pointeur vers un objet de type A”
Il s’avère que dans la même instruction tu le construit l’objet de type A.
[cpp] #include #include
class A{
std::string nom;
public :
A(std::string nom)
void foo() {std::cout << nom << “\n”;}; //void donc pas de returne :o
};
void main () {
A obj1(“objet 1”);
A obj2(“objet 2”);
obj1.foo();
obj2.foo();
A* objA1;
A* objA2;
*objA1 = &obj1;
*objA2 = &obj2;
objA1->foo();
objA2->foo();
delete objA1;
delete objA2;
}
[/cpp]
Dans cette exemple je crée 2 objet A. Aprés je crée 2 pointeurs qui eux vont juste pointer sur un objet de type A.
objA1 pointe sur obj1 et objA2 sur obj2
Ici on voit bien que les pointeurs ne sont pas lier a des new forcement et qu’il permettent d’acceder a des variables d’une autre facon.
Les pointeurs sont le plus souvent utiliser quand la construction d’un objet n’est pas completement défini lors de la compilation. exemple un tableau dont les dimensions sont rentré par l’utilisateur. Le compilo n’a aucun moyen de savoir la taille d’un tel tableau.
ayé, j’ai eu le declic.
Je vous remerci vraiment beaucoup pour vos explications et les liens, Je me sent enfin a l’aise avec toutes ces techniques et les notions pointeurs/references.
… j’essaye juste de comprendre, mais c’est vrai que defois faut m’expliquer longtemps lol