Bonjour.
Je voudrais créer un pointeur sur pointeur sur pointeur d'entier soit un int***  
J'ai un problème lors de la réservation:
je fais:
 
int ***ptrnum;
 
ptrnum=(int***)malloc(sizeof(int**));
 
 
 
j'appelle ensuite une fonction qui a pour entrée ce pointeur:
 
verifnum(&ptrnum);
 
 
or dans cette fonction j'attribut une valeur entiere au contenu du pointeur:
 
****ptrnum=t;   (avec t entier)
 
et sa bloque à ce moment là.
 
Je ne comprend pas trop pourquoi surtout que lorsque je met  """  ptrnum=(int***)malloc(sizeof(int)*80);  """  par exemple, cela marche.
lorsque l'on met   sizeof(int**) ne devrait t-il pas réserver l'espace adéquat pour stocker l'entier???
 

D'abord ptrnum c'est un pointeur vers un pointeur sur un pointeur d'entier, pas un pointeur sur un pointeur d'entier. Ensuite si tu as besoin de faire des choses avec 4 niveau d'indirection, tu es mal barré. Quelque chose me dit qu'il y a un problème d'architecture dans ton appli.
 
Enfin, tout dépend de ce que tu as mis dans *ptrnum et **ptrnum. Puisque tu ne donnes aucun détail à ce sujet, on ne peut pas répondre. Il y a des chances pour qu'une de ces adresses ne contienne pas ce que tu penses qu'elle contient. En faisant un malloc plus large, ton code ne fait toujours pas que tu penses qu'il fait, mais par chance il tombe dans la zone mallocée et donc ça passe.

Il faudrai voir le code en détail mais tu as sans doute un problème avec la notion de pointeur.
Pour pouvoir faire ****ptrnum=t;  il faut d'abord avoir déjà alloué de la place pour ptrnum, ce qui a priori est fait, (mais pourquoi fais-tu verifnum(&ptrnum); ? tu as l'intention de modifié la valeur attribuée à ptrnum ?) ensuite à *ptrnum par un malloc(xxx * sizeof int **)  puis à **ptrnm par un malloc(xxx * sizeof int *) puis enfin ***ptrnum par un malloc(xxx * sizeof int).  
Est-ce fait ?
 

non ce n'est pas sa.
En fait une fonction devra appeler une fonction qui va appeler ce pointeur.
J'ai donc besoins d'un int***  
Le fait est que je veux attribuer une valeur entière à ce ****ptrnum pour pouvoir la récupérer apres dans la dernière fonction appelée.

Ok merci à tous c'est bon maintenant.
J'avais oublié de réserver *ptrnum   **ptrnm  ***ptrnum  donc forcément sa ne pouvait pas marcher.

Exact. Mais cependant, manipuler des pointeurs a 4 niveaux est une porte ouverte aux bugs. Es-tu certain d'avoir besoin de 4 dimensions ???
 
Sinon la question de Trap D est importante. Pourquoi passes-tu à ta fonction l'adresse de "ptrnum" alors qu'apparemment tu ne va pas modifier "ptrnum" mais "****ptrnum" ???
Généralement, on ne passe un pointeur à une fonction que dans 2 cas

• la fonction a pour but de modifier une variable => on passe donc l'adresse de cette variable
• la fonction doit travailler sur un élément complexe (structure, tableau) => en passant l'adresse de cet élément on réduit le temps de copie (vaut mieux copier une adresse à 2 octets plutôt qu'une structure entière qui peut en contenir des dizaines)