Problème d'allocation mémoire d'un tableau de tableaux (tableau de 2dimensions) et passage de paramètre.

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour,

Comme le précise le titre je veux faire une allocation mémoire de int* mat[3] et non pas int** mat puis je dois passer la matrice comme paramètre à la fonction (Assign_V1()).

Code:

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
void Assign_V1(int* mat[3], int N, int M)    
{
	for(int i=0; i<N; i++)
		for(int j=0; j<M; j++) mat[i][j]=i+j;		
}
 
 
int main()
{
	const int N=4;
	const int M=3;
	//je dois avoir une matrice mat[4][3]
	int (*mat)[3] = malloc(N * sizeof(*mat));   //***Mon problème
 
	Assign_V1(mat, N, M);
 
        for (int i = 0; i < N; i++)
       {
            for (int j = 0; j < M; j++) {
                     printf("%3d", mat[i][j]);
               }
        printf("\n");
       }
  return 0;	
 
}

Par avance merci.

Ouais je passe mon tour :aie: ton code est foireux (le gros problème est : tu inverses les lignes et les colonnes parce que tu nommes mal tes variables)

Code:

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
#include <stdio.h>
#include <stdlib.h>
 
 
#define G_NB_COLUMNS 4
#define G_NB_LINES   3
 
 
void Assign_V1(int *mat[3], size_t nb_lines, size_t nb_columns) {
    size_t line, column;
 
    for(line=0; line < nb_lines; ++line) {
        for(column=0; column < nb_columns; ++column) {
            mat[line][column] = (line + column);
        }
    }
}
 
 
int main()
{
    int* mat[G_NB_LINES] = { NULL };
    size_t line, column;
    char is_ok;
 
    for(line=0, is_ok=1; (is_ok && (line < G_NB_LINES)); ++line) {
        mat[line] = malloc(sizeof(int) * G_NB_COLUMNS);
        if (mat[line] == NULL) { is_ok = 0; }
    }
 
    if (is_ok) {
        Assign_V1 (mat, G_NB_LINES, G_NB_COLUMNS);
 
        for(line=0; line < G_NB_LINES; ++line) {
            for(column=0; column < G_NB_COLUMNS; ++column) {
                printf("%3d ", mat[line][column]);
            }
 
            printf("\n");
        }
    } else {
        printf("main - error: allocation failed\n");
    }
 
    for(line=0; line < G_NB_LINES; ++line) {
        if (mat[line] != NULL) { free(mat[line]); }
    }
 
 
    return EXIT_SUCCESS;
}

26/02/2024, 18h13
hogar

Merci pour votre réponse.

En revanche, je n'ai pas compris le test if (mat[line] == NULL) { is_ok = 0; } est-il necéssaire ? est ce qu'il y a risque d'avoir une adresse NULL quand on passe par la fonction malloc().

Merci.
26/02/2024, 18h29
CGi
sur votre code originel, peut-être plutôt :
Code:

1 2 3 4 void Assign_V1(int(*mat)[3], int N, int M){ for(int i=0; i<N; i++) for(int j=0; j<M; j++) mat[i][j] = i+j; }
Code:

void Assign_V1(int* mat[3], int N, int M)

est équivalent à

Code:

void Assign_V1(int* mat[], int N, int M)

soit mat est un pointeur sur pointeur sur int

alors que

Code:

void Assign_V1(int(*mat)[3], int N, int M)

ici mat est un pointeur sur tableaux de trois entiers.
26/02/2024, 18h38
hogar

Donc, pour le paramètre

Code:

int* mat[3],

ce qu'on met entre crochets [3] représente le nombre de lignes et non de colonnes !
26/02/2024, 18h52
CGi

le 3 est facultatif, ce n'est qu'une indication pour le lecteur. du point de vue du code il n'a aucun effet. mat est un pointeur sur pointeur sur entier on aurait pu écrire aussi

Code:

void Assign_V1(int **mat, int N, int M)

c'est aussi équivalent.

Oui dans mon cas il s'agit d'un pointeur sur tableaux de trois entiers (*mat)[3]. Y a t'il une différence dans l'allocation mémoire :
Code:

