Problême de new[]

Bonjour,

J'ai un problême avec un programme que je compile sans aucun problême mais qui plante toujours à l'éxécution. Finalement j'ai trouvé que le problême venait de new[] et je ne comprends pas pourquoi ça ne marche pas. J'ai cherché un peu partout mais je n'ai rien trouvé... Voici le code:

Code:

---

1 2 3 4 5 6 7

bloc* m_blocs[81]; //déclaration *m_blocs = new bloc[81]; //tentative d'appel de new[]   m_blocs[0]->GetValeur() // pas plantage m_blocs[1]->GetValeur() // pas plantage m_blocs[2]->GetValeur() // plantage du programme

---

Merci d'avance

Ton code est faux.
Ceci est correct:

Code:

---

1 2 3 4

bloc* m_blocs=new bloc[81]; //bla bla delete[] m_bloc;

---

Citation:

---

bloc* m_blocs[81]; //déclaration

---

Avec cette declaration, tu crée un tableau de 81 pointeurs de bloc.

Citation:

---

*m_blocs = new bloc[81]; //tentative d'appel de new[]

---

est equivalent à:m_bloc[0]=new bloc[81]; m_bloc[0] est donc un tableau de 81 bloc.
Ce qui est loin de ce que tu veux faire (enfin, je crois). Tu devrais plutot faire:

Citation:

---

bloc* m_blocs;
m_blocs = new bloc[81];
m_blocs[0]->GetValeur() ;
m_blocs[1]->GetValeur() ;
m_blocs[2]->GetValeur() ;

---

En fait j'avais déjà essayé ça:

Code:

---

m_blocs = new bloc[81];

---

Seulement voilà: Code::Blocks ne veut pas compiler et après quelques essais j'ai mis une étoile devant et ça marchait à la compilation :yaisse2: donc je pensais que c'était bon...:aie:

Voilà l'erreur:

error: incompatible types in assignment of 'bloc*' to 'bloc*[81]'

Je crois savoir d' où vient l' erreur:

Citation:

---

bloc* m_blocs;
m_blocs = new bloc[81];
m_blocs[0]->GetValeur() ;
m_blocs[1]->GetValeur() ;
m_blocs[2]->GetValeur() ;

---

On crée en quelque sorte un tableau de 21 bloc donc les m_blocs[i] ne sont plus des pointeurs mais des blocs. On doit donc remplacer les "->" par des "." pour avoir :

Citation:

---

bloc* m_blocs;
m_blocs = new bloc[81];
m_blocs[0].GetValeur() ;
m_blocs[1].GetValeur() ;
m_blocs[2].GetValeur() ;

---

Non le problême n'est (pour l'instant) pas là. Le problême est que le code ne compile à cause de ça:

Code:

---

m_blocs = new bloc[81];

---

Après quelques essais, j'ai trouvé que m_blocs est considéré comme bloc*[81] et new bloc[81] comme bloc* seulement. Le plus étrange est que si j'enlève le [81], le type ne change pas et reste bloc* !! Et de plus le comportement du programme reste similaire (bel et bien comme si [81] n'était pas là). Là je dois dire que je n'y comprends plus rien...

Bonjour,

d'abord il me semble que l'opérateur [] est prioritaire sur * (pour les définitions de type, je crois que c'est la même priorité). Donc quand tu écris

Code:

---

bloc* m_blocs[81];

---

tu déclares un tableau fixe de 81 pointeur vers des objets de type bloc. D'où l'erreur à la compilation.
Et en faisant

Code:

---

*m_blocs = new bloc[81];

---

tu n'affectes que la première case de ton tableau fixe avec un pointeur vers un autre tableau de 81 "bloc". Les 80 autres cases contiennent des pointeurs invalides (valeurs aléatoires ?).
Ceci est ce que tu veux faire je pense :

Code:

---

bloc (* m_blocs)[81];

---

mais new bloc[?] renvoie toujours un bloc * (car la valeur entre crochets peut également être une variable, donc non connue à la compilation).
Tu peux forcer l'affectation d'un bloc * en TabBloc * par un cast :?

Code:

---

1 2 3 4 5

typedef bloc TabBloc[81]; bloc (*m_blocs)[81]; // ou comme cela //TabBloc *m_blocs; m_blocs = (TabBloc *)new bloc[81];

---

Enfin, m_blocs étant un pointeur vers un tableau de [81] bloc, écrire

Code:

---

1 2 3

m_blocs[0]... m_blocs[1]... m_blocs[2]...

---

revient à considérer que m_blocs est un tableau de tableaux de [81] bloc !!! Il faut écrire

Code:

---

1 2 3

(*m_blocs)[0].GetValeur() ; (*m_blocs)[1].GetValeur() ; (*m_blocs)[2].GetValeur() ;

---

Remarque :

Code:

---

1 2 3

m_blocs[0][0].GetValeur() ; m_blocs[0][1].GetValeur() ; m_blocs[0][2].GetValeur() ;

---

passe aussi (mais moins adapté dans ce cas).

Quelques essais plus tard :mrgreen::mrgreen::mrgreen: (sous VS :aie:)

Code:

---

1 2 3 4 5 6 7 8

typedef bloc TabBloc[81]; TabBloc * m_blocs;   m_blocs = new TabBloc; (*m_blocs)[0].GetValeur() ; (*m_blocs)[1].GetValeur() ; (*m_blocs)[2].GetValeur() ; delete m_blocs;

---

ne passe pas (toujours incompatibilité de types :koi:)

Code:

---

1 2 3 4 5 6 7 8

typedef bloc TabBloc[81]; TabBloc * m_blocs;   m_blocs = new TabBloc[1]; (*m_blocs)[0].GetValeur() ; (*m_blocs)[1].GetValeur() ; (*m_blocs)[2].GetValeur() ; delete [] m_blocs;

---

passe et fonctionne (ou du moins semble fonctionner ;))

Code:

---

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

struct TabBloc { bloc Tab[81]; };   TabBloc * m_blocs;   m_blocs = new TabBloc; m_blocs->Tab[0].GetValeur() ; m_blocs->Tab[1].GetValeur() ; m_blocs->Tab[2].GetValeur() ; delete m_blocs;

---

fonctionne (encore heureux :), la solution la plus propre à mon sens)

Je vois trois solutions :

Code:

---

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 33 34 35 36 37

class Bloc{ public : int GetValeur(){return 123;} };     int main() { // Tableau dynamique de blocs Bloc* m_blocs ; m_blocs = new Bloc[81] ;   m_blocs[0].GetValeur(); m_blocs[1].GetValeur(); m_blocs[2].GetValeur();   // Tableau de pointeurs de blocs Bloc* m_blocss[81] ; for( int i=0; i<81; i++ ) m_blocss[i] = new Bloc;   m_blocss[0]->GetValeur(); m_blocss[1]->GetValeur(); m_blocss[2]->GetValeur();     // Tableau dynamique de pointeurs de blocs Bloc** m_blocsss ; m_blocsss = new Bloc*[81] ;   for( int i=0; i<81; i++ ) m_blocsss[i] = new Bloc;   m_blocsss[0]->GetValeur(); m_blocsss[1]->GetValeur(); m_blocsss[2]->GetValeur();

---