Null en C ++

Un pointeur nul ne pointe de rien. La constante par défaut null a une valeur de 0. Semblable à la façon dont les chaînes de fin C ++, le caractère 0 est utilisé pour terminer les chaînes. Null est une autre valeur possible pour un pointeur, et à moins que le CPU ne supporte un modèle de bits particulier pour les pointeurs nuls, il a la même signification que zéro. Quelque chose n'a pas de valeur lorsqu'il est marqué avec le marqueur spécial SQL nul ou appelé null. Le personnage ASCII ASCII à valeur zéro connue connue sous le nom de «NULL» ou «NUL» est fréquemment utilisée comme séparateur, Terminator ou remplissage «Null» ou «NUL». Ce symbole n'a pas de représentation visible. Un pointeur d'objet (ou référence) qui n'est pas actuellement défini sur un objet est connu sous le nom de pointeur nulle ou de référence. Il peut également être écrit comme aucun, null ou nil.

Pourquoi utilisons-nous null?

L'utilisation de pointeurs nuls est autorisée dans les circonstances suivantes:

Initialiser les pointeurs et illustrer des situations similaires à la fin d'une liste de longueur arbitraire. Décrire toute erreur avec un pointeur renvoyé d'une fonction.

Syntaxe
En C ++, il est relativement facile de donner à une variable une valeur nulle; Nous n'avons besoin de le faire qu'une seule fois, lors de l'initialisation. Cette variable est ensuite gérée pour agir comme le pointeur nul.

Puisque nous sommes conscients que le pointeur contient l'adresse mémoire, nous pouvons utiliser Null dans cette situation pour faire du point de pointeur une valeur différente. Cependant, nous devons l'utiliser lors du lancement du pointeur. Cet article examinera différents exemples d'utilisation du NULL dans les programmes C ++.

Exemple non. 1

Trois pointeurs distincts sont créés dans cet exemple, et ils pointent tous vers le null. En conséquence, nous pouvons voir que lorsque nous avons déclaré les variables, la valeur de la variable a été initialisée. Ci-après, nous effectuons une vérification pour vérifier et imprimer la valeur du pointeur. Si l'instruction s'avère précise, l'instruction IMPRESS sera exécutée; Sinon, il reviendra.

Si un pointeur en C ++ n'accède aucune adresse mémoire, il n'accède pas à Null. Nous utiliserons des techniques nulles pour leur donner des valeurs.

#inclure
Utilisation de Namespace Std;
int main ()
int * ptr_1 = null;
int * ptr_2 = null;
int * ptr_3 = null;
si(!ptr_1)
couter << "Value of the pointer " << ptr_1 ;

retour 0;

Dans cet exemple, nous incluons d'abord la bibliothèque, puis utilisons l'espace de noms standard. Nous l'appellerons dans la fonction principale (). La ligne suivante comprend la déclaration de trois pointeurs, et nous leur avons attribué la valeur «null». Ensuite, nous utilisons la condition «IF». Si la condition requise est remplie, l'instruction «cout» imprime la valeur du premier pointeur.

Exemple non. 2

Dans cette illustration, nous utiliserons la fonction NULL C ++ pour montrer comment initialiser le pointeur avec la valeur nul, simplement une valeur particulière que nous pouvons attribuer lors de l'initialisation.

#inclure
Utilisation de Namespace Std;
int main ()
couter<<"Use of null functions";
couter<<"\n";
int * p_1 = null;
int * p_2 = null;
int * p_3 = null;
couter << "The calculated value of the first pointer: " << p_1 ;
couter<<"\n";
couter << "The calculated value of the second pointer: " << p_2 ;
couter<<"\n";
couter << "The calculated value of the third pointer: " << p_3 ;
retour 0;

Nous avons intégré le fichier d'en-tête . Ensuite, nous faisons du codage dans le corps de la fonction principale (). Dans le corps de la fonction principale (). Nous initialisons trois pointeurs et fixons ces pointeurs sur le «null». En utilisant l'instruction «cout», nous imprimons les valeurs des pointeurs (p_1, p_2 et p_3). En fin de compte, nous entrerons «return0».

