Pour assigner un pointeur ... [Résolu]

Signaler
Messages postés
88
Date d'inscription
mercredi 1 juin 2005
Statut
Membre
Dernière intervention
26 juillet 2007
-
Messages postés
475
Date d'inscription
dimanche 3 octobre 2004
Statut
Membre
Dernière intervention
11 août 2006
-
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)

4 réponses

Messages postés
1787
Date d'inscription
lundi 22 novembre 2004
Statut
Membre
Dernière intervention
31 janvier 2009
2
#define NULL ((void*)0)

Le cast serait-il implicite en C++ ?
ULARGE_INTEGERJokyQi=QI("Joky"
Messages postés
21042
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
25
Un pointeur n'est qu'une adresse, 0 en vaut une autre.

ciao...
BruNews, MVP VC++
Messages postés
88
Date d'inscription
mercredi 1 juin 2005
Statut
Membre
Dernière intervention
26 juillet 2007

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

wis : in tartiflette I trust (like the others)
Messages postés
475
Date d'inscription
dimanche 3 octobre 2004
Statut
Membre
Dernière intervention
11 août 2006
3
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).