Discussion :

[gangsoleil]

Bonjour,

Je m'essaye aux tableaux dynamiques avec le code suivant, mais j'ai visiblement un soucis que je ne trouve pas.

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
 
/* Pleins de choses avant */
 
	    int nodes[get_nb()][get_node_number(0)];
 
	    memset (nodes, 
		    0, 
		    get_nb() * get_node_number(0) * sizeof (int));
 
/*	    DEBUGSTR1 ("Size : %lu", sizeof (nodes_if_lists)); */
/*	    nodes_if_lists[1][1] = 12; */
/*	    DEBUGSTR1 ("content : %d", nodes_if_lists[1][1]); */
 
	    save_nodes (nodes);
 
/* Pleins de choses apres */

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
/**
 * Save identifiers of all nodes
 * 
 *@param nodes : allocated list in which function will store data.
 *       
 *@return void
 *
 */
void save_nodes (int ** nodes)
{
    int i;
    int j;
 
    if (nodes != NULL)
    {
	for (i = 0 ; i < get_nb() ; i++)
	{
	    for (j = 0 ; j < get_node_number(0) ; j++)
	    {
		nodes_if_list[i][j] =1;
	    }
	}
    }
    return;
}

Et voici le soucis que j'ai a la compilation, avec gcc :

Code :

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

warning: passing arg 1 of 'save_nodes' from incompatible pointer type

Comme vous le voyez avec le code commenté, lorsque j'écris directement dans mon tableau, tout fonctionne parfaitement. Le soucis ne survient que si j'appelle une fonction avec le tableau en paramètre.

Est-ce que quelqu'un voit ou se situe mon problème, et saurait en plus me l'expliquer ?

[ram-0000]

Peut être que ton compilo considère que int ** c'est par int[][]

essaye en modifiant le prototype de ta fonction :

Code :

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

void save_nodes (int nodes [][])

Ceci dit, je n'ai pas plus d'explications

[sloshy]

Bonjour,
en C90 le malloc des tableaux dynamique est obligatoire.

Code :

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

1
2
3
4
5
6
7
8
9
/*du code*/
    int **nodes;
    int count;
 
    nodes = malloc(sizeof(*nodes) * get_nb());
    for (count = 0; count <= get_nb(); count++)
        nodes[count] = malloc(sizeof(**nodes) * get_node_number(0));
    save_nodes(nodes);
/*du code*/

Bon c'est crade ici parce que je ne vérifie pas le retour du malloc, mais il ne devrait plus y avoir de warning.

[Sve@r]

Bonjour,

Je m'essaye aux tableaux dynamiques avec le code suivant, mais j'ai visiblement un soucis que je ne trouve pas.

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
 
/* Pleins de choses avant */
 
	    int nodes[get_nb()][get_node_number(0)];
 
	    memset (nodes, 
		    0, 
		    get_nb() * get_node_number(0) * sizeof (int));
 
/*	    DEBUGSTR1 ("Size : %lu", sizeof (nodes_if_lists)); */
/*	    nodes_if_lists[1][1] = 12; */
/*	    DEBUGSTR1 ("content : %d", nodes_if_lists[1][1]); */
 
	    save_nodes (nodes);
 
/* Pleins de choses apres */

Salut

Je n'ai pas touché au C depuis très longtemps et donc je ne suis pas au courant des dernières évolutions mais à mon époque, il était interdit de faire int tab[fonction_qui_retourne_une_valeur()] parce que le compilo avait absolument besoin d'un nombre connu à la compilation pour allouer la mémoire.
Et donc fallait faire
int *tab;
tab=malloc(fonction_qui_retourne_une_valeur() * sizeof(int));

Donc peut-être que le C99 a évolué pour accepter ton écriture, j'en sais rien. A vérifier...

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
/**
 * Save identifiers of all nodes
 * 
 *@param nodes : allocated list in which function will store data.
 *       
 *@return void
 *
 */
