Discussion :

[pythagor]

Bonjour,

Je developpe beaucoup en Java et je suis actuellement des cours de C++

Je travaille sur des exercices et là il y en a un sur lequel je bute.

Le voici : je dispose d'une classe F qui a pour attributs un tableau et sa taille.
Son constructeur est vide mais un setter petmet d'initialiser (et changer) le tableau et sa taille.
La classe dispose aussi d'une methode affichant les valeurs du tableau sur la console

Le but de l'exo et d'utiliser un tableau (et non un vector) et de résoudre le problème du cas où on supprimerait le tableau avant d'appeler la méthode print()

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
 
#include <iostream>
#include "f.h"
 
using namespace std;
 
F::F()
{
}
F::~F()
{
    delete[] tab;
}
 
void F::setTab( int *_tab, int _tabLength)
{
    tab=_tab;
    tabLength=_tabLength;
}
 
void F::print()
{
    int i=0;
    for(i=0;i<tabLength;i++)
        cout<<"TAB["<<i<<"]="<<tab[i]<<endl;
}

je n'ai pas mis le header qui contient simplement les signature des fonctions ainsi que le tableau et sa taille en attribut.

Le problème est que si dans le main on fait ceci dans le main:

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
 
F* f = new F();
 
    int * tab= new int[10];
    int length=0;
    tab[length++]=20;
    tab[length++]=15;
    tab[length++]=10;
    tab[length++]=20;
 
 
 
    f->setTab(tab,length);
    delete[] tab;
    f->print();

ça plante ce qui est normal.

Je dois modifier le code en utilisant nottament un ou des "const" pour ne plus qu'il soit possible d'avoir ce problème.

Avez vous une idée ?

Merci beaucoup

[ternel]

Prends un crayon, et exécute ton main à la main, en représentant chaque variable.
Suppose que malloc retourne l'adresse 0x2A. (C'est arbitraire, bien sûr)

Que fait print, et pourquoi ce n'est pas le problème?
Elle affiche le contenu du tableau d'une variable membre (privée).

Où est le problème?
variable membre privée = variable que la classe garantie de toujours être correcte.
Ce n'est apparemment pas le cas.

Regarde qui modifie ou initialise cette variable, c'est là que tu trouveras les problèmes.

Au passage, que se passe-t-il si on appele deux fois setTab() avant print()? ou pas du tout?

[Bousk]

Bah je vois pas 300 solutions, et absolument rien lié au const.
print devrait être const, mais c'est juste par const-correctness, et n'a rien à voir avec ton "problème".
La classe devrait juste devenir propriétaire du tableau, ou s'en faire une copie.

[ternel]

Et initialiser son pointeur dans son constructeur par défaut

[stendhal666]

Bienvenue dans les joies du C++ !

Un premier conseil: quand tu codes en C++, oublie toutes tes certitudes Java. Tu dois gérer toi même ta mémoire! Pour éviter de le faire manuellement, c'est-à-dire éviter de mettre des new et des delete dans ton code, il faut que tu encapsules la gestion de la mémoire dans des classes comme ta classe F: le code appelant F ne doit pas voir la gestion de la mémoire.

Dans ce cas simple, tu devrais avoir:
- un constructeur sans argument:

Code :

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

F() : ptr(nullptr), size(0) {} // la syntaxe (recommandée) est Cteur() : member(init), member2(init2), ... , membern(initn) { corps du constructeur }

- un autre pour créer un tableau:

Code :

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

F(int sz) : ptr(new int[sz]), size(sz) {}

-et bien sûr un destructeur qui libère la mémoire:

Code :

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

~F() { delete[] ptr; }

Si tu veux étoffer ta classe avec des "setters" il faut réfléchir un peu plus au sens de l'opération. En C++ tu as deux types de sémantique:
- copy: F f = ptr_vers_tableau <=> copie le tableau sur lequel pointe ptr_vers_tableau dans le tableau sur lequel pointe f.ptr; ce sont maintenant deux tableaux distincts
- move: F f = ptr_vers_tableau <=> f.ptr = ptr_vers_tableau; ptr_vers_tableau = nullptr. Un seul tableau, donc un seul possesseur du tableau. Sinon arrive au problème que tu as eu

Lequel veux-tu?

[ternel]

