Discussion :

[Franck.H]

Mouais c'est vrai que j'ai pas eu le courage de tout lire M'enfin s'ils demandent en cours un tableau par rapport aux données utilisateurs y'a pas 10 solutions et ils ont alors forcément vus ca en cours ... du moins je pense, ca serait bête sinon de la part du prof mais vu que plus rien ne m'étonne

On va attendre sa réponse et qu'il dise ce qu'il n'a pas encore vu ou plus précisément ce qu'il a vu, ce sera sans doute plus court

[Garulfo]

Mouais c'est vrai que j'ai pas eu le courage de tout lire M'enfin s'ils demandent en cours un tableau par rapport aux données utilisateurs y'a pas 10 solutions et ils ont alors forcément vus ca en cours ... du moins je pense, ca serait bête sinon de la part du prof mais vu que plus rien ne m'étonne

On va attendre sa réponse et qu'il dise ce qu'il n'a pas encore vu ou plus précisément ce qu'il a vu, ce sera sans doute plus court

A priori tu as raison. Mais c'est un petit projet je crois comprendre. Dans ce cas, il veut peut-être faire plus qu'il n'a appris. Ce qui est tout à son honneur cependant ^_^

[nicodn02]

Oulalala, que de discussion. Merci beaucoup en tout cas.

Comme disait Garulfo, je voudrais creer une fonction qui permettait de creer un tableau avec les dimensions que l'utilisateur avait choisit

En ce qui concerne les allocations dynamiques, je n'ai pas encore vu (et surement pas cette année) mais j'ai déja entendu parler du malloc mais en ce qui concerne le sizeof...

Et oui, en effet, c'est un petit projet pour les cours : jeu puissance4
J'ai vu les tableaux, commencer les structures (mais pas encore fait de td dessus) et demain je pense que l'on va commencer les appels récursifs

en ce qui concerne les "supers pointeurs" (**) je n'est pas vu mais je pense que cela est compréhensible =]

et enfin, en effet, je veux faire plus que la normal


Ce que je vins de plus ou moins comprendre : malloc permet de alloué dynamiquement un espace mémoire sur la machine et cette espace peut varié selon le plaisir du programme ou de l'utilisateur
et je pense que le sizeof a un grnad rapport avec ce malloc

[Franck.H]

Haaa si tu n'as pas encore vu l'allocation dynamique il va falloir l'apprendre car pour un tableau qui peut varier suivant les valeurs de l'utilisateur, tu n'as pas trop le choix, il faut taper en plein dans le dynamique.

Ce que je vins de plus ou moins comprendre : malloc permet de alloué dynamiquement un espace mémoire sur la machine et cette espace peut varié selon le plaisir du programme ou de l'utilisateur
et je pense que le sizeof a un grnad rapport avec ce malloc

Oui les fonctions malloc, calloc, realloc, free permettent d'allouer/réallouer/libérer des espaces mémoire, en fait cet espace est alloué sur la tas (voir des cours sur l'organisation de la mémoire, c'est tout aussi important que le reste), cela permet de faire de la gestion dynamique de données, faire des tableaux dynamiques, des listes chaînées, arbres (en fait tout ce qui touche aux structures de données), etc... Je ne vais pas entrer dans les détails

En effet, le sizeof occupe une place importante dans cette allocation dynamique tout simplement car lorsque tu veux allouer par exemple n blocs comme ici de type int, il faut prendre en compte la taille d'un bloc par rapport à ce type donc on multiplies simplement le nombre de bloc à allouer avec la taille du type.

Dans mon exemple, je n'ai pas directement utilisé le type int pour une raison de maintenabilité du code mais même dans ma méthode on fini toujours par faire référence à ce type sauf qu'en cas de changement du type dans la déclaration du pointeur sur pointeur (et non pas super pointeur) dans la structure, tu n'as qu'à cet endroit qu'il faut changer le type donc tu gagnes en temps

Je vais pas faire un cours mais je te conseil vivement d'en suivre les notions de bases de l'allocation dynamique et des pointeurs, au moins pour que tu ne programmes pas trop au hasard

[nicodn02]

Je commence à comprendre.Et si je ne me trompe pas la ligne de code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
tableau.tab = malloc (tableau.nb_lig * sizeof (* tableau.tab));
 
if (tableau.tab != NULL)
{
   int i = 0;
   for (i = 0; i < tableau.nb_lig; i++)
   {
      tableau.tab[i] = malloc (tableau.nb_col * sizeof (** tableau.tab));
   }
}

Permet, dans un premier tps, de creer le tableau dynamique, et dans un second temps( avec le if) il verifie que le tableau a bien été creer , et par la suite initialise chaque case(taille) du tableau avec le sizeof ?