void save_nodes (int ** nodes)
{
    int i;
    int j;
 
    if (nodes != NULL)
    {
	for (i = 0 ; i < get_nb() ; i++)
	{
	    for (j = 0 ; j < get_node_number(0) ; j++)
	    {
		nodes_if_list[i][j] =1;
	    }
	}
    }
    return;
}

Et voici le soucis que j'ai a la compilation, avec gcc :

Code :

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

warning: passing arg 1 of 'save_nodes' from incompatible pointer type

Comme vous le voyez avec le code commenté, lorsque j'écris directement dans mon tableau, tout fonctionne parfaitement. Le soucis ne survient que si j'appelle une fonction avec le tableau en paramètre.

Est-ce que quelqu'un voit ou se situe mon problème, et saurait en plus me l'expliquer ?

Là c'est absolument normal. C'est un problème courant qui arrive aux débutants quand ils arrivent au pointeur et qu'il apprennent qu'un tableau est aussi un pointeur. Ils en déduisent qu'un tableau 2D est un pointeur de pointeur ce qui est logique... mais faux.

L'équivalence tab[] <=> *pt n'est valable que pour la première dimension d'un tableau. Parce qu'en 1D, qu'on aille sur la case [n] ou qu'on aille sur la case située à *(pt + n) est identique. Dans tous les cas, le compilo décale de n positions.

En 2D, ça ne marche plus pareil. Parce que la 2D n'est qu'une simulation mais le compilo continue à bosser en 1D. Et donc dans un int tab[y][x], aller sur la case [m][n] se traduira par un décalage de m * x + n. Mais ce décalage ne peut se faire que si le compilo connait la taille[x] de ton tableau.

Et donc ta fonction save_nodes ne peut pas stocker ton tableau dans un int **. Parce que l'équivalence [] <=> * ne marche plus. Et si tu forces, ben ta fonction ne saura pas se déplacer dans le tableau.
Ta fonction reçoit un int tab[y][x] qu'elle peut stocker dans un int nodes[y][x] ou un int *nodes[x] mais en aucun cas dans un int **nodes. Ce qui explique d'ailleurs ma remarque précédente à propos du compilo qui a besoin de connaitre la taille avant compilation...

Ou alors tu travailles totalement en dynamique. Tu déclares alors un tableau de pointeurs, chaque pointeur étant alloué sur un tableau d'int. Ce n'est alors plus du tout de la 2D même si le comportement à l'exécution y ressemble...

Code C :

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

1
2
3
4
5
6
7
8
9
10
 
    int **nodes;
    int i;
 
    // Allocation pour stocker tous les pointeurs
    nodes=malloc(get_nb() * sizeof(int *));
 
    // Allocation de chaque pointeur
    for (i=0; i < get_nb(); i++)
         nodes[i]=malloc(get_node_number(0) * sizeof(int));

Et là, ta fonction save_nodes fonctionnera. Mais cet ersatz ci-dessus n'est pas parfait parce que dans la réalité, chaque retour de malloc doit être vérifié avec gestion particulière si un malloc échoue. Ce qui donne alors le code suivant

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
36
37
38
39
40
41
42
void free_nodes(int **nodes)
{
    int i;
 
    if (nodes == NULL)
       return;
 
    for (i=0; i < get_nb() && nodes[i] != NULL; i++)
          free(nodes[i]);
    free(nodes);
}
 
fonction_principale()
{
    // Plein de choses avant
 
    int **nodes;
    int i;
 
    // Allocation pour stocker tous les pointeurs
    nodes=malloc(get_nb() * sizeof(int *));
    if (nodes == NULL)
         return (code_particulier_qui_indique_pb);
 
    // Allocation de chaque pointeur
    for (i=0; i < get_nb(); i++)
    {
         nodes[i]=malloc(get_node_number(0) * sizeof(int));
         if (nodes[i] == NULL)
         {
             free_nodes(nodes);
             return (code_particulier_qui_indique_pb);
         }
    }
 
    // Travail sur nodes
    ...
 
    // Fin du travail - Libération mémoire
    free_nodes(nodes);
    return(code_particulier_qui_indique_reussite);
}

