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

27/02/2024, 22h49
edgarjacobs

En plus, si ptr_mat est bien déclaré ligne 28, il n'est jamais défini.

Bonsoir,

Pour le premier code, je n'ai pas compris pourquoi CGI utilise *mat dans le calcul d'adresse *(*mat+i*M+j)) au lieu de mat sans étoile d'ailleurs je n'arrive pas à assimiler la différence entre ptr_mat, *ptr_mat et (*ptr_mat) dans un code précedement vu ci-dessus que je mets ici pour rappel :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <stdio.h> int main() { int mat[3] = {15, 26, 37}; int (*ptr_mat)[3]; ptr_mat = &mat; printf("%p %p %p %p %p %p\n", ptr_mat, *ptr_mat, (*ptr_mat), &mat, &mat[0], mat); //&mat = &mat[0] => adresse de mat revient à l'adresse du premier élément de mat printf("%d, %d, %d\n", (*ptr_mat)[0], (*ptr_mat)[1], (*ptr_mat)[2]); printf("%d, %d, %d\n", *ptr_mat[0], *ptr_mat[1], *ptr_mat[2]); //*ptr_mat[0]=15 (1er élt du tableau mais *ptr_mat[1]!=26 *ptr_mat[2]!=37 return 0; }
Il est clair que ptr_mat est un pointeur qui contient l'adresse du tableau mat (&mat) mais *ptr_mat ? et (*ptr_mat).

MERCI pour vos réponses.

28/02/2024, 20h12
foetus
Tu viens de voir que ton appel est foireux :mrgreen:

Tu passes
- soit 1 pointeur sur 1 int*, int**. comme l'a dit @CGi message 30, si tu commences par remplacer ton tableau par 1 pointeur, autant faire 1 gros malloc (parce que les tableaux multi dimensionnels n'existent pas [vraiment] en C)
- soit int* mat[]. Parce que comme on te l'a dit, en C le passage tableau est dégradé en pointeur : à quoi cela sert de forcer le passage d'1 tableau :koi:
Édit: Tu as du mal avec les tableaux et les pointeurs. :mrgreen: mais le mieux c'est de faire 1 structure t_matrice d'encapsuler au moins ton tableau et ses dimensions (+ faire 1 set de ""méthodes"") Et ainsi éviter de te prendre la tête à passer des tableaux en paramètres.

Citation:

Envoyé par hogar

Il est clair que ptr_mat est un pointeur qui contient l'adresse du tableau mat (&mat) mais *ptr_mat ? et (*ptr_mat).

:whistle: au hasard, l'étoile est l'opérateur de déférencement d'1 pointeur. Mais comme par hasard prt_mat est 1 pointeur :weird: :fou:

Édit: relis tous tes cours depuis le début, reprends tous les exemples 1 par 1, tu piges que dalle :wow: :wow:

Dans ton code ptr_mat est un pointeur sur tableaux de 3 entiers. Ce qui veut dire que si tu lui ajoute 1 il pointera un tableau de trois entiers plus loin (voir l'arithmétique des pointeurs) soit trois entier plus loin.
Ce type de pointeur est plus adapté pour des tableaux à 2 dimensions même s'il est utilisable dans ton exemple.

Voici tout de même trois façons de l'utiliser. (Mais c'est de la torture de l’esprit, personne ne ferait ça).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <stdio.h> int main() { 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]); printf("%d, %d, %d\n", *(*ptr_mat+0), *(*ptr_mat+1), *(*ptr_mat+2)); printf("%d, %d, %d\n", ptr_mat[0][0], ptr_mat[0][1], ptr_mat[0][2]); return 0; }

Pour utiliser les tableaux et les pointeurs, on peut retrouver les divers moyens d'écrire la même chose:
un pointeur, c'est une variable qui mémorise l'adresse d'une donnée.
on accède à cette donnée en déréférençant le pointeur : *ptr.
le language nous donne la formule suivante, toujours vraie que ptr_ou_tableau désigne un pointeur ou le nom d'un tableau.

Code:

ptr_ou_tableau[ n ] ↔ *( ptr_ou_tableau + n )

on a aussi:

Code:

&*ptr ↔ ptr et *&var ↔ var