1 2 3 4 5 for(line=0, is_ok=1; (is_ok && (line < G_NB_LINES)); ++line) { mat[line] = malloc(sizeof(int) * G_NB_COLUMNS); if (mat[line] == NULL) { is_ok = 0; } }
c'est toujours valable !

Merci.

26/02/2024, 18h59
CGi

Je parlais de ton code originel
Dans le code de foetus l'allocation est faite différemment puisqu'il y a un tableau de pointeur sur la pile et des tableaux d'entier sur le tas.
Les deux solutions sont viables.

Dans ton code originel, tu avais juste a changer le prototype de la fonction en

Code:

void Assign_V1(int(*mat)[3], int N, int M)
26/02/2024, 19h29
hogar

Mais en changeant le prototype, j'ai eu ces erreurs :

main.c: In function ‘main’:
main.c:35:20: warning: passing argument 1 of ‘Assign_V1’ from incompatible pointer type [-Wincompatible-pointer-types]
35 | Assign_V1 (mat, G_NB_LINES, G_NB_COLUMNS);
| ^~~
| |
| int **
main.c:8:22: note: expected ‘int (*)[]’ but argument is of type ‘int **’
8 | void Assign_V1(int (*mat)[], size_t nb_lines, size_t nb_columns) {
| ~~~~~~^~~~~~

En mettant les constantes en local dans main(), une erreur supplémentaire :
main.c: In function ‘Assign_V1’:
main.c:13:16: error: invalid use of array with unspecified bounds
13 | mat[line][column] = (line + column);
| ^

Avec ce code ? :

Code:

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
#include <stdio.h>
#include <stdlib.h>
 
void Assign_V1(int(*mat)[3], int N, int M)
{
    for(int i=0; i<N; i++)
        for(int j=0; j<M; j++) mat[i][j] = i+j;
}
 
int main(void)
{
    const int N=4;
    const int M=3;
    //je dois avoir une matrice mat[4][3]
    int(*mat)[3] = malloc(N * sizeof(*mat));   //***Mon problème
 
    Assign_V1(mat, N, M);
 
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)
        {
            printf("%3d", mat[i][j]);
        }
        printf("\n");
    }
    return 0;
}

Voici le code :

Code:

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
#include <stdio.h>
#include <stdlib.h>
 
void Assign_V1(int (*mat)[3], size_t nb_lines, size_t nb_columns) 
{
 
    size_t line, column;
 
    for(line=0; line < nb_lines; ++line) {
        for(column=0; column < nb_columns; ++column) {
            mat[line][column] = (line + column);
        }
    }
}
 
 
int main()
{
	#define G_NB_LINES   3
	#define G_NB_COLUMNS 4
 
    int* mat[G_NB_LINES] = { NULL };
    size_t line, column;
    char is_ok;
 
    for(line=0, is_ok=1; (is_ok && (line < G_NB_LINES)); ++line) 
	{
        mat[line] = malloc(sizeof(int) * G_NB_COLUMNS);
        if (mat[line] == NULL) { is_ok = 0; }
    }
 
    if (is_ok) {
        Assign_V1 (mat, G_NB_LINES, G_NB_COLUMNS);
 
        for(line=0; line < G_NB_LINES; ++line) {
            for(column=0; column < G_NB_COLUMNS; ++column) {
                printf("%3d ", mat[line][column]);
            }
 
            printf("\n");
        }
    }
 
    for(line=0; line < G_NB_LINES; ++line) {
        if (mat[line] != NULL) { free(mat[line]); }
    }
 
 
    return EXIT_SUCCESS;
}

26/02/2024, 20h06
hogar

oui CGI, c'est mon code initial.
26/02/2024, 20h07
CGi

Je t'avait dit avec ton code originel !!!
La du mélange les deux codes, le tien et celui de foetus.
Je l'ai posté juste au dessus de ton dernier post.
26/02/2024, 20h52
hogar

Autant pour moi, effectivement çà marche avec le changement du prototype dans le code initial.

Honnêtement, je suis perdu, je n'arrive pas à faire la différence (en termes de conception) :

int (*mat) [3] : (*mat) est un pointeur sur un tableau de tableau de 3 entiers. Et

