[pied de mamouth]

Bonjour,
Lors d'un tp je me suis fait engueuler par le prof parceque j'avais écris un truc du genre :

Code:

int saisie (char prnoms[][LMAX],int dim)
{
	char temporaire[dim];

Donc j'utilise une variable pour créé un tableau ce que, normalement, le compilateur n'accepte pas. Sauf que quand j'ai testé ça chez moi gcc me l'a compilé, et le programme fonctionnait sans problème.
Alors je me demande si c'est un coup de bol à eviter de retenter ou si gcc permet de faire ce genre de chose sans problème.
Et pis désolé de vous avoir dérangé si on trouve facilement la réponse avec google.

[Aurelio]

bah si ta variable global est défini tout au début du programme il n'y a pas de problème(si elle n'est pas modifié) sinon pour les tableaux dynamiques il faut utiliser les pointeurs.(très relou mais quand tu sais bien t'en servir c'est pratique).

Sinon pour ton truc gcc ne fait pas la gueule parce qu'il n'y a pas d'erreur mais effectivement faut pas faire (meme si ca marche).

[zours]

Y'a effectivement aucune raison que le compilo n'accepte pas une telle syntaxe.
Mais y'a aucune raison non plus pour qu'on l'utilise, c'est très moche.
En règle générale, essaie plutôt d'utiliser des tableaux dynamiques, c'est tout de même plus propre et plus adaptatif. Bon, certes, y'a des cas dans lesquels un tableau statique est plus adapté, mais c'est pas la règle

[pied de mamouth]

ok, merci pour vos réponses. Ca m'éviterat d'écrire de la merde en DS.

[neoflo]

Tu compiles avec quel CFLAG.

Ajoutes en un peu pour voir si il crit, par exemple : -Wall -W -Wmain -pedantic -std=c99

[pied de mamouth]

Salut,
J'ai essayé les options de compilo ( j'avais déjà mis Wall.
Maintenant j'ai deux erreurs qui apparaissent à la compilation :

Code:

tp3-2v3.c:0: malformed option'-D_STRICT_ANSI_-trigraphs'
tp3-2v3.c:0: warning: file does not end in newline

Par contre si j'enlève l'option -std=c99, je ne vois plus la première erreur et j'ai un warning pour ma déclaration de tableau.
Sinon pourquoi tu voulais que j'ajoute -Wall et -Wmain ? Normalement si on fait un -Wall on active -Wmain, non ?

[neoflo]

Il y a également -W.

Ta deuxième erreur vient du fait que tu n'as pas fait de retour à la ligne tout à la fin (c'est à dire là ou ya })

Attention, -Wall contrairement à ce que pourrait suggèrer son nom n'ouvre pas tous les Warnings mais seulement ceux jugé utile par les développeurs de gcc (ou g++).

-std=c99 c'est pour vérifier que ton source respecte le standard C99. C'est l'option -ansi pour le standard ANSI, mais je crois que les commentaires en C++ // ne passe plus (surtout avec le -pedantic qui permet de vérifier la bonne écriture par rapport à la norme C)


Enfin, bref, en tout cas, tu as eu un warning sur ton tableau


En fait,... je crois que Wmain est inclu dans -W

[neoflo]

J'ai testé :

Code:

#include <stdlib.h>
#include <stdio.h>

void test(int t[][4])
{
 int i;

 for(i=0; i<4;i++)
   printf(" %d ", t[1][i]);


}

int main(void)
{
    int t[3][4] = {{0,0,0,0}, {1,1,1,1}, {2,2,2,2}};

    test(t);

  return EXIT_SUCCESS;
}

Avec les options de compilation, aucun problème. L'exécution, aucun problème.

A mon avis, ton prof a craqué.

Par contre, le problème, c'est que tu ne connais qu'une dimension du tableau donc ta fonction est susceptible de tout faire planter.

[pied de mamouth]

En effet si j'avais tapé ça mon prof aurait été heureux mais en gros j'ai déclaré mon tableau avec une variable. Comme tu l'a fait il n'y a pas de problème la taille est bien défini et le compilateur sais à l'avance combien de place il va falloir réservé pour le tableau.

Sinon du coté des erreurs de compilation c'est quoi la première ?
Voici le début de mon code :

Code:

#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <ctype.h>

#define NMAX 10
#define LMAX 48

int analyse(char dir[]);
char *strstrip (char str[]);
....

Perso j'ai plutot l'impression que c'est parceque l'option de compilation est mal passée à gcc.
Voici la ligne que génère mon make :
gcc -Wall -ansi -pedantic -std=c99   -c tp3-2v3.c -o tp3-2v3.o

[neoflo]

La définition la : int analyse(char **No Sms**[]);

M'a l'air suspecte... Genre, il manque une virgule, un type, ou je ne sais quoi.

Quand tu dis : déclarer un tableau avec une variable, tu parles des défintions #define ? Elles seront remplacés lors de la précompilation, ça ne devrait pas poser de problème normalement.

[pied de mamouth]

quand je dis déclarer un tableau avec une variable je fais référence à mon premier post où on voit quelque chose du genre :
char tab[dim] où dim est un variable.
A ce moment là le prof avait raison de m'engeuler puisque meme si ca peut fonctionner bah "c'est pas bien !".

Pour ce qui est de la ligne que tu as tenté de citer je n'avais pas mis "int analyse(char **No Sms**[]);" mais plutot " int analyse (char tableau[]);

[neoflo]

En principe, si on a besoin de tableau bidimensionnel pour représenter un certain type de donnée de bonne qualité.

On crée un type abstrait de donnée du genre :

Code:

struct {
 int* tableau;
 size_t tailleH;
 size_t tailleY;
} Image;

Pis des opérateurs du style :

Code:

int imageCreer(struct Image*, size_t tailleH, size_t tailleY);
void imageDetruire(struct Image*);

int imageEcrire(struct Image*, size_t posH, size_t posY, int valeur);

...

Ca permet de plus de vérifier le bon appel au donnée.

Genre tu peux récuperer une erreur du type : imageEcrire(image, -1 ,-2,3); qui retournerait EXIT_FAILURE par exemple.

[pied de mamouth]

ok merci pour les infos. J'essairai d'appliquer ca pour mon prochain code

[neoflo]

Ca dépend à quel point tu en as besoin.

Si ce n'est que pour une fonction, je ne pense pas que ça vaille la peine.

Mais si tu arrives à dégager des types abstraits et à écrire comme ça, tu es sur le bon chemin . Et petit à petit, tu pourras créer des modules en cachant l'implémentation des choses... (en gros, faire de la programmation objet en C)

[neoflo]

Je signale au passage que ce n'est pas toujours bien de déclarer des gros tableaux comme ça. Notamment car le tableau est directement mis sur la pile du programme (qui est de taille assez limité par rapport au tas).

Par exemple, le programme :

Code:

int main(void)
{
int t[1000][1000];

	return EXIT_SUCCESS;
}

Fait un dépassement de pile chez moi.

Alors que :

Code:

int main(void)
{
int* t = malloc(1000*1000*sizeof(int));
	return EXIT_SUCCESS;
}

Ne provoque aucun problème.