Comme tu vois, ça devient de suite une grosse galère à gérer. Hé oui, c'est ça le C. Tu comprendras que je préfère Python...

[gangsoleil]

Bonjour,

Merci pour vos reponses.

à mon époque, il était interdit de faire int tab[fonction_qui_retourne_une_valeur()] parce que le compilo avait absolument besoin d'un nombre connu à la compilation pour allouer la mémoire.
Et donc fallait faire
int *tab;
tab=malloc(fonction_qui_retourne_une_valeur() * sizeof(int));

Donc peut-être que le C99 a évolué pour accepter ton écriture, j'en sais rien.

J'ai effectivement oublié de préciser que je travaillais en C99, qui autorise justement les tableaux dynamiques sans allocation mémoire spécifique. C'est d'ailleurs le seul but de ce bout de code.

En gros, mon but était simplement d'utiliser cette spécificité de C99, et de voir comment ca se passait si je n'allouais pas la mémoire.

J'essaierai demain en corrigeant le type de la fonction, et je vous dirai ce qu'il en est.

Comme tu vois, ça devient de suite une grosse galère à gérer. Hé oui, c'est ça le C. Tu comprendras que je préfère Python...

C'est pas une galère, c'est justement ce qui fait le charme de ce langage

[diogene]

Comme le dit Sve@r, le passage en argument d'un tableau 2D (ou plus) est embêtant en C.

Pour un tableau, ce qui est passé est toujours l'adresse du premier élément du tableau. Si le tableau en argument est défini comme

Code :

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

type tab[N][M];

alors le paramètre doit être du type "adresse d'un tableau de M type", soit

Code :

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

1
2
3
type (*t)[M]// (avec les parenthèses obligatoires).
// le C tolère aussi comme écriture pour le type du paramètre
type t[][M]

L'ennui est que tu dois spécifier M (pour la raison énoncée par Sve@r), ce qui alourdi si le tableau est un VLA (en C99), puisqu'il faut aussi passer la valeur de la dimension.
Une autre possibilité est de le passer en tant que tableau 1D, mais la fonction devra faire le calcul des indices :
Par exemple :

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
 
void fonc2(int i, int (*t)[i])
{
  printf("%d", t[2][i-1]);
}
void fonc1(int i, int *t)
{
  printf("%d", t[2*i+i-1]);
}
int main(void)
{
  int i= 5;
  int j = i+2;
  int tab[i][j];
  tab[2][j-1] = 123;
  fonc2(j,tab);
  fonc1(j,tab[0]);
  return 0 ;
}

[gangsoleil]

L'ennui est que tu dois spécifier M (pour la raison énoncée par Sve@r), ce qui alourdi si le tableau est un VLA (en C99), puisqu'il faut aussi passer la valeur de la dimension.

C'est justement ce que je cherche a faire, mais je ne trouve pas de syntaxe correcte.

En résumé :
je sais que je peux utiliser un tableau alloué dynamiquement, mais je voulais essayer en utilisant les VLA.
La déclaration du tableau ne pose pas de problème, mais je ne vois pas comment écrire le prototype de la fonction :

Code :

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

int save_nodes (int nodes[][])

ne peut pas fonctionner, puisqu'il lui manque la taille du tableau (enfin la taille du second argument pour être précis)

Code :

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

int save_nodes (int nodes [][get_node_number(0)] )

ne devrait pas passer non plus.

J'en viens a me demander si on peut appeler une fonction en lui passant un VLA comme paramètre...

[diogene]

On peut faire ça, mais je ne sais pas si ça répond à ton problème :

Code :

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

1
2
3
4
5
6
7
8
void fonc(int i, int (*t)[i]);
void fonc(int i, int (*t)[i])
{
  ....
}
 
int tab[dim1][get_node_number(0)];
fonc(get_node_number(0),tab);

Mais il serait mieux d'utiliser pour get_node_number(0) une variable intermédiaire plutôt que d'appeler plusieurs fois la fonction.