les objets sont-ils des pointeurs ?

Bonjour a tous !

j'ai un soucis de compréhension au niveau des objets en c++... Je suis plus habitué au java, et c'est ma premiere en c++, alors peut-etre que ma question va paraitre simple en fait ^^

Juste pour replacer le contexte : je travaille avec memcached, une librairie en développée en C qui permet d'utiliser un serveur de mémoire cache (qui se comporte comme une table de hachage). Les prototypes des deux fonctions principales sont les suivants :

Code:

---

1 2	memcached_return_c rc = memcached_set(..., char* key, size_t key_length, char* value, size_t value_length, ...) char * value = memcached_get(..., char* key, size_t key_length, size_t * value_length, ...)

---

les objets stockés sont passés en paramètre sous forme de pointeurs de chaines de caractères (cast).
Seulement voila... Certains objets contiennent eux-même des attributs, etc, qui sont soit des pointeurs, soit autre chose, et la memcached memcached_set stocke tout, donc même les pointeurs, sans s'occuper de ce qui est pointé par le pointeur.

Tout ca pour en venir a ma petite question ^^
Quand je déclare un objet par exemple avec :

Code:

---

1 2	MonObject c = new MonObject() std::string c ("blabla")

---

ou bien quand j’accède a un attribut d'une classe (qui est protected, ou via un getter),

Code:

---

1 2	MonObject c = monInstance.getter() MonObject c = monInstance.parametre

---

qu'est-ce que j'obtiens ? un pointeur, ou autre chose ? comment est représenté la memoire : est-ce que je dois faire

Code:

---

*c

---

pour pouvoir accéder a la zone mémoire qui contient effectivement l’objet lui-même ? Et est-ce la même chose pour les objets string ? Tout ça est un peu confus pour moi qui habituellement fait du java, je ne suis pas sur de faire la différence (au niveau de la gestion de la memoire) lorsqu’on utilise un struct et lorsqu'on utilise un objet ^^

merci a vous ;)

Bonjour,

pour faire rapide : imagine la mémoire comme un grand tableau.
Chaque case du tableau est identifiée par son adresse mémoire.
Chaque case du tableau peut contenir un élément
- un type basique (int, bool, ...)
- un type complexe (struct/class) (où chaque membre sera attribué lui-même dans une case)
- une adresse d'une autre case (y compris d'elle-même mais là c'est "inutile" ?^^) : le fameux pointeur

Quand tu écris MonObjet m; la mémoire pour stocker m est créée sur la stack.
La particularité de la stack est que dès qu'on sort de son scope l'objet est supprimé.

Code:

---

1 2 3 4 5

{ MonObjet m; m.doSomething(); } m.doSomething(); // compile error

---

Dans ce cas tu peux récupérer le pointeur vers m via &m mais pour utiliser ce pointeur il faut s'assurer que l'objet pointé (m) existe toujours. Sinon ça crash.

Code:

---

1 2 3 4 5 6 7 8 9

