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.