Discussion :

[mrcode]

Bonjour, voici mon code :

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
41
42
43
44
45
46
47
48
49
50
 
void Affichertab(const char tab[4][4])
{
    int i,j;
    for(i=0;i<4;i++)
    {
        printf("\t");
        for(j=0;j<4;j++)
        {
            printf("%c ",tab[i][j]);
        }
        printf("\n");
    }printf("\n");
}
 
void Retournertab(char tab[4][4])
{
    char temp[4][4]={"0"};
    int i,j;
    for(i=0;i<4;i++)
    {
        for(j=0;j<4;j++)
        {
            temp[j][3-i]=tab[i][j];
 
        }
    }
    for(i=0;i<4;i++)
    {
        for(j=0;j<4;j++)
        {
            tab[j][3-i]=temp[j][3-i];
        }
    }
}
 
void Exo4()
{   
    int taille_tableau;
    printf("taille du tableau?\n");
    scanf("%d",taille_tableau);
 
    char tab[4][4]={{'l','3','3','r'},
                      {'l','n','m','3'},
                      {'3','0','4','v'},
                      {'w','d','g','0'}};
    printf("Tableau statique:\n");
    Affichertab(tab);
    Retournertab(tab);
    Affichertab(tab);

Il marche, cependant j'aimerais pouvoir demander a l'utilisateur la taille n de son tableau ( carré ) et lui faire remplir.
Il faut d'abord que j'alloue de la mémoire ( malloc ) et que je libère celle ci ( free )

Suis un peu bloqué, c'est frustrant

Pouvez vous m'aider ? merci

[Sve@r]

Il marche, cependant j'aimerais pouvoir demander a l'utilisateur la taille n de son tableau ( carré ) et lui faire remplir.
Il faut d'abord que j'alloue de la mémoire ( malloc ) et que je libère celle ci ( free )

Suis un peu bloqué, c'est frustrant

Bonjour

Il faut juste se souvenir que "n" dimensions c'est n fois "une" dimension. Et que chaque niveau de dimension se traduit par une étoile de plus.

Donc pour une matrice 2D, il te faut définir un int **tab. Puis ton tab tu lui alloues n "int *" => tab=malloc(n * sizeof(int*)) puis pour chaque tab[x] tu lui alloueras n "int" => for (i=0; i < n; i++) tab[i]=malloc(n * sizeof(int)).
Bien entendu, te faut tester chaque malloc et prévoir une routine de désallocation des "x-1" tabs précédents si l'allocation du tab[x] échoue. Et comme il te faudra aussi fatalement tout désallouer à la fin, il vaut mieux dédier ce travail à une fonction spécifique que tu appelleras au choix si un malloc échoue ou bien à la fin de ton programme.

Sinon une fois que tout ça est fait, tu peux accéder à tab[i][j] comme avant. tab[i] accèdera au "i"ème pointeur en partant de tab et de là, [j] décalera de j "int" à partir de ce pointeur.

Ou alors tu travailles tout en 1D => int *tab; tab=malloc(n*n*sizeof(int)). L'avantage c'est que tu n'as qu'un seul malloc à vérifier ce qui allège ta gestion des erreurs et de libération. L'inconvénient c'est que chaque fois que tu voudras accéder à l'élément[i][j] de ton algo, tu seras obligé de le convertir en tab[i*n+j] et inversement chaque fois que tu voudras savoir à quel [i][j] correspond un tab[x] => i=x/n et j=x%n.