int* mat[3] : ? (est ce qu'il y a la notion de tableau)

int** mat : ?

Merci.
26/02/2024, 21h16
hogar

Si j'ai bien compris :

int* mat[3] (ou int* mat[]) est équivalente à int** mat : un tableau de pointeurs où chaque pointeur pointe sur un tableau d'entiers.

A confirmer ? Si oui donc l'allocation mémoire à suivre est celle de Foetus.

Par avance merci.
26/02/2024, 22h57
CGi

int* mat[3]
int* mat[]
int** mat
En tant que paramètre de fonction les trois sont équivalent :
pointeur sur pointeur sur entier
pointeur(1) sur pointeur(2) sur entier
ou pointeur(2) peut être le premier pointeur d'un tableau de pointeurs.
et ou entier peut être le premier entier d'un tableau d'entier.

Citation:

Envoyé par hogar

int (*mat) [3] : (*mat) est un pointeur sur un tableau de tableau de 3 entiers.

ici mat est un pointeur sur tableau de 3 entiers (déjà dit plus haut).
(il peut pointer sur le premier tableau d'un tableau de tableau de 3 entiers).

Citation:

Envoyé par hogar

int* mat[3] (ou int* mat[]) est équivalente à int** mat

Pour être tatillon/ précis non ce n'est pas équivalent :mrgreen:

*) int* mat[3] est 1 définition d'1 tableau de 3 ""cases"", chaque case contient 1 pointeur sur 1 int (**). C'est au même titre qu'1 autre tableau short tab[15] ou float tab[2].
*) int* mat[] est aussi 1 tableau mais pour 1 passage de paramètre et non pour 1 définition. Le passage de paramètre dégrade les tableaux en pointeur (sauf si c'est dans la même source, à vérifier)
*) int** mat est 1 pointeur sur 1 pointeur d'entier. 1 double pointeur est le signe de l'adresse d'1 pointeur sur 1 int (**)

Édit: Après recherche, int* mat[] peut-être aussi 1 définition mais il faut obligatoirement l'initialiser (c'est le compilateur qui calcule la taille) par exemple : char tab[] = {'H', 'e', 'l', 'l', 'o', '!'};.

**: int* peut être, avec int* mat[3] et int* ptr:
*) 1 adresse : int a; mat[1] = &a; ptr = &a;.
*) 1 autre tableau : int a[4]; mat[0] = a; /* or mat[0] = &a[0]; */ ptr = a; /* or ptr = &a[0]; */.
*) 1 allocation : mat[2]= malloc(XXX * sizeof(int)); ptr = malloc(XXX * sizeof(int));.

Et int (*mat) [3] est la définition d'1 pointeur sur 1 tableau de 3 ""cases"" puisque tu mets les parenthèses:
Code:

1 2 3 4 5 6 int mat[3] = {15, 26, 37}; int (*ptr_mat)[3]; ptr_mat = &mat; printf("%d, %d, %d\n", (*ptr_mat)[0], (*ptr_mat)[1], (*ptr_mat)[2]);
avec int**
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 int mat[3] = {15, 26, 37}; int (*ptr_mat)[3]; int** dptr_mat; ptr_mat = &mat; // version 1: get the adress of int* // dptr_mat = (int**) &ptr_mat; // <- cast, warning: assignment to ‘int **’ from incompatible pointer type ‘int (**)[3]’ // version 2: allocate the pointer and copy an int* dptr_mat = malloc( sizeof(int**) ); // test is NULL (*dptr_mat) = (int*) ptr_mat; // <- cast, warning: assignment to ‘int *’ from incompatible pointer type ‘int (*)[3]’ printf("%d, %d, %d\n", (*ptr_mat)[0], (*ptr_mat)[1], (*ptr_mat)[2]); printf("%d, %d, %d\n", (*dptr_mat)[0], (*dptr_mat)[1], (*dptr_mat)[2]); // printf("%d, %d, %d\n", (**dptr_mat + 0), (**dptr_mat + 1), (**dptr_mat + 2)); // version 2: free free(dptr_mat);

Bonsoir,
merci pour toutes les explications mais je reprends le code de foetus (mon besoin actuel):