Est ce que par deriere cela, je peux faire MON initialisation? (cf supérieur) ou sinon comment initialiser?

Enfin, pourquoi l'utilisation de pointeur sur pointeur dans la structure et par la suite, avec les malloc ?

[Franck.H]

Je commence à comprendre.Et si je ne me trompe pas la ligne de code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
tableau.tab = malloc (tableau.nb_lig * sizeof (* tableau.tab));
 
if (tableau.tab != NULL)
{
   int i = 0;
   for (i = 0; i < tableau.nb_lig; i++)
   {
      tableau.tab[i] = malloc (tableau.nb_col * sizeof (** tableau.tab));
   }
}

Permet, dans un premier tps, de creer le tableau dynamique, et dans un second temps( avec le if) il verifie que le tableau a bien été creer , et par la suite initialise chaque case(taille) du tableau avec le sizeof ?

En fait on initialise pas vraiment mais on alloue les colonnes si tu préfères. Dans un tableau 2D, bin tu as 2 dimensions ou si tu préfère des tableaux dans un tableau. C'est ce que fait ce bout de code, la première allocation permet de créer le tableau principal et dans la boucle, on créé un tableau par indice du tableau principal. Logique non ?

Est ce que par deriere cela, je peux faire MON initialisation? (cf supérieur) ou sinon comment initialiser?

Une les allocations effectuées, tu initialises et utilise dont tableau de tableaux comme un tableau statique ordinaire, rien ne change

Enfin, pourquoi l'utilisation de pointeur sur pointeur dans la structure et par la suite, avec les malloc ?

Bin comme un tableau ne connais pas sa propre taille et qu'ici en plus tu en as plusieurs (en fait deux données de tailles), sans compter un tableau de tableau, il paraît assez judicieux de tout rassembler dans une structure et de créer des fonctions qui vont permettrent de créer, gérer et détruire un tel objet ! C'est une question de structuration du programme avant tout

L'allocation dynamique tout simplement car ce sont des pointeurs et que par défaut, lorsque tu déclares des pointeurs, ils pointent sur des adresses non valides donc il faut réserver de l'espace mémoire valide et formatté par rapport au type des données qui y seront stockés

[nicodn02]

