Salut les geeks, j’ai remis mes gros doigts dans du C++ et j’ai qq difficultés avec nos amis les pointeurs.
Donc imaginons une classe lambda avec plusieurs variables membres qui sont des pointeurs char* (oui, String tout ça, je sais, mais ce n’est pas le but ici).
Ces pointeurs son mis à null dans les constructeurs, et puis j’appelle les différents setters. Dans les setters de chaque variable de type pointeur, je commence par faire un delete (le pointeur sera toujours valide ou null normalement) puis un new (ce sera plus lisible dans le code je pense).
Un exemple de classe avec deux pointeurs char* (nom et prenom) et deux entiers (age et taille):
[codebox]Personne::Personne(){
cerr << “[Personne] Constructeur par défaut” << endl;
nom = NULL;
prenom = NULL;
setNom(NULL);
setPrenom(NULL);
setAge(18);
setTaille(175);
}[/codebox]
un setter typique:
[codebox]void Personne::setNom(const char* const nom){
delete this->nom;
//QUESTION: serait-il utile de mettre le pointeur à null ici? des explications?
this->nom = new char[nom ? strlen(nom) : 0 + 1];
pourquoi tu fais
[codebox]
nom = null;
puis
setnom(null)
[/codebox]
si tu fais ton nom = null, ton setnom derriere sert a rien.
Et ton delete de ton setnom arrivera sur rien, vu que tu aura deja fait nom=null
Pourquoi, si le nom que tu passes est null, tu fais un *this->nom = 0 et pas = null ?
Moi je ferai ca :
[codebox]
void Personne::setNom(const char* const nom){
delete this->nom;
if (nom != null)
{
this->nom = new char[strlen(nom)];
strcpy(this->nom, nom);
}
else
{
this->nom = null;
}
Bizarre ton code. Un conseil, prends l’habitude de nommer les données membres de ta classe ainsi « m_nomdelavariable ». Et fait commencer le nom de tes classes par un C (comme classe). Puis d’autres détails.
Je remets une partie de ton code à jour pour en espérant répondre à ta question (j’ai pas bien compris ce que tu voulais)
C’est tordu ton truc … pourquoi tu crée une personne avec des infos nulles?
si c’est null, tu set juste pas l’attribut.
Et quand bien même, c’est le rôle du constructeur de les mettre à null au début, si besoin il y a, sans passer par les setters!
La personne avec des infos nulles, c’est parce que la classe doit subir toute une série de tests (genre affichage d’un vecteur d’objets mixtes, etc…) dans le cadre d’un dossier. Les setters dans le constructeur, c’était suggéré pour la modularité (genre changer juste le setter au lieu du constructeur par défaut, de celui de copie et celui d’initialisation si on modifie une variable).
Je viens d’éplucher le code en revue avec un pote, les erreurs étaient en fait dues à tout autre chose, mais j’en ai profité pour revoir la classe, et je pense que le résultat est plus propre comme cela:
D’abord le constructeur:
[codebox]Personne::Personne() : nom(NULL), prenom(NULL), ident(NULL), age(18), taille(175){
cerr << “[Personne] Constructeur par défaut” << endl;
//setNom("xxx");
}[/codebox]
un setter et un getter:
[codebox]void Personne::setNom(const char* const nom){
delete[] this->nom;
const char* const Personne::getNom() const{
return nom ? nom : “”;
}[/codebox]
Voilà, je ne m’amuse plus à allouer un octet pour rien, et le constructeur s’en trouve bien simplifié aussi (vive les initlists). ça vous parait moins horrible?
1/ Une donnée membre pointeur ça s’initialise à NULL dans le constructeur (ou alors avec une donnée pré-établie).
2/ Il faut toujours mettre en place un déstructeur qui fasse le delete() des pointeurs de cette manière :
[codebox]
if (this->monpointeur != NULL) {
delete(this->monpointeur);
this->monpointeur = NULL;
}[/codebox]
3/ Dans le setter tu dois faire le delete du pointeur s’il est non-nul avant de réaffecter la nouvelle adresse pointée :
[codebox]
public void setMonpointeur(void* pointeur) {
if (this->monpointeur != NULL) {
delete(this->monpointeur);
}
this->monpointeur = refpointeur;
}
[/codebox]
4/ A l’appel du getter toujours vérifier si le pointeur reçu est NULL avant de l’utiliser.
Après, le plus propre c’est de mettre en place des smart pointers (pointeurs intelligents), soit toi-même, soit via une lib (Boost par exemple).
Pas de delete, tu n’as pas alloué de tableau d’objet mais un tableau de type primitif. En général, le compilateur s’en sort, mais c’est pas beau quand meme.
Pour en rajouter un peu, je trouve que ton getter peut etre dangereux: tu retourne l’adresse d’une constante probablement cree sur la pile (le “”), si l’appelant s’avise de garder le pointeur pour (beaucoup) plus tards, tu risques, selon le compilo et la plateforme, de tomber sur un bout de memoire pas frais.
A ta place, soit je retournerais juste “nom”, et c’est a l’appelant de gerer le NULL, soit je retournerais l’adresse d’une constante vide, genre un “static const char[] = “””.
Mais en fait je retournerais NULL.
Tiens? Je pensais que le “” est un littéral qui n’est pas créé sur la pile mais dans le data segment?! Pour l’appelant, c’est un test fourni par un prof qui gère que dalle, c’est à notre classe de gérer le maximum de cas.
Dans la plus part des cas oui, mais sur certaine plateforme douteuses, c’est pas toujours certain: pour utiliser moins de memoire, certaine constantes seront construite sur la pile… Je sais, et oui, ca surprends toujours la premiere fois…
(j’ai pas bien compris ce que tu voulais)