C'est un bon conseil, il manque juste le mot clé: RAII (ou parfois RFID). C'est le sigle qui désigne cette technique, et qu'on trouve appliquée dans std::vector (un tableau de ce type), std::unique_ptr.
Cette technique peut s'appliquer pour d'autre type de recssources comme des connexions réseaux, une image, un fichier (std::fstream, par exemple), et plein d'autres choses, encore.

[pythagor]

merci à tous pour vos réponses rapides

Je trouvais aussi bizarre que la consigne dise qu'en maniant un const on puisse résoudre le problème.

Effectivement je trouve que le fait de recopier le tableau dans le constructeur (et donc en devenir l'unique propriétaire) est une excellente idée !

Le move aussi est une bonne idée. Mais je pense que je vais plutôt utiliser un recopiage pour ne pas avoir de problème au cas où le pointeur vers le tableau utilisé dans le setter est const.

Petite question de synthaxe :
@stendhal666 tu dis que la bonne sythaxe est

Code :

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

F() : ptr(nullptr), size(0) {}

Je trouve la synthaxe

Code :

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

F() : {ptr=nullptr; size=0;}

plus simple (puisque plus proche de java)

Y a t il une difference entre les deux façons d'ecrire le constructeur ?

Merci beaucoup

[Ehonn]

Pour le constructeur : FAQ C++ : Mes constructeurs doivent-ils utiliser les listes d'initialisation ou l'affectation ?

[stendhal666]

La FAQ est un peu mystérieuse pour un débutant sur le sujet, avec ses sémantiques de valeur et d'entité (même si j'ai plussoyé l'intervention de Ehonn).

Il y a un certain nombre choses impossibles à faire avec la syntaxe F() { membre1 = X; ... }
Par exemple si membre est une référence:

Code :

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

1
2
3
4
5
class F {
  int& _i;
public:
  F(int& i) { _i = i; } // ne compilera pas: "la référence F::_i& n'est pas initialisée dans la fonction F::F(int&)"
};

En fait, avant le '{' du constructeur tu peux décider de l'initialisation des membres de la classe. Après le '{', ils ont été initialisés à leur valeur par défaut (je simplifie: la question de l'initialisation automatique est compliquée mais ce sera pour une autre fois) et tu leur assignes de nouvelles valeurs. Donc tu perds en performance et en possibilités (les références, pour un exemple simple, comme elles doivent toujours être initialisées).

Par rapport à Java, C++ te donne un contrôle très fin sur tout ce que tu fais. C'est très bien si tu sais quoi en faire, très frustrant sinon. Mais je te donne à nouveau le même conseil: oublie Java quand tu codes en C++! Malgré certaines ressemblances générales dans la syntaxe et les conventions d'indentation, ce sont des langages parfaitement différents, avec chacun ses forces et ses faiblesses. Donc tu devrais presque au contraire choisir les syntaxes les plus éloignées de Java :-)

[fenkys]

Bonjour,

Le programme tel que tu l'as ecrit dans le post original oublie quatre éléments fondamentaux quand on travaille avec des pointeurs.
1) Il faut toujours vérifier un pointeur avant de l'utiliser.
2) Désallouer un pointeur ne change pas sa valeur. Elle libère juste la mémoire pointée.
3) Tu dois avoir autant d'allocation que de désallocation de pointeur.
4) On pourrait rajouter que désallouer un pointeur va invalider tous les pointeurs qui pointent sur la même zone mémoire.

Je te laisse voir en quoi ton programme n'est pas conforme à ces quatre principes.


PS: le RAII dont parle Leternel est un outils puissant qui permet de vérifier au moins deux de ces quatre points. Il ne se limite pas aux pointeurs d'ailleurs.

[Bousk]

4) On pourrait rajouter que désallouer un pointeur va invalider tous les pointeurs qui pointent sur la même zone mémoire.

Oui parce qu'on désalloue uniquement la mémoire pointée.
Et btw pointeur !== d'allocation dynamique de mémoire. Il est nécessaire pour ça, mais n'a rien à voir. Un pointeur vers un objet de la stack ça existe.

[Jerome2568]

Ton probleme est que durant ton set (ligne 17 de ton f.cpp) tu copies le pointeur, pas les donnees.
Donc a la ligne 14 de ton main, les données sont detruites, la ligne suivante, quand print essaye d'y acceder, sa te retourne n'importe quoi.

Comme fenkys le dit si bien pense RAII, ton constructeur et setter ne doivent faire qu'un et surtout copier les données.