Hou.. dur dur à avaler.
Tu a un site pour comprendre plus aisément (car je n'est pas comprend le role de la boucle for pour le malloc ) et de même pour les pointeurs de pointeurs Car après il faut que je sache adapter le code à mon projet et par la suite l'expliquer

[nicodn02]

Ou sinon, faire bcp plus simple c'est-à-dire, dans ma fonctione main() demander les nb_col et les nb_lig et par la suite creer mon char grille[nb_lig][nb_col] ?

[Franck.H]

Hou.. dur dur à avaler.
Tu a un site pour comprendre plus aisément (car je n'est pas comprend le role de la boucle for pour le malloc ) et de même pour les pointeurs de pointeurs Car après il faut que je sache adapter le code à mon projet et par la suite l'expliquer

C'est ce que je craignais donc voici quelques cours:

Les pointeurs, ça sert à quoi ?
Les pointeurs démythifiés !
Les pointeurs du C et du C++.
Description des mécanismes d'allocation dynamique de mémoire en langage C
Bien utiliser malloc()

Sinon tu as des cours complets sur le Langage C ici: http://c.developpez.com/cours/#cours-c


Bonne lecture

[millie]

Je commence à comprendre.Et si je ne me trompe pas la ligne de code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
tableau.tab = malloc (tableau.nb_lig * sizeof (* tableau.tab));
 
if (tableau.tab != NULL)
{
   int i = 0;
   for (i = 0; i < tableau.nb_lig; i++)
   {
      tableau.tab[i] = malloc (tableau.nb_col * sizeof (** tableau.tab));
   }
}

Ca ne sert pas à grand chose d'implémenter un tableau comme ça, ça fait beaucoup de malloc pour rien.

L'implémentation que j'ai donné ne requiert qu'un unique malloc et est beaucoup plus simple à mettre en oeuvre

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
largeur
hauteur
 
int * tab = malloc(sizeof(int) * largeur * hauteur);
if(tab==NULL) 
 ...
 
/*recuperation de (i,j)*/
tab[largeur * j + i]
 
...
free(tab);

Et c'est d'autant mieux de voir le tableau comme un type abstrait (comme j'ai indiqué sur la première page)

[Franck.H]

Ouais c'est aussi une solution, disons que j'utilise toujours cette manière et qui reste la plus naturelle par rapport aux tableaux de tableaux

[souviron34]

moi j'utilise toujours comme millie (sauf pour des tableaux de chaînes)...

• Plus simple à manipuler
• Plus simple à explorer
• Applicable aux images directement
• Force à intégrer la notion de pointeur, beaucoup moins évidente avec les tableaux (de tableaux).

Après, bon c'est une question de choix

[nicodn02]

DOnc ce que je pourrais faire c'est :
dans mon main() demander si l'utilisateur veut ou non personnalisé la grille

si non, la grille[6][7]
si oui, alors je demande les nb_lig et les nb_col et apres je creer
char grille[nb_lig][nb_lig]

non?

[Thierry Chappuis]

Ca ne sert pas à grand chose d'implémenter un tableau comme ça, ça fait beaucoup de malloc pour rien.

L'implémentation que j'ai donné ne requiert qu'un unique malloc et est beaucoup plus simple à mettre en oeuvre

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
largeur
hauteur
 
int * tab = malloc(sizeof(int) * largeur * hauteur);
if(tab==NULL) 
 ...
 
/*recuperation de (i,j)*/
tab[largeur * j + i]
 
...
free(tab);

Et c'est d'autant mieux de voir le tableau comme un type abstrait (comme j'ai indiqué sur la première page)

Pour être complet, voici une solution alternative qui ne demande que 2 allocations dynamiques, et qui permet de conserver la syntaxe d'accès aux différentes cases du tableau 2D:

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
#include <stdio.h>
#include <stdlib.h>
 
/* Constuit un tableau 2D avec une allocation dynamique par dimension */
int **tableau2D_creer(size_t longueur, size_t largeur)
{
    int **self = NULL;
 
    if (longueur > 0 && largeur > 0)
    {
        /* 1ère allocation dynamique */
        self = malloc(longueur * sizeof *self);
 
        if (self != NULL)
        {
            /* 2ème allocation dynamique */
            self[0] = malloc(longueur * largeur * sizeof *self[0]);
 
            if (self[0] != NULL)
            {
                size_t i;
                for (i = 1; i < longueur; ++i)
                {
                    self[i] = &self[0][i * largeur];
                }
 
                /* Initialiser le tableau */
                for (i = 0; i < longueur * largeur; ++i)
                {
                    self[0][i] = 0;
                }
            }
            else
            {
                /*La deuxième allocation a échoué: on libère la mémoire
                  allouée*/
                  free(self), self = NULL;
            }
        }
    }
 
    return self;
}
 
/* Détruit du tableau 2D */
void tableau2D_detruire(int ***self)
{
    if (self != NULL && *self != NULL)
    {
        free(**self);
        free(*self), *self = NULL;
    }
}
 
/* Affiche le contenu du tableau 2D */
void tableau2D_afficher(int **self, size_t longueur, size_t largeur)
{
    if (self != NULL && longueur > 0 && largeur > 0)
    {
        size_t i, j;
        for (i = 0; i < longueur; ++i)
        {
            for (j = 0; j < largeur; ++j)
            {
                printf("%d ", self[i][j]);
            }
            printf("\n");
        }
    }
}
 
/* Exemple d'utilisation */
int main(void)
{
    int err = EXIT_SUCCESS; /* code d'erreur */
    size_t i, j; /* indices de boucle */
    size_t dim_x = 3;
    size_t dim_y = 5;
 
    int **tableau = tableau2D_creer(dim_x, dim_y);
 
    if (tableau != NULL) /* Allocation OK */
    {
        /* On place quelques valeurs dans notre tableau */
        for (i = 0; i < dim_x; ++i)
        {
            for (j = 0; j < dim_y; ++j)
            {
                if (i != j)
                {
                    tableau[i][j] = 10;
                }
            }
        }
        /* On affiche */
        tableau2D_afficher(tableau, dim_x, dim_y);
        /* Et bien sûr, on libère la mémoire */
        tableau2D_detruire(&tableau);
    }
    else /* L'allocation a échoué */
    {
        fprintf(stderr, "Erreur d'allocation! Mémoire insuffisante...\n");
        err = EXIT_FAILURE;
    }
 
    return err;
 
}

Voici un excellent résumé (dessins à l'appui) des différentes stratégies imaginables pour allouer dynamiquement un tableau de ints à 2 dimensions: http://c-faq.com/aryptr/dynmuldimary.html

Thierry

[nicodn02]

Le code suivant vous gene-t-il ?

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
 
#include <stdio.h>
#include <stdlib.h>
 
/* Initialisation de la grille par '.' */
void initialisation_grille(char grille[][5], int nb_lig, int nb_col){
     int i, j;
 
     for (i=0; i<nb_lig; i++){
 
        for (j=0 ; j<nb_col; j++){
            grille[i][j]='.';
        }
 
     }
}
 
/* Affichage de la grille */
void draw_grille(char grille[][5], int nb_lig, int nb_col){
     int i, j;
 
     for(i=0; i<nb_lig; i++){
 
         for(j=0; j<nb_col; j++){
             printf("%c ", grille[i][j]);
         }
 
         printf("\n");  
     }
 
     printf("\n");
}
 
 
int main (void){
    int col, lig;
scanf("%d", &col);
scanf("%d", &lig);
char grille[lig][col];
initialisation_grille(grille, lig, col);
draw_grille(grille, lig, col);
 
  system("PAUSE");	
  return 0;
}

Je m'explique: je demande a l'utilisateur le nombre de colonnes et de lignes
Mais ont peut remarquer que dans mes fonctions je declare un tableau char grille[][5] j'ai mis la taille des colonnes mais lors de l'éxecution j'ai bien ce que je veut, de bonne "taille" de l'utilisateur ( pas très francais )
Une méthode pour éviter d'utiliser le malloc ou sinon, si vous pouvez, comment utiliser le malloc avec ce code (draw_grille et initialisation)??

[souviron34]

Le code suivant vous gene-t-il ?
....

OUI

Code :

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

1
2
3
4
5
6
7
8
9
void initialisation_grille(char *grille, int nb_lig, int nb_col)
{
   /* reste du code inchangé */
}

void draw_grille(char *grille, int nb_lig, int nb_col){
    /* reste du code inchangé */
}

et dans le main :

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
 
 
int main (void){
    int col, lig;
    char *grille=NULL;

  scanf("%d", &col);
  scanf("%d", &lig);

   grille = malloc ( col*lig );
   if ( grille == NULL )
     {
         fprintf ( stderr, "Erreur d'allocation\n");
         return EXIT_FAILURE ;
     }

  initialisation_grille(grille, lig, col);
  draw_grille(grille, lig, col);
  
  free(grille);

  system("PAUSE");	
  return EXIT_SUCCESS;
}

[nicodn02]

Avec ton code, je ne fais plus qu'un seul malloc et en plus, j'ai l'impression de le comprendre... Mais pour confirmation, au lieu d'utiliser un malloc pour chaque dimension, on fait directement le produit des nb_col par nb_lig et c'est bon ?

[millie]

Mais pour confirmation, au lieu d'utiliser un malloc pour chaque dimension, on fait directement le produit des nb_col par nb_lig et c'est bon ?

C'est ce que je te dis depuis le début...

Il ne faut faire qu'un seul malloc dans ce cas, ça ne sert à rien d'en faire pour chaque colonne (ou ligne) vu qu'on connait déjà la taille de ceux-ci et que la taille est constante.
=> C'est plus efficace (moins de malloc, données contigus à coup sûr, prend moins de place réelle), moins de risque d'oublier un free.

[Thierry Chappuis]

Code :

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

1
2
3
4
5
void initialisation_grille(char *grille, int nb_lig, int nb_col)
{
   /* reste du code inchangé */
}

[/QUOTE]
Si tu n'utilises qu'un seul malloc, le reste du code change, contrairement à ce que tu dis ici, puisque la syntaxe d'appel est modifié. La fonction initialisation_grille() devient:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void initialisation_grille(char grille[], int nb_lig, int nb_col)
{
    int i, j;
 
    for (i=0; i<nb_lig; i++)
    {
        for (j=0 ; j<nb_col; j++)
        {
            grille[i*nb_col + j] = '.';
        }
 
     }
}

Pour conserver la syntaxe d'apppel tout en limitant le nombre d'appel à malloc(), il faut au minimum une allocation par dimension comme dans le code que j'ai donné plus haut.

Thierry

[souviron34]

....
Si tu n'utilises qu'un seul malloc, le reste du code change, contrairement à ce que tu dis ici, puisque la syntaxe d'appel est modifié. La fonction initialisation_grille() devient:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void initialisation_grille(char grille[], int nb_lig, int nb_col)
{
    int i, j;
 
    for (i=0; i<nb_lig; i++)
    {
        for (j=0 ; j<nb_col; j++)
        {
            grille[i*nb_col + j] = '.';
        }
 
     }
}

Pour conserver la syntaxe d'apppel tout en limitant le nombre d'appel à malloc(), il faut au minimum une allocation par dimension comme dans le code que j'ai donné plus haut.

Thierry

Euh.. Thierry je crois que tu n'étais pas réveillé....

Si tu fais ce que j'ai dit, bien sur que non que le code ne change pas. La syntaxe d'appel oui, mais pas l'intérieur du 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
void initialisation_grille(char *grille, int nb_lig, int nb_col)
{
    int i, j;
     
    for (i=0; i<nb_lig; i++)
    {
        for (j=0 ; j<nb_col; j++)
        {
            grille[i*nb_col + j] = '.';
        }
        
     }
}

mache parfaitement...