Discussion :

[hogar]

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 :

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
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.

[foetus]

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

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
#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;
}

[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.

[CGi]

sur votre code originel, peut-être plutôt :

Code :

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

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 :

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

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

est équivalent à

Code :

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

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

soit mat est un pointeur sur pointeur sur int

alors que

Code :

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

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

ici mat est un pointeur sur tableaux de trois entiers.

[hogar]

Donc, pour le paramètre

Code :

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

int* mat[3],

ce qu'on met entre crochets [3] représente le nombre de lignes et non de colonnes !

[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 :

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

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

c'est aussi équivalent.

[hogar]

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 :

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

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.

[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 :

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

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

[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);
| ^

[CGi]

Avec 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
#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;
}

[hogar]

Voici le 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
#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;
}

[hogar]

oui CGI, c'est mon code initial.

[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.

[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.

[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.

[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.

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).

[foetus]

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

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

*) 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 :

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

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 :

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
    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);

[hogar]

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

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
 
 
#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.

[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 ?

[CGi]

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 :

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
#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 :

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
#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.