initialisation pointeur ,NULL ou 0 ?

Version imprimable

13/04/2008, 15h35
isoman

initialisation pointeur ,NULL ou 0 ?

Bonjour,
lors de la création d'un pointeur est ce que il y a une différence si on l'initialise a 0 ou a NULL ?
Merci
13/04/2008, 16h00
ram-0000

Dans les faits, je dirai que c'est pareil. Simplement, par habitude, NULL c'est réservé aux pointeurs.

Si je voie "p = NULL", je déduit immediatement que p est un pointeur (de quoi, je n'en sais rien mais pointeur quand même) alors que si je voie "p = 0", je ne sais pas si p est un nombre ou un pointeur.

En plus, on n'est pas à l'abris d'une définition genre "#define NULL (void *)-1" (bien que cela soit peut probable)
13/04/2008, 16h00
Davidbrcz

pour moi non.
13/04/2008, 16h24
koala01

Salut,

Au final, on peut répondre que non.

Seulement, NULL n'est , le plus souvent, jamais qu'un terme déclaré grâce à 'un macro (dont tu peux t'attendre à trouver une définition dans des fichiers tels que cstddef, cstdio, cstring, ctime, cwchar) sous une forme proche de

Code:

#define NULL (void*) 0

ou sous une forme proche de

Code:

#define NULL 0

Sauf que, voilà... NULL est la seule adresse dont il soit certifié qu'elle est invalide, et qu'une impléméntation pourrait très bien décider de la faire pointer sur autre chose que 0X00000000 :P

Comme il n'y a, à ma connaissance (bien que je pourrais le vérifier), pas de précision dans la norme autre que "défini une adresse invalide", il n'est pas impossible d'envisager qu'une implémentation particulière puisse définir NULL comme valant ... autre chose que 0.

L'idéal est donc, à mon sens, de toujours préférer l'utilisation de NULL à celle de 0, ne serait ce que parce que, dans l'idée générale, NULL s'applique principalement à un pointeur, et donc, fournit une information intrinsèque que 0 ne fournit pas.

Maintenant, il ne s'agit ici que d'un avis personnel... que je partage, mais tu trouveras surement sur le forum des gens qui ne le partagent pas ;)
13/04/2008, 17h15
Vespasien

Le grand Bjarne Stroustrup préconise l'emploi de 0 face au problème évoqué par ram_0000.
13/04/2008, 18h22
ram-0000

Citation:

Envoyé par Vespasien

Le grand Bjarne Stroustrup préconise l'emploi de 0 face au problème évoqué par ram_0000.

Je suis très touché que même le grand Bjarne Stroustrup s'intéresse à mes problèmes :P
13/04/2008, 19h05
Sylvain Togni

NULL est garanti être de type entier et de valeur 0 par la norme.

Ce qui ne signifie pas forcement que le pointeur nul vaut 0x00000000, d'ailleurs. Car lorsqu'on affecte NULL ou 0 à un pointeur il y a une conversion de la valeur entière 0 en pointeur nul qui peut avoir n'importe quelle représentation mémoire.
14/04/2008, 01h56
Alp

Le sujet a déjà été abordé à maintes reprises dans le forum. Tu trouveras beaucoup plus d'éléments de réponse grâce à une recherche avancée ;)
14/04/2008, 09h16
Vespasien

Citation:

NULL est garanti être de type entier et de valeur 0 par la norme

Ce Bjarne, quel farceur! Il ne connait plus les normes qu'il écrit. :mouarf:
'Le Langage C++', Bjarne Stroustrup, page 99 en haut à droite.
15/04/2008, 11h41
Sylvain Togni

Citation:

Envoyé par Vespasien

Ce Bjarne, quel farceur! Il ne connait plus les normes qu'il écrit. :mouarf:
'Le Langage C++', Bjarne Stroustrup, page 99 en haut à droite.

Et ? Quel est le problème, je ne voit nul part de contradiction entre ce que j'ai écrit et ce qu'il à écrit.
15/04/2008, 12h52
Vespasien

En langage C++, il arivait fréquemment qu'une macro NULL soit définie pour représenter le pointeur 0. En C++, un contrôle plus sérieux impose l'utilisation du 0 normal, plutot que toute macro NULL telle qu'évoquée. Le nombre de problèmes est aini considérablement réduit. Si vous pensez devoir définir NULL, utilisez
const int NULL = 0;
Le qualificatif const évite toute redéfinition accidentelle de NULL et garanti ...