Exemple non. 3

Utilisation d'un pointeur nul pour générer une déclaration conditionnelle dans le programme et démontrant comment ils modifient la valeur pendant que l'initialisation est démontrée dans ce cas.

#inclure
Utilisation de Namespace Std;
int main ()
int v_1 = 45;
int v_2 = 38;
int v_3 = 23;
couter<<"Use of null functions:";
couter<<"\n";
int * pt1 = null;
int * pt2 = null;
int * pt3 = null;
couter<<"The values of variables before using null function:";
couter<<"\n";
couter << "The value of first variable before using null function:" << pt1 ;
couter<<"\n";
couter << "The value of second variable before using null function:" << pt2 ;
couter<<"\n";
couter << "The value of third variable before using null function:" << pt3 ;
couter<<"\n";
si(!pt1)
pt1 = &v_1;
couter << "The value of first variable after initialization: " << pt1 ;
couter<<"\n";

si(!pt2)
pt2 = &v_2;
couter << "The value of second variable after initialization: " << pt2 ;
couter<<"\n";

si(!pt3)
pt3 = &v_3;
couter << "The value of third variable after initialization: " << pt3 ;
couter<<"\n";

retour 0;

Après avoir incorporé la bibliothèque et la fonction standard, nous invoquerons la fonction principale (). Ensuite, nous initialisons trois variables nommées V_1, V_2 et V_3. Ensuite, nous générons une instruction conditionnelle dans ce code, initialisons les valeurs des pointeurs et attribuons une valeur «nul» à chaque pointeur. Nous utilisons la condition «IF». Tout d'abord, nous affichons la valeur des pointeurs avant d'utiliser la fonction nul. Ensuite, nous obtenons les valeurs du pointeur après l'initialisation en utilisant l'instruction «cout».

Exemple non. 4

Utilisez null si vous ne pouvez pas fournir de destination pour un pointeur. Les applications qui utilisent des pointeurs sont protégées contre les accidents et les fuites de mémoire par la valeur nulle. Pointer en C et C ++ fait référence au stockage d'une adresse mémoire. Attribuez toujours le pointeur NULL à une variable de pointeur si vous n'êtes pas sûr de l'emplacement précis pour attribuer. Cela se produit lorsqu'une variable est déclarée. Les pointeurs avec la valeur null sont considérés comme des pointeurs nuls.

#inclure
Utilisation de Namespace Std;
int main()

int * p = null;
couter << "The value of pointer is " << p ;
retour 0;

Nous inclurons la bibliothèque au début du code. Ici, nous déclarerons le pointeur et le affecterons avec une valeur «nul». Avant d'entrer dans la commande «return 0», l'instruction «cout» est appliquée pour afficher la valeur du pointeur.

Exemple non. 5

Chaque variable représente un emplacement de mémoire, et chaque emplacement de mémoire a une adresse unique qui peut être accessible à l'aide de l'opérateur AmperSand (&), qui signifie une adresse mémoire. Considérez ce qui suit, qui imprime les adresses variables qui ont été déclarées:

#inclure
Utilisation de Namespace Std;
int main ()

int v1;
char v2 [42];
couter << "The address of first required variable: ";
couter << &v1 << endl;
couter << "The address of second required variable: ";
couter << &v2 << endl;
retour 0;

Au début du code, nous inclurons la bibliothèque requise. Ici, nous initialiserons une variable «V1» ayant un type de données entier. Une autre variable, «V2», sera initialisée avec un type de données de caractère. Et cette variable est déclarée comme un tableau. Nous voulons imprimer l'adresse de ces deux variables, nous utiliserons donc la déclaration «cout». L'adresse sera obtenue avec l'aide de l'opérateur «&».

Conclusion

Après avoir lu cet article, nous voyons comment utiliser les fonctions nuls pour attribuer des valeurs aux variables. Lors de la programmation, les valeurs nulles sont essentielles pour prévenir les échecs inattendus. Par conséquent, lorsqu'un pointeur ne fait référence à aucune adresse de mémoire, les fonctions nulles ou les affectations nuls à un pointeur sont utilisées pour fournir une valeur par défaut.