Bonjour,
 
je viens de m'apercevoir qu'intervertir l'ordre de deux déclarations de pointeurs peut créer des erreurs de segmentation
 

 
Je crois avoir compris que le problème est qu'aucun emplacement n'est réservé pour stocker la valeur pointée par char** (une adresse).
Est-ce que je suis obligé de faire un malloc() après chaque déclaration de pointeur ?
 
D'autre part, en prenant un exemple simple, est-ce que  

est correct ? ou y'a t-il toujours un risque de seg_fault ?

comportement indéfini.

c'est donc une erreur de programmation ?

 
ça te forcera à faire une allocation par la suite avant de pouvir utiliser ton pointeur

Le problème est ailleurs. Si tu définis des pointeurs sans leur donner une valeur valide, le déréférencement produit un comportement indéfini. C'est un bug de codage.
 

Oui. Le pointeur pointe n'importe où.

Non. Ce qui est obligatoire, c'est que la valeur du pointeur soit valide au momement où tu l'utilises (ou si tu le passes à une fonction).

14 ça veut dire quoi ? Tu trouves que ça ressemble à une adresse valide ?
p n'étant pas défini, le comportement est indéfini. C'est un bug. Oui, il y a de risque de seg_fault.
 
Il y a 4 façons standards d'initialiser un pointeur
 

• NULL (le pointeur est alors invalide, son déréférencement invoque un comporetement indéfini). Mais c'est une valeur testable  

• l'adresse d'une variable du même type
• la valeur retournée par malloc()
• la valeur retournée par fopen() (de type FILE*)

plus les variantes dérivées de ces exemples...

Tu as du mal à finir ton TP de SDE ?

 
Non. Mais chaque fois que tu déclares un pointeur style "<type> *pt"; tu es obligé d'écrire quelque part "pt=...<une adresse valide>..." avant de t'occuper de "*pt".
 
Donc si tu déclares un pointeur double style "<type> **pt"; il faut d'abord que t'écrives qqpart "pt=...<une adresse valide>..." avant d'aller t'occuper de "*pt" qui devra lui aussi recevoir "...<une adresse valide>..." avant que t'ailles t'occuper de "**pt".
 
Etc etc
 
La fonction "malloc()" alloue une zone mémoire et renvoie l'adresse de la zone allouée. Donc "malloc()" renvoie une adresse valide et c'est pourquoi on peut écrire "pt=malloc(...)". Mais c'est pas la seule façon d'y mettre une  adresse valide.
On peut aussi écrire "int i; int *pt; pt=&i"
 
La seule constante, c'est qu'il y a toujours écrit quelque part "pt=..."

 
il a ecrit
 
*p = 14;
 
pas  
 
p = 14;
 
(noob)
 

'fin c'est faux quand même, puisque p est indéfini à cet endroit du programme

 
(nan rien, c'est juste pour faire mon chieur)

Ok. Je me suis laissé emporté... Corrigé.

 
soit le code

 
on compile et on exécute
fronsac:18> gcc -o essai2 essai2.c
essai2.c: Dans la fonction « main »:
essai2.c:9: AVERTISSEMENT: affectation d'un type pointeur incompatible
essai2.c:10: AVERTISSEMENT: affectation transforme en entier un pointeur sans transtypage
fronsac:19> essai2
 
effectivement ça ne plante pas mais je doute que cela face quelque chose d'interessant et d'utile.
de plus a mon avis pp n'est toujours pas initialisé.
il est possible que dans l'élan une coquille ce soit glissé malicieusement et qu'il fallait lire **ppp
 

Ok, je crois que j'ai bien compris le principe

ué j'ai oublié une etoile, j'etais pas tres reveille

 
Bon, c'est vrai, tu as trouvé un exemple où on peut avoir *pp sans avoir pp=...
Mais en fait, tu masques l'instruction pp=&p en utilisant *ppp qui correspond à pp
Dans les faits... c'est comme si t'avais écrit pp=&p... sauf qu'il faut bien examiner le code pour s'en rendre compte.
 
Ceci démontre qu'on peut toujours pondre un code correct mais réellement illisible.
 

oué chui fan de trucs porcho, j'adore parsemer mon code de machin comme ca pour faire rire mes collegues :