Pour assigner un pointeur ...

Il me semblait que pour declarer un pointeur il fallait faire
double* pointeur = NULL;
Mais dans un cours de C++ et des codes, je vois des 0,

Peut on declarer des pointeurs sur des type simple par 0 ???
double* pointeur = 0;
Peut on declarer des pointeurs sur des objet de classes pareillement ???
Maclasse* MonObjet = 0;


wis : in tartiflette I trust (like the others)

Salut, je prend donc vos reponses comme un oui ... ??
Oui


wis : in tartiflette I trust (like the others)

En C comme en C++ on peut écrire :
double* pointeur = 0;

c'est équivalent à :
double* pointeur = (double *)0;

Mais la vrai question c'est pourquoi le standard C++ ne définie pas la macro NULL ?

D'abord il faut savoir que l'adresse nulle n'est pas forcément l'adresse 0, par contre les standards (C et C++) garantissent que la valeur 0 "castée" en pointeur est l'adresse nulle. C'est pour ca qu'n C elle est définie ainsi :
#define NULL ((void *)0)
c'est à dire 0 convertie en pointeur, et pointeur de type void car le C autorise les conversions dans les 2 sens entre un pointeur void et un pointeur d'un autre type.

Le standard C définie la macro NULL pour palier à une faiblesse du langage, cette faiblesse c'est le fait qu'une fonction peut etre déclarée sans connaitre le type et le nombre d'argument.
Soit la fonction f définie ainsi :
int f(char * p) {}

sa déclaration est :
int f();

et son prototype (qui inclue la déclaration) non obligatoire :
int f(char *p);

Le prototype est par contre obligatoire en C++ (ne pas oublier que C et C++ sont incompatible, bien que syntaxiquement trés proche), c'est même une caractéristique du C++ reprise par le C (C89).

Donc en C, lorsque le compilateur doit résoudre l'appel d'une fonction, bien que celle-ci soit déclarée, il peut ne pas connaitre le nombre et le type des arguments.
Si j'appelle la fonction f de cette facon :
int n = f(NULL);

le compilateur détermine à partir de cet appel que la fonction prend un argument de type void * (ce qui n'est pas tout a fait vrai mais assimilable), donc aucun probleme.

Par contre en appelant la fonction f de cette facon :
int n = f(0);

Le compilateur en déduit que la fonction f prend argument de type int, et la ca peut poser 2 problemes suivant l'architecture :
- d'abord si la taille d'un int est différente de la taille d'un pointeur, on empilera plus ou moins d'octets que prévue, la pile sera corrompue dans le contexte de la fonction.
- ensuite si l'adresse nulle n'est pas la valeur 0 elle ne sera pas interprètée comme telle dans la fonction.

Comme en C++ le prototype est obligatoire (et assimilé à la déclaration) on n'a pas ce probleme. D'ailleur en C++ seul les conversion T * -> void * sont valides, par conséquent NULL ne peut etre définie que de cette facon :
#define NULL 0 // pas standard
ce qui est tout juste bon à rendre le code plus lisible (c'est une histoire de gout).