Probleme test if avec tableau

Version imprimable

Bonjour,
Je voudrais faire un test if sur des valeurs d'un tableau
Le programme doit remplacer les valeurs voisines identiques par des espaces (pour faire des "trous" dans le tableau)
J'ai codé comme cela et j'ai une erreur qui dit "error : subscripted value is neither array nor pointer nor vector"

Merci de votre aide
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 void figures(char* tableau) { int i=0; int j=0; for (i=0; i<10; i++) { for(j=0; j<15; j++) { if((tableau[i][j]==tableau[i+1][j]) && (tableau[i][j]==tableau[i+2][j])) { tableau[i][j]=' '; tableau[i+1][j]=' '; tableau[i+2][j]=' '; } printf("%c", tableau[i][j]); } printf("\n"); } }

19/11/2014, 20h03
diogene
tableau est du type char*. Donc tableau[i] est du type char (et n'est donc pas une adresse). Alors que signifie tableau[i][j] ?
C'est comme si tu écrivais
Code:

1 2 char c; ... c[j] ... // ???
Pour savoir quelle doit être la déclaration correcte de tableau comme paramètre de la fonction pour pouvoir écrire tableau[i][j] et avoir le résultat correct, il faut en savoir plus sur la nature de l'argument lors de l'appel à cette fonction.
19/11/2014, 20h08
esired
Bonsoir. Ta variable
Code:

1 2 char* tableau
représente un pointeur que tu peux utiliser comme un vecteur (tableau à une dimension).
Mais dans ton code, tu l'utilises comme s'il s'agit d'un tableau à deux dimensions quand tu fais
Code:

1 2 tableau[i][j]
Ce qui ne peut pas marcher. Tu dois donc faire que
Code:

1 2 if (tableau[i] == tableau[j])

Mais je l'ai déclaré dans mon main() là c'est un sous prog qui l'utilise !
Ca c'est mon programme complet !

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#include <stdio.h>
#include <stdlib.h>
 
void figures(char* tableau);
 
int main()
{
//---------------------------------------------------
// Initialisation horloge pour nombre aléatoire
//---------------------------------------------------
 
   srand(time(NULL));
 
//---------------------------------------------------
// Initialisation variables
//---------------------------------------------------
 
    int tmp=0;
    char caractere='0';
    char tableau[10][15];
    int i=0;
    int j=0;
 
//------------------------------------------------------------------------------------------------------------------------------------
// Affectation des valeurs pour le tableau :
// Une variable temporaire prend une valeur aléatoire entre 0 et 4 (5 valeurs possibles).
// Pour chaque valeur de la variable temporaire, le caractère affiché dans le tableau prend une valeur différente selon ce code :
//
// S = Soleil
// F = Fraise
// P = Pomme
// O = Oignon
// M = Mandarine
//------------------------------------------------------------------------------------------------------------------------------------
 
    /* Pour chaque ligne */
    for(i=0; i<10; i++)
    {
        /* Pour chaque colonne */
        for(j=0; j<15; j++)
        {
            tmp=rand()%5; // Variable temporaire prenant une valeur entre 0 et 4 (5 valeurs possibles)
 
             if(tmp==0) {caractere='S';} // Si la variable temporaire est égale à 0, le caractèe affiché est S
             if(tmp==1) {caractere='F';} // etc.
             if(tmp==2) {caractere='P';} // etc.
             if(tmp==3) {caractere='O';} // etc.
             if(tmp==4) {caractere='M';} // etc.
 
            tableau[i][j]=caractere; // On stocke le caractère dans la case du tableau correspondante
            printf("%c ", tableau[i][j]); // Affichage de la case du tableau
        }
        printf("\n"); // Saut de ligne a la fin du remplissage de la ligne pour mettre en forme le tableau
        system("pause");
        figures(tableau); // Appel du ss prog
    }
    return 0;
}
 
void figures(char* tableau)
{
    int i=0;
    int j=0;
 
    for (i=0; i<10; i++)
    {
        for(j=0; j<15; j++)
        {
               if((tableau[i][j]==tableau[i+1][j]) && (tableau[i][j]==tableau[i+2][j]))
               {
                   tableau[i][j]=' ';
                   tableau[i+1][j]=' ';
                   tableau[i+2][j]=' ';
               }
 
            printf("%c", tableau[i][j]);
        }
         printf("\n");
    }
}

19/11/2014, 20h54
esired
Le problème vient de la déclaration de la fonction. Il faut
Code:

1 2 void figures(char *tableau[]);
au lieu de
Code:

1 2 void figures(char *tableau);
19/11/2014, 20h57
Sve@r
Citation:

Envoyé par adicarbo

Mais je l'ai déclaré dans mon main() là c'est un sous prog qui l'utilise !

Bonjour
Si on te dit que tu fais mal quelque chose, ce n'est pas la peine de dire "mais c'est moi qui l'ai fait ainsi". On le sait bien que c'est toi, mais ça reste mal fait !!!
Citation:
Envoyé par adicarbo

Code:

1 2 3 4 5 6 7 8 9 10 11 12 void figures(char* tableau); int main() { ... char tableau[10][15]; ... figures(tableau); // Appel du ss prog return 0; }
C'est bien ce que Diogène et esired t'ont dit. Si tu déclares char tableau[10][15] alors chaque tableau[i][j] est un char donc chaque tableau[i] est un char[15] (on peut aussi le voir comme un char * si on schématise) et donc tableau est alors un char[10][15] (on peut se le représenter aussi comme un char ** mais c'est juste pour donner une illustration du niveau d'indirection et non une équivalence réelle).

Donc si tu envoies tableau à ta fonction, celle-ci ne peut pas le stocker dans un char *. Mais si tu lui demandes quand-même de le faire (au fait, ton compilo t'a rien dit ???), elle n'a alors aucun moyen de pouvoir aller taper dans tableau[i][j]. Si on te donnais une grille sans te dire combien il y a de lignes et de colonnes, et qu'on te demande la case F4, tu pourrais la trouver toi ???
Citation:
Envoyé par esired

Le problème vient de la déclaration de la fonction. Il faut

Code:

1 2 void figures(char *tableau[]);
Attention, tu dois impérativement donner la taille sinon c'est comme pour la grille donnée dans l'exemple ci-dessus: le C est incapable de calculer l'index de la case à partir des indices.

Seule la dernière dimension peut-être omise (parce qu'elle n'entre pas en ligne de compte dans le calcul)..
19/11/2014, 21h02
adicarbo

Donc il suffit que je mette void figures (char* tableau[]) pour que ça marche ? Comme ça on sait que tableau est un pointeur de tableau et non un autre type de pointeur c'est bien ça ? Même si je l'ai déclaré comme un tableau à la base ? Je ne comprend pas exactement la différence entre char char * et char ** dans ce cas là en fait...

Désolé je ne voulais pas paraître comme tu l'a décrit .. j'essayais de bien expliquer ce que j'avais fait ... :?
19/11/2014, 21h05
Médinoc

Tu n'as pas déclaré le paramètre tableau avec le bon type. Tu devrais déclarer et définir la fonction ainsi:

Code:

void figures(char tableau[10][])

Ou encore, en utilisant le formalisme pointeur au lieu du formalisme tableau, tu pourrais la déclarer
void figures(char (*tableau)[10]), mais c'est imbitable pour un débutant.
19/11/2014, 21h05
SkyZoThreaD

Déclares ce que tu veux où tu veux il reste le problème de pointeur/tableau qui à mes yeux est le coté le plus compliqué du C.
Ton tableau déclaré statiquement dans le main est un tableau à deux dimensions qui est bien déclaré et à première vue, il est bien utilisé dans les boucles "for" qui suivent. Cependant, quand tu cherches à le passer par pointeur en argument de la fonction figures() il faut utiliser le bon type.
Il faut que tu comprenne que les "array" du C ne sont pas des objets comme en java par exemple, ce sont des pointeurs (adresse mémoire) vers le début d'un bloc d'une série d'éléments les uns à la suite des autres dans la mémoire de la machine.
En gros un "char tableau[]" c'est pareil que "char *tableau". Par contre "char tableau[8]" est bien un pointeur aussi mais vers 8 "chars" qui se suivent en mémoire.
Donc tu ne peux pas faire passer ton tableau 2d pour un "char*" le compilateur t'as vu venir de loin :roll:. C'est un "char**" ou un "char[][]" si tu préfères.
19/11/2014, 21h07
Médinoc

@SkyZoThreaD: Attention, un vrai tableau 2D (comme celui qui est sujet ici) n'est pas implicitement convertible en type**.
19/11/2014, 21h08
SkyZoThreaD

Citation:

Envoyé par Médinoc

Tu n'as pas déclaré le paramètre tableau avec le bon type. Tu devrais déclarer et définir la fonction ainsi:

Code:

void figures(char tableau[10][])

Ou encore, en utilisant le formalisme pointeur au lieu du formalisme tableau, tu pourrais la déclarer
void figures(char (*tableau)[10]), mais c'est imbitable pour un débutant.

C'est vrai que c'est chaud à biter :mrgreen: j'ai cru voir un pointeur de fonction au début :oops:
19/11/2014, 21h08
adicarbo

Ah ok j'ai compris en fait quand j'ai tableau[i][j] c'est bien une valeur donc mon if n'est pas faux mais le problème c'est qu'avant j'ai mis en paramètre un char* donc un tableau[i] seulement qui représente non pas une valeur mais toute une ligne par exemple..

Merci beaucoup ! :D
19/11/2014, 21h10
SkyZoThreaD

Citation:

Envoyé par Médinoc

@SkyZoThreaD: Attention, un vrai tableau 2D (comme celui qui est sujet ici) n'est pas implicitement convertible en type**.

Ah bon?! pourquoi?

edit: ok effectivement c'est carrément une grosse erreur de prog.:aie:
19/11/2014, 21h15
Sve@r

Citation:

Envoyé par adicarbo

Donc il suffit que je mette void figures (char* tableau[]) pour que ça marche ? Comme ça on sait que tableau est un pointeur de tableau et non un autre type de pointeur c'est bien ça ? Même si je l'ai déclaré comme un tableau à la base ?

Il faut d'abord comprendre que ta grille en 2D, pour le C, ce n'est qu'une seule et unique grosse suite de cases (donc un tableau en 1D). Et donc il est obligé de transformer tes indices en index.
Ainsi case[i][j] correspond à la case mémoire i * nb_de_colonnes + j. Et ce principe s'étendra à n dimensions (sur un char tableau[10][15][20], alors tableau[i][j][k] donnera la case i * 15 + j * 20 + k.

Seule en 1D il n'y a aucun soucis car 1D dans ton programme c'est 1D en mémoire.

Si maintenant tu as un char tableau[10], alors tableau (le nom pur) c'est l'adresse de son premier élément. Et cette adresse, passée à une fonction, pourra être stockée soit dans un char pt[], soit un char pt[10], soit un char *pt au choix. A ce niveau, c'est pareil.

Si maintenant tu as un char tableau[10][15], alors tableau (toujours le nom pur) c'est toujours l'adresse de son premier élément. Mais ce premier élément, lui, ne représente plus un char mais un tableau de char. Et comme le C aura toujours besoin de savoir qu'il y a 15 colonnes pour faire ses calculs, tu pourras stocker cette adresse soit dans un char pt[][15], soit un char pt[10][15], soit un char *pt[15]. Mais surtout pas un char **pt (même si l'analogie avec le premier exemple laisse penser que c'est possible).

Citation:

Envoyé par adicarbo

Je ne comprend pas exactement la différence entre char char * et char ** dans ce cas là en fait...

Un char * c'est l'adresse d'une case mémoire contenant un caractère, un char ** c'est l'adresse d'une case mémoire contenant l'adresse d'une autre case mémoire qui, elle, contient un caractère. Et si on met de coté ce besoin connaitre N-1 dimensions, on peut faire une analogie entre [] et *, [][] et ** et etc...

Au final d'après ce que tout le monde m'a dis j'ai mis ça et ça marche !

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
 
void figures(char tableau[10][15]);
 
int main()
{
//---------------------------------------------------
// Initialisation horloge pour nombre aléatoire
//---------------------------------------------------
 
   srand(time(NULL));
 
//---------------------------------------------------
// Initialisation variables
//---------------------------------------------------
 
    int tmp=0;
    char caractere='0';
    char tableau[10][15];
    int i=0;
    int j=0;
 
//------------------------------------------------------------------------------------------------------------------------------------
// Affectation des valeurs pour le tableau :
// Une variable temporaire prend une valeur aléatoire entre 0 et 4 (5 valeurs possibles).
// Pour chaque valeur de la variable temporaire, le caractère affiché dans le tableau prend une valeur différente selon ce code :
//
// S = Soleil
// F = Fraise
// P = Pomme
// O = Oignon
// M = Mandarine
//------------------------------------------------------------------------------------------------------------------------------------
 
    /* Pour chaque ligne */
    for(i=0; i<10; i++)
    {
        /* Pour chaque colonne */
        for(j=0; j<15; j++)
        {
            tmp=rand()%5; // Variable temporaire prenant une valeur entre 0 et 4 (5 valeurs possibles)
 
             if(tmp==0) {caractere='S';} // Si la variable temporaire est égale à 0, le caractèe affiché est S
             if(tmp==1) {caractere='F';} // etc.
             if(tmp==2) {caractere='P';} // etc.
             if(tmp==3) {caractere='O';} // etc.
             if(tmp==4) {caractere='M';} // etc.
 
            tableau[i][j]=caractere; // On stocke le caractère dans la case du tableau correspondante
            printf("%c ", tableau[i][j]); // Affichage de la case du tableau
        }
        printf("\n"); // Saut de ligne a la fin du remplissage de la ligne pour mettre en forme le tableau
    }
    system("pause");
    figures(tableau);
    return 0;
}
 
void figures(char tableau[10][15])
{
    int i=0;
    int j=0;
 
    for (i=0; i<10; i++)
    {
        for(j=0; j<15; j++)
        {
               if((tableau[i][j]==tableau[i+1][j]) && (tableau[i][j]==tableau[i+2][j]))
               {
                   tableau[i][j]=' ';
                   tableau[i+1][j]=' ';
                   tableau[i+2][j]=' ';
               }
 
            printf("%c ", tableau[i][j]);
        }
         printf("\n");
    }
}

J'utilise la notation des tableaux car je ne maitrise pas vraiment celle des * pour les pointeurs ... Parce qu'en mettant ** ça ne marche pas alors après je crois d'après vos messages (mais ce n'était pas très clair) qu'il faudrait mettre char* tableau[] enfin bon ça marche avec char tableau[10][15]

20/11/2014, 12h00
diogene
Citation:

je crois d'après vos messages (mais ce n'était pas très clair) qu'il faudrait mettre char* tableau[] enfin bon ça marche avec char tableau[10][15]

Non, tu veux passer en argument un tableau de (10) tableaux de (15) char, or char* tableau[] déclare non pas un tableau de tableaux (de char) mais un tableau de pointeurs (sur char) ce qui n'est pas la même chose.

Lors du passage comme argument d'une fonction d'un tableau d'éléments de type X (X pouvant d'ailleurs être des tableaux), on spécifie à l'appel comme argument le nom du tableau. Cet identificateur a pour valeur l'adresse du premier élément du tableau, et c'est cette valeur qui est transmise à la fonction (en C tous les arguments sont transmis par valeur, sans exception).
Le type du paramètre est donc fondamentalement X*.

