Erreur de compilation C2057 : difficultés pour la résoudre

Version imprimable

22/09/2003, 13h48
karl3i

Erreur de compilation C2057 : difficultés pour la résoudre
Bonjour à tous,

je viens de récupérer les sources d'un programme qui devait marcher sous Unix. J'utilise Visual C++ 6.0. En compilant, j'obtiens l'erreur C2057 (expression constante attendue). Voilà le code qui pose problème.
Code:

1 2 3 4 void p3(int np) { int y[np]; // Cette ligne là
Je me suis donc renseigné sur C2057 Erreur compilation 2057. J'ai essayé l'exemple proposé et ai vérifié qu'il marchait bien.
Mais quand j'ai voulu l'appliquer à mon problème ca n'a pas bien marché.
Code:

1 2 3 4 void p3(const int np) // J'ai rajouté const sur cette ligne là { int y[np]; // Cette ligne là
Ca provoque toujours la même erreur.
Enfin j'ai fait un autre essai (en fait, j'en ai fait d'autres aussi, mais par souci de ne pas allonger trop le message, je ne présente que le suivant):
Code:

1 2 3 4 5 6 void p3(int np) { const int ntemp = 2; // Ceci est juste un essai pour essayer de voir d'où vient le problème int y[ntemp];
et cela m'a encore généré la même erreur !

Bref, si vous avez des idées d'où ca peut venir, ca m'aiderait bien,
Merci beaucoup,
Guilhem.
22/09/2003, 13h56
Anomaly

En effet on ne peut pas créer un tableau dont la taille est variable de cette manière. Tes 2 premiers exemples ne peuvent pas compiler, ce n'est pas standard (même si gcc les accepte). Le 3ème est acceptable en C++, mais pas en C, les const int n'étant pas des constantes, mais des variables non modifiables.

La solution dans ton cas est de créer dynamiquement le tableau en début de fonction et de le supprimer à la fin.
22/09/2003, 14h10
karl3i

Très claire ton explication. :)
Merci beaucoup, je m'en vais tester cela.
22/09/2003, 14h28
Gandalf

Citation:

Envoyé par Anomaly

En effet on ne peut pas créer un tableau dont la taille est variable de cette manière. Tes 2 premiers exemples ne peuvent pas compiler, ce n'est pas standard (même si gcc les accepte). Le 3ème est acceptable en C++, mais pas en C, les const int n'étant pas des constantes, mais des variables non modifiables.

La solution dans ton cas est de créer dynamiquement le tableau en début de fonction et de le supprimer à la fin.

Mais si les Variables Length Array font parti du standard : C99...

Visual n'est pas conforme à ce standard...
22/09/2003, 14h31
Anomaly

Cela se peut, je ne connais pas les détails du standard C99, je suis toujours au C89 ;) De toute façon jusqu'à encore récemment gcc ne supportait pas totalement ce standard-là non plus.
22/09/2003, 14h35
Gandalf

Il me semble que les VLA sont supportés depuis pas mal de temps...
22/09/2003, 14h52
Anomaly

Citation:

Envoyé par Gandalf

Il me semble que les VLA sont supportés depuis pas mal de temps...

En tant que extension GNU ! C'est documenté ainsi dans le manuel de gcc 2.95.3 ;)

Merci pour les précisions. Je me suis fait un petit programme test, avec allocation dynamique du tableau (cf code ci-dessous). Il marche bien. Je vais maintenant essayer de l'intégrer dans mon projet.

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
 
#include <stdlib.h> // To use malloc
#include <stdio.h> // To use printf
 
int main() 
{
	int np;
	int* y;
	int i;
	np = 100;
	//int *y;
y = (int *) malloc (np * sizeof(int));	// alloue un bloc de 100 entiers
// y=NULL;  // Test du cas d'erreur
if (y == NULL) 
{        /*    l'allocation a echoue    */ 
    printf ("l'allocation a echoue\n") ;    /*    message d'erreur    */ 
    exit (0) ;                              /*    arret du programme  */ 
} 
/*    l'execution de ce qui suit n'a lieu que si (y != NULL)       */ 
/*    on affecte des valeurs aux elements du tableau                  */ 
 
for (i=0 ; i<np ; i++)    /*    boucle de 0 a n-1 (np elements)         */ 
{ 
    y[i] = i ; /*    chaque element a la valeur de l'indice */ 
	printf ("Val : %d \n",i);
}                    
 
free (y); 
printf ("Mémoire libérée \n") ;  
 
return 1;
}

Ok, merci bcp Anomaly :). Voilà le code intégré à mon projet et ca marche bien.
NB : Code ci-dessous.

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
 
void p3(int np)
{
	int	j, jm;
    int* y;  // This is the pointer on the table
    y = (int *) malloc (np * sizeof(int));   // allocation of a 100 integer block
 
  // y=NULL;  // Error case check 
  if (y == NULL) 
	{        //    Allocation failure  
    printf ("Allocation failure, program will be terminated \n") ;    // error message  
    exit (0) ;                              // Termination of the program   
	} 
/*    Following will be executed only if (y != NULL)       */ 
 
 // int	y[np];  
/* This declaration cannot work with C compiler (it worked with Unix)
	All the lines before this line are EQUIVALENT to this single one
   */
 
(Mon traitement du tableau et autres... etc)
 
 free (y);  // Memory freed
printf ("Memory freed \n") ;  
}

22/09/2003, 18h36
Gnux

Bonjour
Je comprends pas cette partie du code:

Code:

y = (int *)

Pourquoi n'y a t-il rien qui pointe vers int? Pas de variable derrière le type
je comprends pas :(
Merci à celui qui prendra le temps de m'expliquer :)
22/09/2003, 21h58
karl3i
Salut,

tu veux parler de la ligne
Code:

1 2 y = (int *) malloc (np * sizeof(int));
?

En fait malloc te renvoie un pointeur. Et je le caste en int, c'est-à-dire que je le convertis en pointeur sur un int, parce que c'est le type contenu dans mon tableau.
La conversion, c'est justement la partie de code (int *).
Si j'avais eu un tableau de float, j'aurais fait (float *) malloc(np * sizeof(float)).

Je ne sais pas exactement ce que malloc renvoie à la base, peut-être un pointeur sur du void, autrement dit tu peux le faire pointer sur n'importe quoi en faisant la conversion.

J'espère que je n'ai pas raconté trop de bêtises :) et que tu as compris :)

Guilhem.