Discussion :

[Oblivion0]

Bonjour à toutes et tous,

J'ai écrit une petite fonction permettant d'allouer la mémoire nécessaire pour une matrice de dimensions dim_i et dim_j. Cette matrice contient des doubles.
Cependant, je voudrais que cette matrice puisse contenir des pointeurs vers une structure "S", mais je galère niveau syntaxe. Comment faut-il changer cette fonction pour arriver à mes fins ?

Merci beaucoup par avance à quiconque pourra m'aider !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
double** Allocate_Matrix(int dim_i, int dim_j){
  int i = 0, j = 0;
  double** mat = NULL;
 
  mat = (double**) malloc(dim_i*sizeof(double*));
  if (mat == NULL) exit(EXIT_FAILURE);
  for (i = 0; i < dim_i; i++){
    mat[i] = (double*)malloc(dim_j*sizeof(double));
    if (mat[i] == NULL){
      for (i = i-1; i = 0; i--) free(mat[i]);
    }
  }
  return mat;
}

[foetus]

Et un truc comme cela ?

Code :

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

1
2
3
4
    t_S** mat_S;
 
    mat_S = malloc(dim_i * dim_j * sizeof(t_S*));
    if (mat_S != NULL) { memset(mat_S, 0, (dim_i * dim_j * sizeof(t_S*))); }

[Oblivion0]

Impeccable, merci !

[Sve@r]

Bonjour

Code :

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

1
2
3
    t_S** mat_S;
    mat_S = malloc(dim_i * dim_j * sizeof(t_S*));
    if (mat_S != NULL) { memset(mat_S, 0, (dim_i * dim_j * sizeof(t_S*))); }

Il me semble que tu as transformé la nature intrinsèque de sa matrice non ? Il avait une matrice 2D et tu lui donnes une matrice 1D. Alors que d'après ce que j'ai compris, il avait un échiquier de doubles et il voulait un échiquier de pointeurs.
Mais bon, si ça lui convient...

Impeccable, merci !

Attention, dans ton premier code tu sors du programme si malloc échoue ce qui n'est pas super propre. Généralement, si une fonction ne peut pas faire son travail, on lui fait retourner une valeur spéciale et c'est l'appelant qui gère.
De même si les sous-malloc échouent tu libères ce qui a été alloué (bon réflexes !) mais il faut aussi indiquer le souci à l'appelant...

[Invité]

Bonjour,

Cette condition est à revoir :

Code :

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

for (i = i-1; i = 0; i--) free(mat[i]);

[foetus]

Il me semble que tu as transformé la nature intrinsèque de sa matrice non ? Il avait une matrice 2D et tu lui donnes une matrice 1D. Alors que d'après ce que j'ai compris, il avait un échiquier de doubles et il voulait un échiquier de pointeurs.
Mais bon, si ça lui convient...