MonObjet* ptrm; { MonObjet m; ptrm = &m; // les 2 lignes suivantes sont identiques m.doSomething(); ptrm->doSomething(); } ptrm->doSomething(); // ça compile, ça crash à l'exécution

---

Quand tu écris MonObjet* m = new MonObjet; la mémoire pour stocker m est créée sur la heap, et m est un pointeur vers cette mémoire.
La heap n'est pas supprimé automatiquement, il faut la supprimer explicitement (via delete dans ce cas) grâce au pointeur que l'on possède.
Dans le cas où tu trimballes le pointeur, il faut s'assurer que l'objet pointé existe toujours également.

Code:

---

1 2 3 4 5 6 7 8

MonObjet* ptrm = new MonObjet; MonObjet* ptrm2 = ptrm; // les 2 lignes suivantes sont identiques ptrm->doSomething(); ptrm2->doSomething(); delete ptrm; ptrm->doSomething(); // crash ptrm2->doSomething(); // crash

---

Code:

---

1 2	MonObject c = new MonObject() std::string c ("blabla")

---

Tu ne pourras pas écrire ce code, parce que c est redéfini.
Le premier c sera un pointeur vers un objet MonObjet;
le second est un objet créé sur la stack.

Code:

---

1 2	MonObject c = monInstance.getter() MonObject c = monInstance.parametre

---

Même début, mais là ça dépend du getter.
Si le getter retourne un const& (ce qui est généralement le cas d'un getter bien écrit pour retourner un type complexe), il y aura une copie d'effectuée.

Citation:

---

qu'est-ce que j'obtiens ? un pointeur, ou autre chose ? comment est représenté la memoire : est-ce que je dois faire

---

Tant que tu ne vois pas de *, il ne s'agit pas d'un pointeur. Sauf à utiliser les smart_pointer.
L'opérateur pour récupérer l'adresse d'une variable est & .

Effectivement, en Java, tu ne manipules jamais un objet directement, tu emploies une référence, qui elle est un lien vers l'objet.

Attention, le terme référence ci-dessus doit s'entendre au sens Java du terme, pas au sens C++. Exemple :

Code:

---

1 2 3 4 5

// Code Java Maclasse obj; // crée une référence vers un objet de type Maclasse et l'initialise à null obj = new Monobjet(); // instancie un objet de type Maclasse qui est referencé par la variable obj obj.coucou(); // appel de la méthode coucou de l'objet référencé par obj

---

En C++, par défaut, tu peux manipuler un objet directement (par valeur). Exemple

Code:

---

1 2 3 4

// Code C++ Maclass obj; // Crée un objet de type Maclasse en appellant son constructeur par défaut obj.coucou(); // appel de la méthode coucou de l'objet obj

---

Dans ce cas-là, la variable obj contient directement l'objet. Comme toutes les variables automatique, elle sera détruite à la fin du bloc courant (en appellant le destructeur de Maclasse). obj n'est pas une référence à un objet situé ailleurs.

Tu as également la possibilité de créer dynamiquement ton objet sur le tas avec new, comme tu le fais en Java. En C++, new renvoie un pointeur vers l'adresse mémoire de l'objet nouvellement créé.

Code:

---

1 2 3 4 5

Maclasse* obj = NULL; // obj est un pointeur qui ne pointe sur rien obj = new Maclass; // on alloue de la mémoire et on construit un objet de type Maclasse. obj contient l'adresse de cet objet. obj->coucou(); // appelle la méthode coucou de l'objet pointé par obj delete obj; // détruit l'objet pointé par obj (appel de destructeur) et libération de la mémoire réservée pour celui-ci.

---

Comme tu le vois, obj est explicitement déclaré comme étant un pointeur et l'appel de méthode utilise l'opérateur flèche au lieu du point. Si j'avais écris, comme tu l'as fait, j'aurais eu les erreurs de compilation suivantes :

Code:

---

1 2 3

Maclasse obj = new Maclasse(); // Erreur impossible de convertir un Maclasse* en Maclasse. obj.coucou(); // erreur, le pointeur obj ne possède pas de membre coucou (c'est l'objet pointé qui en possède un).

---

Donc, quant à ta question sur ce qui est renvoyé par tes getters, tout dépend de leur signatures. Ils peuvent renvoyer un objet, une référence à un objet, ou encore un pointeur vers un objet. Regarde simplement quel est leur type de retour.

merci beaucoup pour ta réponse !! C'est beaucoup plus clair, mais il me reste encore quelques question :roll:

Par exemple quelle est la différence entre écrire

Code:

---

MonObject c = new MonObject()

---

et écrire

Code:

---

MonObjet* ptrm = new MonObjet;

---

?

Je ne sais pas si je me représente bien, mais si je veux "accéder a la zone mémoire ou est réellement stocke l'objet" (c'est toujours dans l'optique de ne pas me perdre avec des pointeurs quand je stocke des choses avec memcached), mais je comprends ça (avec des notations pas tres bien choisies, mais c'est pour donner l'idee : la fleche represente le fait de "pointer"):

Code:

---

1 2	c -> la zone memoire ou est stockee l'objet ptm -> un autre pointeur -> la zone memoire ou est stockee l'objet

---

et donc, si je veux toujours "accéder a la zone mémoire ou est réellement stocke l'objet", est-ce que ca a du sens de faire :

Code:

---

1 2	MonObject c = new MonObject(); *c;

---

Donc du coup, comme j'utilise le template pair defini dans la librairie standard :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

template <class T1, class T2> struct pair { typedef T1 first_type; typedef T2 second_type;   T1 first; T2 second; pair() : first(T1()), second(T2()) {} pair(const T1& x, const T2& y) : first(x), second(y) {} template <class U, class V> pair (const pair<U,V> &p) : first(p.first), second(p.second) { } }

---

si je fais

Code:

---

std::pair <std::string,std::string> cntWithKey (key,cnt);

---

comme les deux membres sont des classes, toujours a cause de memcached qui gere mal les pointeurs, si je veux reelement recuperer ce qui est en memoire, je dois faire qqchose comme ça ?

Code:

---

*(cntWithKey.first());

---

merci beaucoup pour vos explications !!!

Merci beaucoup Niark13, desole j'ai commence a repondre alors que tu n'avais pas encore repondu ^^

Ok maintenant j'ai encore mieux compris, c'est la difference entre

Code:

---

MonObject c;

---

et

Code:

---

MonObject c = new MonObject()

---

que je n'avais pas saisis.

Et donc, par exemple avec le template pair,

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

template <class T1, class T2> struct pair { typedef T1 first_type; typedef T2 second_type;   T1 first; T2 second; pair() : first(T1()), second(T2()) {} pair(const T1& x, const T2& y) : first(x), second(y) {} template <class U, class V> pair (const pair<U,V> &p) : first(p.first), second(p.second) { } }

---

si je fais

Code:

---

1 2 3 4

str::string cnt ("blaba"); str::string key ("123456789"); std::pair <std::string,std::string> cntWithKey (key,cnt);

---

je suis sur que je cntWithKey contient toute l'information, sans pointeurs ? (Ca ne m'arange pas, parce que ca plante a ce niveau ^^ comme je programme dans un projet beaucoup plus vaste, je n'ai acces qu'a une fonction de log pour unique aide au debuggage, je ne peux pas savoir exactement quel est le soucis ^^ mais par elimination, je croyais que le crach venait du fait que pair etait un couple de pointeurs, et pas un couple contenant bien les deux objets au complet...)

merci encore ;)