Code:

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
 
 
#include <stdio.h>
#include <stdlib.h>
 
void Assign_V1(int *mat[4], size_t nb_lines, size_t nb_columns)     
{
 
    size_t line, column;
 
    for(line=0; line < nb_lines; ++line) {
        for(column=0; column < nb_columns; ++column) {
            mat[line][column] = (line + column);
        }
    }
}
 
 
int main()
{
	#define G_NB_LINES   4
	#define G_NB_COLUMNS 3
 
    int* mat[G_NB_LINES] = { NULL };
    size_t line, column;
    char is_ok;
    //int *ptr_mat[4];
    int *ptr_mat[G_NB_LINES];
    //ptr_mat=&mat;   //error: assignment to expression with array type
 
    for(line=0, is_ok=1; (is_ok && (line < G_NB_LINES)); ++line) 
	{
        mat[line] = malloc(sizeof(int) * G_NB_COLUMNS);
        if (mat[line] == NULL) { is_ok = 0; }
    }
 
    if (is_ok) {
        Assign_V1 (mat, G_NB_LINES, G_NB_COLUMNS);
 
        for(line=0; line < G_NB_LINES; ++line) {
            for(column=0; column < G_NB_COLUMNS; ++column) {
                //printf("%3d ", mat[line][column]); //affichage classique
                printf("%3d", *(ptr_mat+(line*G_NB_LINES+column)));  //warning: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘int *’ [-Wformat=]
            }
 
            printf("\n");
        }
    }
 
    for(line=0; line < G_NB_LINES; ++line) {
        if (mat[line] != NULL) { free(mat[line]); }
    }
 
 
    return EXIT_SUCCESS;
}

Je n'arrive pas à afficher ma matrice en utilisant pointeurs (adresse des élements et leur valeur).

Merci d'avance.

27/02/2024, 20h07
fred1599

Bonsoir,

J'ai pas suivi la discussion, mais il semble que vous n'ayez pas besoin de ptr_mat du tout, car mat est déjà un tableau de pointeurs vers les lignes de votre matrice. Vous pouvez directement accéder à chaque élément de la matrice avec mat[line][column] pour l'initialisation et l'affichage.

Un simple printf("%3d ", mat[line][column]); ne suffirait pas ?

Citation:

Envoyé par hogar

Je n'arrive pas à afficher ma matrice en utilisant pointeurs (adresse des élements et leur valeur).

Ça ne peut pas fonctionner, tes tableaux ne sont pas contiguës !

Ça pourrait fonctionner avec ton code initial, puisque les tableaux sont contiguës :

Code:

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
#include <stdio.h>
#include <stdlib.h>
 
#define N 4
#define M 3
 
void Assign_V1(int(*mat)[M], int n) // n tableaux de M int
{
    for(int i=0; i<n; i++)
        for(int j=0; j<M; j++) mat[i][j] = i+j;
}
 
int main(void)
{
    int(*mat)[M] = malloc(N * sizeof(*mat));
 
    Assign_V1(mat, N);
 
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)  printf("%3d", mat[i][j]); // avec les indices
        printf("\n");
    }
 
    printf("\n");
 
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)  printf("%3d", *(*mat+i*M+j)); // avec les pointeurs
        printf("\n");
    }
 
    free(mat);
    return 0;
}

Mais dans ce cas on peux faire un peu plus simple en faisant une allocation d'un tableau d'entiers que l'on utilise comme s'il avait 2 dimensions :

Code:

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
#include <stdio.h>
#include <stdlib.h>
 
#define N 4
#define M 3
 
void Assign_V1(int *mat, int n, int m)
{
    for(int i=0; i<n; i++)
        for(int j=0; j<m; j++) *(mat+i*M+j) = i+j;
}
 
int main(void)
{
    int* mat = malloc(N*M*sizeof(*mat));
 
    Assign_V1(mat, N, M);
 
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)  printf("%3d", *(mat+i*M+j)); 
        printf("\n");
    }
 
    free(mat);
    return 0;
}

Mais là, on ne peut plus utiliser les crochets simplement.

Voir 40 message(s) de cette discussion en une page