Salut,

Je m'entraine un peu sur les pointeurs etc.

L'idée c'est une fonction qui va changer la valeur d'un double dans un tableau qui est dans un tableau qui lui même est dans un tableau.

Mon code fonctionne, j'arrive bien à changer mes valeurs mais je ne comprends pas pourquoi entre chaque tableau je dois "sauter" un nombre.

void	ddpointe(double ***bats)
{
	bats[0][0][0] = 0;
	bats[0][1][0] = 1;
	bats[0][1][1] = 2;               ---> Je suis dans tabB[1]

 	*(**(bats + 0) + 4) = 3; 	// tabC[0]  ------> Je passe à bats + 4?
	*(**(bats + 0) + 5) = 4; 	// tabC[1]
	*(**(bats + 0) + 6) = 5;	// tabC[2]  --------> même chose ici + 6
       	*(**(bats + 0) + 8) = 6;	// tabD[0]  --------> la je passe à + 8
	*(**(bats + 0) + 9) = 7;	// tabD[1]
	*(**(bats + 0) + 10) = 8;	// tabD[2]
	*(**(bats + 0) + 11) = 9;	// tabD[3]

	
}

Je n'arrive pas à saisir pourquoi? Est-ce au niveau de la mémoire que cela se joue?

J'ai fais un tableau histoire d'essayer de comprendre et vous montrer mon raisonnement (attention ça va peut être piquer le cerveau...)

Pourquoi passer de +6 à +8 alors que c'est la "case" d'à côté?

Pareil pour le passage de taB à tabC?

Merci pour le coup de main!

Salut comment as-tu fais ton allocation pour ton tableau?
Si c’est un malloc tu as du faire comme ça en gros:

double tableau = malloc(size * sizeof(double**));
for(int i = 0; i < size; i++){
     tableau[i] = malloc(size * sizeof(double*);

.....

En gros au début de chaque bloc mémoire que ton malloc va allouer il va y avoir un header du malloc

La valeur que tu vas trouver en +7 correspond donc à la valeur du header du malloc suivant.

Salut,

Je n'utilise pas encore malloc (j'en suis pas là)

J'ai fait comme ça:

#include <stdio.h>
#include "ddpointe.h"

int	main(void)
{
	double	tabA[1] = {0};
	double	tabB[2] = {0};
	double	tabC[3] = {0};
	double	tabD[4] = {0};
	double 	*tabs[4] = {tabA, tabB, tabC, tabD};
	double	**bats[1] = {tabs};

	ddpointe(bats);
	return (0);
}

tu as tout mon code sauf le .h avec le proto de la fonction.

Merci!

Je crois que j'ai trouvé, comme mon double vaut 8 octets, je dois "sauter" les 8 octets car je n'ai pas fais d'allocation ?! -----> En fait non, ça colle pas.

-
Edité par UnDeuxTwa 26 juin 2020 à 16:18:46

Dans ce genre d'exercice, il faut ABSOLUMENT faire un dessin

Mais c'est le genre d'exercice inutile et en réalité contre-productif.  La difficulté avec les pointeurs, c'est pas de faire un truc tordu pour le plaisir de se demander ensuite combien il faut d'étoiles pour faire un truc qui ne sert strictement à rien. Tout ça pour se la péter avec des "triple pointeurs", chose qui n'a aucun intérêt (ils disparaissent si on a l'idée de se servir de typedef).

Ce qui est utile en réalité, c'est de savoir QUAND il faut se servir de pointeurs pour faire des choses utiles, et quand s'en abstenir.

-
Edité par michelbillaud 27 juin 2020 à 12:45:39

-
Edité par edgarjacobs 27 juin 2020 à 16:10:11

Mais qu'est-ce que peut bien apprendre avec

*(**(bats + 0) + 6) = 5; 

Il y a juste un jeu d'écritures, à partir de l'équivalence entre *(p +i)  et p[i]

*(**(bats + 0) + 6)
*(*  bats[0]   + 6)

(*bats[0]) [6]

c'est purement du calcul, ça n'apporte aucune compréhension.

-
Edité par michelbillaud 27 juin 2020 à 21:47:54

Salut!

Merci pour vos réponses! J'ai compris!

Je suis d'accord sur le fait que ça n'a pas d’intérêt, c'était simplement pour être sûr de bien avoir compris les pointeurs, j'en fais un peu tous les jours juste histoire de ne pas me perdre, j'ai mis un peu de temps à comprendre cette notion donc je la répète, bêtement pour bien l'intégrer.

Merci à vous pour votre aide!