Par le bon sens *ptr c'est aller voir ce qu'il y a à l'adresse dans le pointeur, &*ptr c'est son adresse, c'est la valeur du pointeur, d'où &*ptr ↔ ptr.
Par le bon sens &var c'est l'adresse de la variable, *&var c'est aller voir ce qu'il y a à cette adresse, il y a var, d'où *&var ↔ var.
l'équivalence, très souvent répétée : "Le nom d'un tableau correspond à l'adresse de la première case du tableau" correspond à:
Code:

1 2 3 4 5 tableau[ n ] ↔ *( tableau + n ) en particulier: tableau[ 0 ] ↔ *( tableau + 0 ) on prend les adresses; & tableau[ 0 ] ↔ & * tableau d'où: & tableau[ 0 ] ↔ tableau
Maintenant, les éléments peuvent eux même être des tableaux (on a un tableau de tableaux) ou des pointeurs (on a un tableau de pointeurs), les 2 règles à ne pas oublier permettent toujours s'y retrouver: ptr_ou_tableau[ n ] ↔ *( ptr_ou_tableau + n ) et "Le nom d'un tableau correspond à l'adresse de la première case du tableau".

29/02/2024, 08h04
Sve@r

Bonjour

Citation:

Envoyé par hogar

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

Oui il y a un risque. Rien ne t'assure que ta demande sera satisfaite. Et en 2D il te faut vérifier le malloc initial (celui du nb de lignes) et ensuite tous les mallocs internes (ceux de chaque ligne). Et gérer si le malloc de la ligne 7 échoue (libérer les 6 lignes déjà allouées puis libérer le tableau).

Pour le reste de tes soucis, peut-être viennent-ils du fait que tu assimiles un tableau 2D à un jeu d'échec dans lequel on cible facilement une case ou une autre. Or il n'en est absolument rien. En mémoire tu n'as qu'une seule dimension. Et passer de la 2D à la 1D ne peut se faire alors que si le compilo connait la taille de la dernière dimension (taille d'une ligne). Et pareil en 3D pour passer de la 3D à la 1D il faudra qu'il connaisse la taille des deux dernières. Et etc.

Pour ton premier code, tu remplaces void Assign_V1(int* mat[3], int N, int M) (qui signifie "mat est un tableau de 3 pointeurs") par void Assign_V1(int (*mat)[3], int N, int M) (qui signifie "*mat est un tableau de 3 int" et qui, force du hasard, correspond à la déclaration de mat dans le main).
Et ce serait bien que tu indentes proprement, histoire de nous montrer que tu es fier de ton C et fier d'avoir un code agréable à l'oeuil.

Bonjour,

J'ai ce proramme qui n'affiche aucune erreur lors de la compilation mais aucun affichage de résultat.

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
#include <stdio.h>
 
void assign(int (*mat)[3], int N, int M)   
{
	for (int i=0; i<N; i++) 
		for (int j=0; i<M; j++)
	{
	    mat[i][j]=i+j;   
	}
}
 
 
void afficher(const int mat[][3], int N, int M) 
{
    for (int i=0; i<N; i++) 
		for (int j=0; i<M; j++) printf("%d ", mat[i][j]);
}
 
 
int main()
{
     #define N 4
     #define M 3
 
     int mat[N][M]={0};
 
   	 assign(mat, N, M); 
   	 afficher(mat, N, M);
 
     return 0;
}

Merci de m'aider.

06/03/2024, 20h41
Sve@r

Citation:

Envoyé par hogar

Merci de m'aider.

Merci de faire attention à ce que tu écris (ligne 6). Tu aurais mis un printf() tu l'aurais vu immédiatement.
06/03/2024, 22h20
CGi

Tu as détendu tes macro #define plus bas dans ton code parce que ça ne compilait pas ? sans te demander pourquoi ?
Et bien c'est parce que les noms de tes paramètres de fonction portent le même nom que tes macros #define.
Pour différencier les macros des variables, généralement on les met en majuscule et les variables en minuscules.

Pour ton problème, c'est les deux for j ou tu ne testes pas les bonnes variables (i au lieu de j).
07/03/2024, 20h30
hogar

Un grand merci à tout le monde et en particulier à CGI.

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