Discussion :

[Plomeg]

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 :

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

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

[Davidbrcz]

Ton code est faux.
Ceci est correct:

Code :

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

1
2
3
4
 
bloc* m_blocs=new bloc[81]; 
//bla bla
delete[] m_bloc;

[darrylsite]

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

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

*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:

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

[Plomeg]

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

Code :

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

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 donc je pensais que c'était bon...

Voilà l'erreur:

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

[darrylsite]

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

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 :

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

[Plomeg]

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

Code :

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

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...

[gb_68]

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 :

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

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 :

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

*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 :

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

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 :

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

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 :

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

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 :

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

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

Remarque :

Code :

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

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).

[gb_68]

Quelques essais plus tard (sous VS )

Code :

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

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 )

Code :

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

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 :

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

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)

[gelam]

Je vois trois solutions :

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
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();