Discussion :

[FoolBar]

Bonjour,

J'aimerais savoir ou se trouve le problème dans ce 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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 int main()
    {
    printf("\n[Sens dessus dessous]\n");
    printf("Taille du tableau : ");
    int n;
    scanf("%d", &n);
    printf("Cases : \n");
    char **CDC = (char**)malloc(n * sizeof(char));
    for (i = 0; i < n; i++)
        CDC[i] = (char*)malloc(n * sizeof(char));
    int j;
    // Saisie des mots
    for (i = 0; i <= n; i++)
    {
        for (j = 0; j < n; j++)
        {
            scanf("%c", &CDC[i][j]);
        }
    }
    for (i = 0; i <= n; i++)
    {
        for (j = 0; j < n; j++)
        {
            printf("%c", CDC[i][j]);
        }
    }
    printf("\n\n");
 
    // Transpose le tableau
    for (i = 0; i <= n; i++ )
    {
        for (j = i + 1; j < n; j++ )
        {
            char tmp = CDC[i][j];
            CDC[i][j] = CDC[j][i];
            CDC[j][i] = tmp;
        }
    }
 
    // Affiche la transpose
    printf("Transpose \n");
    for (i = 0; i <= n; i++)
    {
        for (j = 0; j < n; j++)
        {
            printf("%c", CDC[i][j]);
        }
    }
    printf("\n");
    printf("\n");
    // Swap les colonnes
    for (i = 0; i <= n; i++)
    {
        for (j = 0; j < n / 2; j++)
        {
            char tmp = CDC[i][j];
            CDC[i][j] = CDC[i][n - 1 - j];
            CDC[i][n - 1 - j] = tmp;
        }
    }
    // Affichage apres rotation
    printf("Apres rotation\n");
    for (i = 0; i <= n; i++)
    {
        for (j = 0; j < n; j++)
        {
            printf("%c", CDC[i][j]);
        }
    }
    printf("\n");
    return 0;
}

Merci

[Obsidian]

Bonjour, c'est vraiment une rotation de 90° que tu veux faire, ou c'est une simple transposée comme les commentaires semblent l'indiquer (et ce qui serait beaucoup plus courant) ?

La confusion est fréquente, mais une transposée de matrice consiste à permuter les colonnes et les lignes de chacun des termes, ce qui se traduit en réalité par une sorte de symétrie autour de la diagonale.

[Sve@r]

J'aimerais savoir ou se trouve le problème dans ce code ?

Bonjour

Si tu veux qu'on trouve des erreurs dans l'algorithme, alors j'en sais rien. Et ce n'est d'ailleurs pas notre rôle. Essaye de poser une matrice réduite (style [3][3]) sur une feuille, effectue ensuite les swap que tu as écrit dans ton code et regarde si le résultat correspond à ce que tu devrais avoir.

Si tu veux qu'on trouve des erreurs dans le langage, alors je n'en vois qu'une seule principale ici char **CDC = (char**)malloc(n * sizeof(char)). En effet, ici théoriquement uu ne veux pas allouer des "char" mais des "pointeurs" donc des "char*". Donc le code devrait être char **CDC = (char**)malloc(n * sizeof(char *)). D'aileurs ça doit être un réflexe obligatoire, dans l'allocation, que de mettre une étoile de moins que le type de l'objet alloué.

Ensuite on trouve des maladresses comme par exemple oublier de vérifier les allocations ; ou libérer la mémoire à la fin. Pour un simple petit code rapide c'est pas important mais si tu veux plus tard coder des trucs fiables et pérennes alors tu devras aussi gérer ces étapes. Et il existe aussi un vaste débat sur les avantages et inconvénients à caster ou ne pas caster malloc (perso je ne préfère pas caster mais je ne le reproche pas à ceux qui le font) donc pour ça, si tu as bien en tête les susdits avantages et inconvénients quand tu castes, alors tu restes seul juge.

Accessoirement, tu peux remplacer un tableau 2D alloué comme tu l'as fait (allouer d'abord la matrice puis allouer ensuite chaque ligne) par un tableau 1D. A ce moment là, tu écriras char *CDC = (char*)malloc(n * n * sizeof(char)). Ca allège l'opération d'allocation, de tests et de libération (surtout que dans la version 2D, quand tu testes chaque allocation de lignes, tu dois surtout prévoir le cas où une ligne ne s'alloue pas alors que l'allocation a réussi pour toutes les précédentes et gérer alors la libération en conséquence !!!) ... mais ça complexifie ensuite l'adressage car tu dois remplacer dans ton algo chaque adresse [x][y] 2D de l'algo par une adresse [z] du tableau mémoire 1D. Donc un avantage dans un cas qui se paye dans l'autre...

[Médinoc]

Au passage, si tu as besoin des casts du retour de malloc(), c'est que tu compiles en C++. Supprime ces casts, tu n'en as pas besoin en C.