Discussion :

[edgarjacobs]

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

[hogar]

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 :

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

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.

[foetus]

Tu viens de voir que ton appel est foireux

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

Édit: Tu as du mal avec les tableaux et les pointeurs. 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.

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

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


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

[CGi]

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 :

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

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

[dalfab]

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 :

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

  ptr_ou_tableau[ n ]  ↔  *( ptr_ou_tableau + n )

• on a aussi:
  

  Code :

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

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

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

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

[Sve@r]

Bonjour

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.

[hogar]

Bonjour,

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

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

[Sve@r]

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.

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

[hogar]

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