Citation:

---

Envoyé par Rhyos

Par exemple quelle est la différence entre écrire

Code:

---

MonObject c = new MonObject()

---

et écrire

Code:

---

MonObjet* ptrm = new MonObjet;

---

?

---

La première écriture te renverra une insulte du compilateur.*
Essayer de compiler c'est un premier pas pour savoir ce qui est correct ou non. Si la syntaxe est mauvaise à la base, ça sert à rien d'aller plus loin.

* en supposant que MonObject n'est pas un typedef farfelue qui camoufle un pointeur.

Pour un utilisateur venant du Java, j'ai tendance à conseiller de ne pas utiliser new dans un premier temps. Jusqu'à ce que tu en ressentes vraiment la nécessité, et même à ce moment, il se pourrait que d'autres alternatives s'offrent à toi. Donc pour passer en paramètre et éviter la copie, utilise les références (au sens C++ du terme) : void fonction(std::vector<int> &un_vecteur);.

D'ailleurs, je me souviens que dans un livre C++ (Accelerate C++), il ne parle des pointeurs que vers le chapitre 10-11. Comme quoi, ce n'est pas spécialement la première chose à apprendre/utiliser en C++.

Merci pour vos réponses, je pense avoir bien compris maintenant :)
Bousk désolé de ne pas avoir testé, mais ayant été un peu perdu et en train de travailler aussi, je n'ai pas eu le temps pour ca :roll:

en tout cas merci a tous :ccool:
je marque resolu

Citation:

---

Envoyé par Rhyos

je suis sur que je cntWithKey contient toute l'information, sans pointeurs ? (Ca ne m'arange pas, parce que ca plante a ce niveau ^^ comme je programme dans un projet beaucoup plus vaste, je n'ai acces qu'a une fonction de log pour unique aide au debuggage, je ne peux pas savoir exactement quel est le soucis ^^ mais par elimination, je croyais que le crach venait du fait que pair etait un couple de pointeurs, et pas un couple contenant bien les deux objets au complet...)

---

Oui et non : les objets std::string contiennent des pointeurs, eux. Si tu les utilises normalement, ça ne pose pas de problème puisqu'ils ont un constructeur de copie et un opérateur d'affectation qui se charge de gérer correctement ces pointeurs, mais si tu fais une copie "brute" bit par bit (et c'est, si j'ai bien compris, ce qui se passe dans la bibliothèque memcached), ça peut tout à fait ne pas fonctionner (la mémoire pointée utilisée en interne par std::string peut avoir été libérée).