La syntaxe du C admet que pour la déclaration des paramètres on puisse écrire indifféremment ce type comme X* ou comme X[]. C'est l'unique cas (déclaration d'un paramètre d'une fonction) où il y a la possibilité d'avoir une écriture "pointeur" équivalente à une écriture "tableau". Dans le cas où on utilise la notation "tableau", une dimension peut être spécifiée mais est totalement ignorée par le compilateur.

Exemple :
Code:

1 2 3 4 5 6 7 X t[10]; //On peut donc écrire indifféremment ... fonc(X* tab){...} ... fonc(X tab[]){...} ... fonc(X tab[10]){...} // appel ... fonc(t);
C'est le même principe qui est utilisé si X est un tableau de N éléments de type Y: Y t[10][15]; :
Le paramètre tab est encore X* : adresse d'un tableau de N éléments Y soit Y (*tab)[N] . On voit bien que *tab est un Y[N] donc un tableau de N éléments Y (les parenthèses sont obligatoires car Y* tab [N] désigne un tableau de N pointeurs sur Y)

On peut également, comme avant, utiliser la notation "tableau" dans cette déclaration de paramètre en écrivant qu'il s'agit d'un tableau de X donc d'un tableau de tableaux de N Y : Y tab[N][] . Là aussi, on peut spécifier une dimension Y tab[N][M] mais M sera totalement ignorée par le compilateur. Par contre, la mention de la dimension N est obligatoire (le compilateur a évidemment besoin de savoir la taille des éléments du tableau).

La fonction ne pourra être utilisée que pour des tableaux dont les éléments seront des tableaux de exactement N éléments Y, ce qui constitue une sérieuse limitation à prendre en compte.