Bjarne dit que NULL n'est pas dans la norme C++ mais fréquemment définie. C'est très différent de "NULL est garanti être de type entier et de valeur 0 par la norme". Aucune garantie que ton compilateur le prenne correctement. Aucune garanti qu'elle ne soit pas redéfinie ensuite.

je ne voit nul part de contradiction entre ce que j'ai écrit et ce qu'il à écrit Moi, si. Fréquemment les histoires d'amour finissent mal revient donc a dire que toutes les histoires d'amour finissent mal?:cry:
15/04/2008, 13h41
ProgVal

Dans les MégaCours, il y a marqué que parfois, NULL équivaut à -1.
15/04/2008, 18h23
JolyLoic

Citation:

Envoyé par Vespasien

Bjarne dit que NULL n'est pas dans la norme C++ mais fréquemment définie. C'est très différent de "NULL est garanti être de type entier et de valeur 0 par la norme". Aucune garantie que ton compilateur le prenne correctement.

Il ne dit pas ça, et s'il le disait, il se tromperait.

Citation:

Envoyé par La norme, annexe C

C.2.2.3 Macro NULL [diff.null]
1 The macro NULL, defined in any of <clocale>, <cstddef>, <cstdio>, <cstdlib>, <cstring>, <ctime>, or <cwchar>, is an implementationdefined
C++ null pointer constant in this International Standard (18.1).

La question de savoir si NULL est préférable ou pas à 0 est loin de faire l'unanimité entre les experts C++, au point que dans la prochaine norme, un nouveau mot clef (null_ptr) est défini qui devrait résoudre ces problèmes.

Citation:

Envoyé par ProgVal

Dans les MégaCours, il y a marqué que parfois, NULL équivaut à -1.

Dans ce cas, les MégaCours se trompent.
16/04/2008, 09h49
Médinoc

JolyLoic: Alors finalement, la norme C ne garantit pas que if(ptr) équivaut à if(ptr!=NULL) ?
16/04/2008, 10h24
JolyLoic
Je ne connais pas la norme C, mais je ne vois pas ce qui dans l'extrait de la norme C++ que j'ai posté te fait dire ça.

Il est bien sur possible de n'avoir inclus aucun header spécifié, auquel cas NULL ne sera pas compris. Il est aussi possible de faire :
Code:

1 2 3 4 #include <cstdio> #undef NULL int a = 3; #define NULL &a
Mais n'importe quel développeur faisant ça passerait en court martiale, et donc dans les cas courants, pratiques, de tous le jours, if(ptr) équivaut à if(ptr!=NULL) ?
16/04/2008, 10h55
yan

Dans un des ancien thread, il est expliqué que NULL représente la conversion de 0 en pointeur void. Ce qui as un sens en C et pas trop en C++.
Et que c'est pour cela qu'il faut mieux utiliser 0 plustôt que NULL pour initialiser un pointeur en C++, car (void*)0 ne garantie pas que cela corresponde à un pointeur == 0
16/04/2008, 13h00
JolyLoic
Je ne suis pas trop ce que tu veux dire...

En C++, sauf manipulation douteuse, NULL signifie 0, et rien d'autre.

Maintenant, 0, dans les contextes appropriés(1), est interprété comme une "null pointer constant" (dont la représentation en bits est non spécifiée), différente de toutes les valeurs de pointeurs valides.

(1) Ce qui peut poser problème, le fameux :
Code:

1 2 3 4 5 void f(int i); //1 void f(int *j); //2 int *pi = NULL; // Ou =0, c'est pareil f(pi); // C'est 1 qui est choisi
16/04/2008, 13h48
Emmanuel Deloget

Citation:

Envoyé par Médinoc

JolyLoic: Alors finalement, la norme C ne garantit pas que if(ptr) équivaut à if(ptr!=NULL) ?

NULL est un pointeur constant nul (null pointer constant), selon l'annexe C de la norme cité par JolyLoic. La norme dit en outre:

Citation:

Envoyé par Norme C++, 4.10 §1

A null pointer constant is an integral constant expression rvalue of integer type that evaluates to zero.

Citation:

Envoyé par Mongaulois

Dans un des ancien thread, il est expliqué que NULL représente la conversion de 0 en pointeur void. Ce qui as un sens en C et pas trop en C++.

Et que c'est pour cela qu'il faut mieux utiliser 0 plustôt que NULL pour initialiser un pointeur en C++, car (void*)0 ne garantie pas que cela corresponde à un pointeur == 0

En C, NULL est aussi une null pointer constant, mais la définition de ce terme est plus étendue:

Citation:

Envoyé par Norme C99, 6.3.2.3 §3

An integer constant expression with the value 0, or such an expression cast to type void *, is called a null pointer constant.

De fait,

Code:

#define NULL ((void*)0)

et

Code:

#define NULL 0

Sont des définitions C valides, tandis que la première n'est pas valide en C++.

Quoi qu'il en soit,

Code:

#define NULL (valeur différente de 0)

Est invalide, en C comme en C++. Par conséquent, if (ptr) et if (ptr != NULL) sont toujours équivalents.

Citation:

Envoyé par JolyLoic

(1) Ce qui peut poser problème, le fameux :

C'est surtout f(NULL) qui appelle le premier overload, malgré la formulation choisie par le programmeur. pi est du type int*, donc le second overload sera appelé - quelque soit la valeur de pi, y compris si pi == NULL, puisque la décision se fait sur le type du paramètre.
16/04/2008, 14h02
yan

Citation:

Envoyé par Emmanuel Deloget

De fait,

Code:

#define NULL ((void*)0)

et

Code:

#define NULL 0

Sont des définitions C valides, tandis que la première n'est pas valide en C++.

C'est de ça que je parlais. Mais je n'avais plus l'explication.
16/04/2008, 14h48
JolyLoic

Citation:

Envoyé par Emmanuel Deloget

C'est surtout f(NULL) qui appelle le premier overload, malgré la formulation choisie par le programmeur. pi est du type int*, donc le second overload sera appelé - quelque soit la valeur de pi, y compris si pi == NULL, puisque la décision se fait sur le type du paramètre.

Oui, effectivement, à force de vouloir détailler, on dit parfois des bêtises...

'remarque, il m'est déjà arrivé (:oops:) de faire une manip bizarre pour avoir un NULL qui ne s'utilise qu'avec les pointeurs.
C'est sale, c'est un monstre, c'est commenté en Anglais, mais ça satisfaisait mes ardeurs C-istes de l'époque... :aie:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#ifdef __cplusplus
 
#ifndef CLASS_NSNULL_NULLPOINTER_DEFINED
#define CLASS_NSNULL_NULLPOINTER_DEFINED
namespace NsNull
{
 
//When using COM under Visual C++, an inline function in comdef.h uses the
//Visual-specific keyword __uuidof() with NULL, which returns a null UUID.
//
//If this is needed, define CLASS_NSNULL_NULLPOINTER_NEED_UUID before
//including this file
#ifdef CLASS_NSNULL_NULLPOINTER_NEED_UUID
#define CLASS_NSNULL_NULLPOINTER_DECLSPECS DECLSPEC_UUID("00000000-0000-0000-0000-000000000000")
#else
#define CLASS_NSNULL_NULLPOINTER_DECLSPECS
#endif
 
//NullPointer class:
//A class that is implicitely convertible into NULL.
//
//It is not recommended to include this file before standard header files.
//However, it can be done. In this case, when including before MFC headers,
//defining CLASS_NSNULL_NULLPOINTER_NEED_LPARAM might be required, because
//some inline functions in MFC pass directly NULL as a LPARAM.
class CLASS_NSNULL_NULLPOINTER_DECLSPECS NullPointer
{
public:
	inline explicit NullPointer()
	{ }
 
	template< class T >
	inline operator T* (void) const
	{
		T* ptr = 0;
		return ptr;
	}
 
	//Hacks for WPARAM and LPARAM, needed by some MFC files
	#ifdef CLASS_NSNULL_NULLPOINTER_NEED_WPARAM
	inline operator WPARAM (void) const
	{
		WPARAM wParam = 0;
		return wParam;
	}
	#endif// ! CLASS_NSNULL_NULLPOINTER_NEED_WPARAM
	#ifdef CLASS_NSNULL_NULLPOINTER_NEED_LPARAM
	inline operator LPARAM (void) const
	{
		LPARAM lParam = 0;
		return lParam;
	}
	#endif// ! CLASS_NSNULL_NULLPOINTER_NEED_LPARAM
};
 
}//namespace NsNull
#endif// ! CLASS_NSNULL_NULLPOINTER_DEFINED
 
#undef NULL
#define NULL (NsNull::NullPointer())
 
#endif// __cplusplus

PS: Par contre, ça ouvre la porte pour mettre une autre macro à la place de NULL, comme nullptr, et ça, c'est peut-être une bonne chose.

17/04/2008, 09h33
isoman

J'ai plein d'infos, merci à tous pour vos réactions, je vous laisse continuer le sujet :king: