Discussion :

[Kurogane1]

Bonjour,
J'ai un tableau de tableau et je cherche à l'empiler dans une pile.
J'ai ça :

Code :

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

1
2
3
typedef struct ech {
int echi[8][8];
} ech_t;

Puis j'ai ça :

Code :

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

1
2
3
ech_t echi_temp;
echi_temp.echi=echiquier;
empiler_echiquier(&pile_ech,echi_temp);

Puis j'ai ça :

Code :

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

int echiquier[8][8];

Quand je compile ça me mets cette erreur : incompatible types when assigning to type 'int[8][8]' from type 'int (*)[8]'

Si je change ma structure en :

Code :

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

1
2
3
typedef struct ech {
int *echi[8];
} ech_t;

Alors j'ai plutôt cette erreur : incompatible types when assigning to type 'int *[8]' from type 'int (*)[8]'

Ne me demandez pas de redéfinir « echiquier », car je me suis servi dans 5-6 pages de code et je ne peux pas tout re-modifier donc. Comment faire pour empiler une matrice ?

Et surtout qu'est ce que ça veut dire les () dans le type : int (*)[8] ? Car apparemment ce n'est pas la même chose que int *[8].



Merci d'avance pour vos réponses.

[Neckara]

Tu as un tableau de tableau si je comprend bien, c'est à dire un tableau de pointeurs pointant sur la première case d'un tableau.

Pour l’empiler, je pense qu'il vaut mieux d'abord stocker les valeurs de ton tableau, en commençant pas tableau[0][0], tableau[0][1] etc...

Puis d'empiler les pointeurs vers chaque première case des tableaux de la pile en commençant par tableau[0], tableau[1] etc...

Et en dernier, tu empile la taille logique de ton tableau de pointeur.

[valefor]

[I]ech_t echi_temp;
echi_temp.echi=echiquier;

Avant même de parler de empiler, et comme tu l'as remarqué cela ne compile pas.

Le c ne gère pas les opérations sur les types "complexes" (tableaux, chaines de caractères, structures maison, etc).

Vous devez donc copier votre echiquier vers la structure à la main :

Code :

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

memcpy(echi_temp.echi, echiquier, sizeof(echi_temp.echi))

par exemple.

Est-ce que "echiquier" est passé en paramètre de la fonction qui fait la copie dans la structure ou est-ce une variable globale ?

Pour ce qui est du empiler, je ne suis pas sûr de comprendre la question.

[Thierry Chappuis]

Tu as déjà un problème ici:

Code :

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

echi_temp.echi = echiquier;

En effet, le champ echi de ta structure est de type tableau contenant 8 tableaux de 8 entiers de type int, alors que echiquier est converti implicitement en un pointeur sur un tableau de 8 ints, aka int (*)[8]. Deux problèmes: d'une part il y a incompatibilité de types et d'autre part, un tableau n'est pas une lvalue et ne peut être utilisé à gauche d'un opérateur d'affectation.

Tu es obligé de copier le contenu de echiquier explicitement dans echi_temp en le parcourant avec des boucles ou éventuellement en utilisant une fonction comme memcpy(). Toutefois, si tu transformes echiquier en une structure de type ech_t, tu peux te permettre l'affectation suivante:

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
38
39
40
#include <stdio.h>
#include <stdlib.h>
 
typedef struct ech {
    int echi[8][8];
}
ech_t;
 
void afficher_ech(ech_t *echiquier)
{
    int i, j;
 
    for (i = 0; i < 8; i++)
    {
        for (j = 0; j < 8; j++)
        {
            printf("%d ", echiquier->echi[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}
 
int main(void)
{
    ech_t echi_temp;
    ech_t echiquier = {{{1,1,1,1,1,1,1,1},
                        {1,1,1,1,1,1,1,1},
                        {1,1,1,1,1,1,1,1},
                        {1,1,1,1,1,1,1,1},
                        {1,1,1,1,1,1,1,1},
                        {1,1,1,1,1,1,1,1},
                        {1,1,1,1,1,1,1,1},
                        {1,1,1,1,1,1,1,1}}};
 
    echi_temp = echiquier;
    afficher_ech(&echi_temp);
 
    return 0;
}

Toutefois, si tu modifies ta structure de type ech_t de la manière suivante:

Code :

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

1
2
3
4
5
typedef struct ech {
    int (*echi)[8]; /* Le champs echi est maintenant un pointeur sur un tableau de 8 ints */
                        /* ATTENTION: les parenthèses sont importantes! */
}
ech_t;

Tu peux maintenant te permettre l'affectation directe:

Code :

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

echi_temp.echi = echiquier;

Avec mes meilleures salutations

Thierry

[diogene]

Et surtout qu'est ce que ça veut dire les () dans le type : 'int (*)[8]'. Car apparemment ce n'est pas la même chose que int *[8].

int(*)[8] est le type pointeur sur un tableau de 8 int
exemple d'utilisation : int(*p)[8]; p est un pointeur sur un tableau de 8 int

int*[8] est le type tableau de 8 pointeurs sur int
exemple d'utilisation : int *tab[8]; tab est un tableau de 8 pointeurs sur int

[anacharsis]

Ne me demandez pas de redéfinir echiquier, car je me suis servi dans 5-6 pages de code et je ne peux pas tout remodifier donc.

c'est bien compréhensible ... mais c'est pourtant ce qu'il faut faire quant l'idée de départ n'est pas la meilleure.
ah ... si les professionnels de l'informatique qui ont pondus Windows n'avaient pas raisonné comme toi ...
je ne sais pas ce que tu veux faire avec un echiquier dont les cases sont des entiers, donc je ne critique pas, mais un type plus petit tient un peu moins de place dans une pile (4 fois moins) donc se manipule plus vite (si on est adroit)
car

Comment faire pour empiler une matrice ?

il faut empiler tous ses éléments : memcpy peut très bien (si la pile est implémentée dans un tableau) ou une boucle pour empiler les 64 éléments (si la pile est implémentée en liste chaînée).

PS s'il s'agit de résoudre le problème des 8 reines, il vaut mieux envisager une autre définition de l'échiquier.

A+