Tu as entièrement raison
Mais est-bien utile de faire un tableau de tableaux (ce qu'est une matrice) ?

Tout est plus lourd : les allocations ligne par ligne, les désallocations et avoir un niveau pointeur en + (une variable de type t_S*** contre de type t_S**)
Non ici , je pense qu'il faut mieux coder une interface matrice (avec un type fixe), avec les constructeurs, les destructeurs et les mutateurs qui vont bien.

[Oblivion0]

Cette condition est à revoir :

Code :

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

for (i = i-1; i = 0; i--) free(mat[i]);

En quoi est-ce faux ?

[Bousk]

Ce code fait rien. Tu initialises i, mais osef vu que tu lui assignes directement 0, et 0 c'est évalué à faux donc on rentre jamais dans la boucle.

[Sve@r]

En quoi est-ce faux ?

for(initialisation; condition; increment).
Déjà dans la condition tu as confondu "comparaison" et "affectation" (i == 0 et non i = 0). Nota: si tu crains de te tromper à l'avenir, alors inverse les deux opérandes. Tu aurais écrit 0 = i le compilo aurait gueulé sa race alors qu'écrire 0 == i fonctionnera tout comme i == 0.
Et ensuite la condition est une condition de continuation, pas une condition d'arrêt. Tu dois demander tant que i supérieur à 0 parce que c'est la condition qui continue la boucle ; et non pas demander i vaut 0 en espérant que le compilo comprendra que tu indiques une condition qui permet de quitter la boucle.

[koala01]

Salut,

Bonjour

Il me semble que tu as transformé la nature intrinsèque de sa matrice non ? Il avait une matrice 2D et tu lui donnes une matrice 1D. Alors que d'après ce que j'ai compris, il avait un échiquier de doubles et il voulait un échiquier de pointeurs.

De manière générale, le but d'une matrice reste toujours, de permettre la représentation d'un nombre d'éléments équivalent au multiple de l'ensemble de ses dimensions.

Pour prendre un exemple concret : si tu veux créer une matrice 2D composée de L lignes et de C colonnes, ton objectif final reste, a priori, de pouvoir représenter L x C éléments, et ce, quel que soit le type des éléments que l'on veut représenter, non .

Dés lors, quelle serait la différence entre le code

Code :

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

1
2
3
4
double ** mat;
mat = malloc(sizeof(double*)* MAXLINES);
for(int i=0; i< MAXLINES; i++)
    mat[i]= malloc(sizeof(double) * MAXCOLS);

qui finirait bel et bien par allouer l'espace mémoire correspondant à MAXLINES * MAXCOLS et le code

Code :

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

1
2
double * mat;
mat = malloc(sizeof(double) MAXLINES * MAXCOLS);

qui produira le même effet, à ceci près que

1. l'espace mémoire est alloué en une seule fois
2. nous "économisons" l'usage d'un pointeur
3. les accès se font à l'aide d'un indice (mat[ligne * MAXCOLS + colonne]) au lieu de deux (mat[ligne][colonne])

Hé bien la réponse est toute simple : dans le pire des cas, cela reviendra strictement au même (avec le léger avantage de pouvoir travailler sur un pointeur au lieu de devoir travailler sur un pointeur de pointeur).

Dans le meilleur des cas comme il n'y a aucune garantie que les allocations successives effectuées lors de la boucle soient effectivement contiguës en mémoire, il n'est même pas interdit de penser que la contiguité des données nous permettra de profiter avantageusement des éventuels système de cache utilisés par le processeur.

Alors, bien sur, au final, cela nous oblige à une petite gymnastique mentale pour calculer l'indice de l'élément auquel on souhaite accéder (à l'aide de la formule indice = ligne_demandée * nombre_de_colonne + colonne_demandée). Mais n'est ce pas un bien faible prix à payer pour la simplification des prototypes que cela nous autorise

Tu as le droit d'avoir ton propre avis sur le sujet, mais, étant plus habitué au C++ qu'au C, je trouve personnellement que ca vaut la peine

[Sve@r]

les accès se font à l'aide d'un indice (mat[ligne * MAXCOLS + colonne]) au lieu de deux (mat[ligne][colonne])

Là c'est un point important car tu dois donc reprendre tout ton code pour réécrire tes accès. C'était un peu le but de ma remarque initiale. Je ne critiquais pas la transformation elle-même, juste le fait qu'elle n'ait pas été mentionnée par foetus car ça implique une refonte par le PO

Dans le meilleur des cas comme il n'y a aucune garantie que les allocations successives effectuées lors de la boucle soient effectivement contiguës en mémoire

En fait, dans les allocations en 2D, c'est garanti qu'elles ne seront pas contigües en mémoire. La première alloue n pointeurs tous contigus (donc par exemple 1000, 1001, 1002, 1003 etc). Il est donc obligé qu'aucune ligne ne pourra être allouée en 1000, 1001, 1002 etc.

Alors, bien sur, au final, cela nous oblige à une petite gymnastique mentale pour calculer l'indice de l'élément auquel on souhaite accéder (à l'aide de la formule indice = ligne_demandée * nombre_de_colonne + colonne_demandée). Mais n'est ce pas un bien faible prix à payer pour la simplification des prototypes que cela nous autorise

N'oublie pas aussi qu'on peut avoir besoin de convertir un indice en ligne/colonne => ligne=i/MAXCOLS et colonne=i%MAXCOLS

Tu as le droit d'avoir ton propre avis sur le sujet,

Oui, c'est d'ailleurs un truc que je dis assez souvent.

[koala01]

Là c'est un point important car tu dois donc reprendre tout ton code pour réécrire tes accès.

tu dois reprendre le code ... existant Le nouveau code ne posera aucun problème, et, comme les problèmes de création et d'allocation sont, de manière générale, les premiers résolus, on peut espérer que cet aspect reste assez limité, malgré tout

C'était un peu le but de ma remarque initiale. Je ne critiquais pas la transformation elle-même, juste le fait qu'elle n'ait pas été mentionnée par foetus car ça implique une refonte par le PO

Sur ce point, par contre, je suis tout à fait d'accord avec toi

En fait, dans les allocations en 2D, c'est garanti qu'elles ne seront pas contigües en mémoire. La première alloue n pointeurs tous contigus (donc par exemple 1000, 1001, 1002, 1003 etc). Il est donc obligé qu'aucune ligne ne pourra être allouée en 1000, 1001, 1002 etc.

Tu as raison de chicaner sur ce point, car je me suis effectivement mal exprimé :

Ce que je voulais dire, c'est que, chaque ligne se voyant allouer un espace mémoire de taille identique (mettons pour la facilité, 10 bytes), on n'a aucune garantie que le début de l'espace mémoire alloué à une ligne particulière soit effectivement contigu à l'adresse mémoire à laquelle se trouve la dernière donnée de la ligne précédante, et que nous ayons donc une représentation proche de

Code :

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

1
2
3
4
ligne 0 : 1000 à 1009 inclus
ligne 1 : 1010 à 1019 inclus
ligne 2 : 1020 à 1029 inclus
ligne 3 : 1030 à 1039 inclus

Ca peut arriver, à titre plus ou moins exceptionnel, et ce serait l'idéal pour les mécanisme de cache, mais, a priori, il est beaucoup plus vraisemblable de penser que cela n'arrivera pas

N'oublie pas aussi qu'on peut avoir besoin de convertir un indice en ligne/colonne => ligne=i/MAXCOLS et colonne=i%MAXCOLS

Bien sur

Oui, c'est d'ailleurs un truc que je dis assez souvent.

Donc, tu essayais juste de tirer la discussion en longueur en jouant l'avocat du diable

Ca ne me dérange pas du tout, car je le fais aussi régulièrement. Ca permet de faire sortir des notions qu'on a trop souvent tendance à oublier ou à mal comprendre