Discussion :

[Tooth]

Bonjour à tous,

Je crée ce sujet afin d'avoir de l'aide et des explications sur le langage C. Je suis étudiant 1ère année dans un DUT Informatique et notre langage de travail est le C. Cependant n'ayant jamais programmé en C je suis un peu perdu et j'ai besoin de quelques conseille et un suivit sur un projet.

Le projet est le suivant : réaliser en version graphique (à l'aide de la bibliothèques "graphics.h" . A savoir que nous n'utilisons pas "sdtlib.h" mais une bibliothèques créée par nos professeurs pour éviter qu'on se serve sur internet. Aussi, nous devons toujours déclarer nos tableaux.

Donc, actuellement j'ai définit toutes mes structure (joueur, pion, tableau simple, tableau 2d), j'ai crée le tableau 2 dimensions, j'ai crée en version graphique la grille (grille 8*8).

Maintenant je dois tester si mon tableau fonctionne correctement, mais vu que c'est un type crée (pion) je ne sais pas comment faire, après cela je ne sais pas trop quoi faire pour continuer mon programme.

Je ne cherche en aucun cas qu'on me fasse le projet, juste avoir de l'aide et des conseils pour apprendre à programmer proprement en C.

Je vos met en pièces jointes mon code actuelle ainsi que le sujet sous format PDF.

Je vous remercie de vos réponses;

Tooth

[Kannagi]

Je voudrais un petit éclaircissement mais tu dis

A savoir que nous n'utilisons pas "sdtlib.h"

vous n'avez pas le droit de utilisez ?
Parce que cette lib standard possède quelque fonction incontournable (notamment malloc et rand).

Sinon pour ton code déjà tu pourrais créer des .h (pour tes structure) , vu que tu aura plusieurs .c , j'imagine c'est un projet le code pourra être assez conséquent.

Après tu ne dis pas ce qui te bloque donc déjà avant de vouloir coder , met sur papier ce que tu as besoin , les règle du jeu ect , après tu regarde comment avoir acces et/ou les algo a mettre en place , et ensuite tu prog.

[Tooth]

Effectivement nous n'avons pas le droit d'utiliser Stdlib(pour éviter de prendre les codes tout fait sur internet) mais on n'a une bibliothèque équivalente faites par les prof de l'IUT qui contient toutes les fonctions.

Merci du conseil, je vais tenter de faire mes arbres programmatiques sur papier et ensuite je passe à la prog.

[Sve@r]

Le projet est le suivant : réaliser en version graphique (à l'aide de la bibliothèques "graphics.h" . A savoir que nous n'utilisons pas "sdtlib.h" mais une bibliothèques créée par nos professeurs pour éviter qu'on se serve sur internet. Aussi, nous devons toujours déclarer nos tableaux.

Mouais. Je ne pige pas trop cette dernière phrase. Un tableau c'est une suite de variables d'un type précis. Donc déjà que les variables il faut les déclarer à fortiori les tableaux aussi. Et sans passer par une librairie, qu'elle soit d'origine ou créée par les profs...

Maintenant je dois tester si mon tableau fonctionne correctement, mais vu que c'est un type crée (pion) je ne sais pas comment faire, après cela je ne sais pas trop quoi faire pour continuer mon programme.

Non, en lisant ton énoncé on lit que tu dois faire valider tes structures. Ce n'est pas la même chose. Et puis là non plus je ne pige pas la phrase "mon tableau fonctionne correctement"...

[Tooth]

Bonjour,

Mouais. Je ne pige pas trop cette dernière phrase. Un tableau c'est une suite de variables d'un type précis. Donc déjà que les variables il faut les déclarer à fortiori les tableaux aussi. Et sans passer par une librairie, qu'elle soit d'origine ou créée par les profs...

On doit impérativement déclarer nos longueurs de tableau ainsi que leur type, nous devons donc définir des structures (ce qui n'est pas indiqué dans la plupart des cours).

Non, en lisant ton énoncé on lit que tu dois faire valider tes structures. Ce n'est pas la même chose. Et puis là non plus je ne pige pas la phrase "mon tableau fonctionne correctement"...

Non, on fonctionne un peu différemment puisqu'on est en apprentissage, on ne fait pas valider nos structure car on à moins de temps.
Ce que je voulais dire par voir si le tableau fonctionne correctement c'est crée une fonction qui m'affiche mon tableau de pion.

Donc, j'ai un peu avancer dans ce mini-projet et je rencontre un problème au moment de la compilation , j'ai des erreurs au niveau du parcours de mes tableaux avec ce message : "Subscripted value is neither array nor pointer nor vector". Je sais d'où vient le problème mais pas comment le corrigé (même si je sais ce qu'est un pointeur, nous n'avons pas encore eu le cour portant dessus).

[Médinoc]

Cette fonction est fausse:

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
tab_grille creer_grille (int x, int y)// crée un tableau deux dimensions
{
  assert (x>0);
  assert(y>0);
  tab_grille grille;
  int i;
 
  grille.x = x;
  grille.y = y;
 
  grille.data2 = malloc (x *sizeof (tab_pion));
 
  for (i=0 ; i<x ; i++)
  {
    grille.data2 = malloc (y *sizeof (pion)); //Surtout cette ligne, en fait
  }
  return grille;
}

[Tooth]

La fonction est fausse mais l'idée est bonne ? Car je ne vois pas comment faire autrement un tableau 2 dimensions.

Si je résous ce problème, mes erreurs à la compilation seront eux aussi résolu ?

[gerald3d]

En informatique il n'existe qu'une seule dimension pour les tableaux. La manière dont on accède à leurs données est un "trompe l'œil" pour aider l'humain dans sa lecture.

Ainsi ton tableau de dimension (x,y) est en fait un bloc mémoire linéaire de taille x.y. À ce nombre il faudra multiplier le nombre d'octets nécessaires pour coder la taille d'une donnée.

[Médinoc]

@Tooth: Au minimum, il faudrait passer à ceci:

Code C :

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

grille.data2[i] = creer_tab(y, blanc);

Notes annexes:

1. Évite d'utiliser x et y pour des dimensions, car généralement on les utilises pour des coordonnées.
   Une convention (parmi tant d'autres) est d'appeler des dimensions cx et cy ("c" pour "count", il me semble) à la place.
2. Comme dit par gerald3d, tu peux aussi faire un "vrai" tableau à deux dimensions (en fait, un tableau à une seule dimension de x*y cases) plutôt qu'un tableau de tableaux.

[Sve@r]

...
Une convention (parmi tant d'autres) est d'appeler des dimensions cx et cy ("c" pour "count", il me semble) à la place.

Moi j'utilise bêtement "i" et "j"

Comme dit par gerald3d, tu peux aussi faire un "vrai" tableau à deux dimensions (en fait, un tableau à une seule dimension de x*y cases) plutôt qu'un tableau de tableaux.

Moi je suis pas trop d'accord. Déjà le C permet des accès [i][j] alors pourquoi s'en passer ? C'est vrai que c'est plus optimisé de taper directement dans tab[i*L+j] que de taper dans tab[i][j] mais pour un TP de ce genre, a-t-on vraiment besoin d'optimiser autant ?
Surtout qu'ensuite il faudra analyser le jeu. Avec un tableau en 2D, vérifier que 4 pions sont alignés c'est assez facile. Avec un tableau 1D, il faudra alors opérer des conversions de coordonnées plus ou moins fastidieuses. Je dis pas que c'est pas faisable mais faut se souvenir que c'est un TP de cours pour débutant et peut-être limité dans le temps...

La fonction est fausse mais l'idée est bonne ? Car je ne vois pas comment faire autrement un tableau 2 dimensions.

Voici la syntaxe pour créer un tableau dynamique en 2D (tableau d'int pour simplifier mais c'est adaptable à tout type)

Code c :

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
int **creationTableau(int nb_lig, int nb_col)
{
    int **tab;
    int i;
 
    tab=malloc(nb_lig * sizeof(int));
    if (tab == NULL) return NULL;
 
    for (i=0; i < nb_lig; i++)
    {
        tab[i]=malloc(nb_col * sizeof(int));
        if (tab[i] == NULL)
        {
            int j;
            for (j=0; j < i; j++) free(tab[j]);
            free(tab);
            return NULL;
        }
    }
 
    return tab;
}

Comme tu vois, c'est un peu fastidieux. Faut gérer chaque malloc et penser à libérer tout ce qui a été alloué s'il y a un pb.

Maintenant, la vraie question est celle-ci: pourquoi veux-tu faire absolument un tableau dynamique alors que le plateau de jeu est figé (à 5x5 il me semble) ??? Pourquoi ne pas déclarer directement un t_pion plateau[5][5] ??? Parfois, faire du "sur mesure" ne se justifie pas forcément au regard de la prog que ça impose...
Il existe même une astuce pour éviter le malloc même en cas de plateaux variables: tailler à la taille la plus grande possible et ensuite initialiser chaque case inutilisable à -1. Exemple tu veux faire un puissance 4 sur un plateau pouvant aller de 5x5 jusqu'à 10x10 ben tu définis directement un tableau 10x10. Ensuite si le joueur veut jouer en 5x5 ben tu remplis 75 cases à "-1" et tu le laisses jouer sur les 25 qui restent. C'est vrai que c'est un peu de place perdue mais parfois, faut savoir un peu en perdre et avoir en retour une programmation plus simplifiée...

PS: pour une plus grande facilité de lecture, essaye de nommer tes types "t_qqchose".

[Obsidian]

C'est vrai que c'est plus optimisé de taper directement dans tab[i*L+j] que de taper dans tab[i][j] mais pour un TP de ce genre, a-t-on vraiment besoin d'optimiser autant ?

Ce n'est même pas plus optimisé puisque les éléments d'un tableau multidimensionnel statique en C restent toujours consécutifs en mémoire. Donc i*L+j est exactement l'opération effectuée de manière implicite par le compilateur…

[gerald3d]

Ce n'est même pas plus optimisé puisque les éléments d'un tableau multidimensionnel statique en C restent toujours consécutifs en mémoire. Donc i*L+j est exactement l'opération effectuée de manière implicite par le compilateur…

Je suis bien d'accord !

+1

[Médinoc]

Moi j'utilise bêtement "i" et "j"

Mais ce sont des noms pour des indexes!

Moi je suis pas trop d'accord. Déjà le C permet des accès [i][j] alors pourquoi s'en passer ? C'est vrai que c'est plus optimisé de taper directement dans tab[i*L+j] que de taper dans tab[i][j] mais pour un TP de ce genre, a-t-on vraiment besoin d'optimiser autant ?
Surtout qu'ensuite il faudra analyser le jeu. Avec un tableau en 2D, vérifier que 4 pions sont alignés c'est assez facile. Avec un tableau 1D, il faudra alors opérer des conversions de coordonnées plus ou moins fastidieuses. Je dis pas que c'est pas faisable mais faut se souvenir que c'est un TP de cours pour débutant et peut-être limité dans le temps...

C'est pour ça que je préfère la solution hybride.

[Tooth]

Code c :

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
int **creationTableau(int nb_lig, int nb_col)
{
    int **tab;
    int i;
 
    tab=malloc(nb_lig * sizeof(int));
    if (tab == NULL) return NULL;
 
    for (i=0; i < nb_lig; i++)
    {
        tab[i]=malloc(nb_col * sizeof(int));
        if (tab[i] == NULL)
        {
            int j;
            for (j=0; j < i; j++) free(tab[j]);
            free(tab);
            return NULL;
        }
    }
 
    return tab;
}

A quoi servent les ** devant le nom de fonction ? Normalement , cela veut dire que je pointe vers un pointeur, non ?

Pareil pour tab == NULL, cela est vraiment indispensable ?

Je supose que "Free" est pour libérer la mémoire dès lors que l'on utilise plus le tableau.

Je n'utilise pas t_pion plateau[5][5] (qui est pourtant bien plus simple) car notre professeur nous l'interdit, on doit créer une structure pour nos tableaux afin de pouvoir connaitre la longueur.

[Sve@r]

A quoi servent les ** devant le nom de fonction ? Normalement , cela veut dire que je pointe vers un pointeur, non ?

Ben oui. C'est pour allouer en dynamique des tableaux de tableaux qui ne peuvent passer que par des tableaux de pointeurs.
Donc j'alloue x pointeurs (pour x lignes). Et chaque pointeur lui sera alloué y cases (pour y colonnes).
Ensuite, tab[i][j] commencera par taper sur tab[i] (le iième pointeur) puis, de ce iième pointeur, il ira sur l'élément[j] (la jième case).

Pareil pour tab == NULL, cela est vraiment indispensable ?

L'allocation peut échouer. Dans ce cas, mieux vaut éviter de continuer à bosser...

Je supose que "Free" est pour libérer la mémoire dès lors que l'on utilise plus le tableau.

Oui. Toute mémoire allouée doit impérativement être libérée quand tu n'en as plus besoin. C'est étonnant que tes profs te demandent de faire du malloc() sans qu'ils t'aient enseigné cela.

Je n'utilise pas t_pion plateau[5][5] (qui est pourtant bien plus simple) car notre professeur nous l'interdit, on doit créer une structure pour nos tableaux afin de pouvoir connaitre la longueur.

Bah, c'est un peu débile (la longueur on la connait => 5) mais bon, ce n'est pas insurmontable

Code c :

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

1
2
3
4
typedef struct {
    char *data;
    size_t len;
} t_tab;

Puis

Code c :

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
size_t init_tab(t_tab *pTab, size_t len)
{
    pTab->data=malloc(len * sizeof(char));
    if (pTab->data == NULL)
    {
        pTab->len=0;
        return 0;
    }
    pTab->len=len;
    return len;
}
 
void free_tab(t_tab *pTab)
{
    free(pTab->data);
    pTab->len=0;
}
 
int main()
{
    t_tab tableau;
    if (init_tab(&tableau, 25) == 0)
        printf("Erreur alloc(%d)\n", 25);
    ... //travail
    free_tab(&tableau);
}

Et on peut même rendre tout ça plus générique en utilisant des pointeurs universels

Code c :

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
typedef struct {
    void *data;
    size_t len;
    size_t sz_data;
} t_tab;
 
size_t init_tab(t_tab *pTab, size_t len, size_t sz_data)
{
    pTab->data=malloc(len * sz_data);
    if (pTab->data == NULL)
    {
        pTab->len=0;
        pTab->sz_data=0;
        return 0;
    }
    pTab->len=len;
    pTab->sz_data=sz_data;
    return len;
}
 
void free_tab(t_tab *pTab)
{
    free(pTab->data);
    pTab->len=0;
    pTab->sz_data=0;
}
 
int main()
{
    t_tab tableau;
    if (init_tab(&tableau, 25, sizeof(t_pion)) == 0)
        printf("Erreur alloc(%d)\n", 25);
    ... //travail
    free_tab(&tableau);
}