C # pointeurs
Que sont les pointeurs en C # dans Ubuntu 20.04?
Les pointeurs sont utilisés pour allouer dynamiquement la mémoire. Nous pouvons dire qu'un pointeur est une variable qui contient l'adresse d'un emplacement de mémoire. Il y a deux parties à chaque variable spécifiée dans un programme:
- Adresse variable.
- Valeur variable stockée.
Lorsqu'une déclaration en C # est déclarée dangereuse avec le mot clé dangereux, les pointeurs sont utilisés. Ces déclarations, qui utilisent des variables de pointeur, ne sont pas contrôlées par des collectionneurs à ordures.
Faire la déclaration de pointeurs en C # dans Ubuntu 20.04
Le script suivant est la syntaxe générale de la façon de déclarer un type de pointeur:
type * variable_name;
int * p;
L'opérateur de déréférence est indiqué par le symbole d'astérisque (*). La valeur de l'adresse à laquelle les références de pointeur sont acquises à l'aide de l'opérateur de déréférence. Déclare «p», une variable de pointeur qui porte l'adresse d'un type int. Notez que lorsqu'une fonction du bloc de code est désignée avec le modificateur dangereux, C # permet d'utiliser les variables de pointeur. Un bloc de code où une variable de pointeur est déclarée est connue sous le nom de code dangereux ou de code non géré. Dans Ubuntu 20.04, nous devons compiler un code dangereux comme ceci: CS / Nom de fichier dangereux.CS
Comment utiliser les pointeurs en C # dans Ubuntu 20.04
Le mot-clé dangereux peut être utilisé de nombreuses façons. Il peut être utilisé pour modifier une méthode, une propriété, un constructeur, etc. Pour mieux comprendre comment les pointeurs sont déclarés dans le langage de programmation C #, considérez les exemples suivants:
Exemple # 1: Utilisation de pointeurs pour la déclaration en C # dans Ubuntu 20.04
L'illustration suivante montre comment déclarer et utiliser une variable de pointeur. Ici, nous avons utilisé le modificateur dangereux. Le signe * est utilisé pour déclarer implicitement les pointeurs, comme dans l'exemple donné:
Le code commence par l'importation des fichiers d'espace d'utilisation et de noms. Le fichier de l'espace de noms a attribué le nom «cSharppointers». Le fichier d'espace de noms a un bloc dans lequel nous avons défini une classe «Program1». Dans la classe «Program1», nous avons des mots clés dangereux utilisés avec la fonction principale. Le mot-clé dangereux nous permet d'utiliser des codes dangereux en C # uniquement. Ensuite, nous avons déclaré deux variables dans la fonction principale dangereuse. La première variable se voit attribuer un nom «valeur» et définit son type à int. La «valeur» variable est une valeur entière. La deuxième variable est représentée comme «V» de type int avec le symbole astérisque (*), il s'agit donc d'une variable de pointeur de type entier. La variable du pointeur a l'opérateur d'adresse (&) utilisé avec la variable «valeur». En tant que pointeur, il renverra l'adresse de la valeur. L'instruction Writeline imprimera la valeur et l'adresse des variables spécifiées.
Nous avons obtenu la sortie suivante de l'exécution de code ci-dessus. La valeur et l'adresse sont affichées dans l'image.
Exemple n ° 2: Utilisation de pointeurs pour accéder aux tableaux en C # dans Ubuntu 20.04
Un tableau est un ensemble de données du même type qui ne sont distinguées que par leur ordre de stockage. Dans le programme C # suivant, les tableaux sont accessibles à l'aide de notations de pointeur.
Le code est démontré où nous avons défini la classe dans le fichier d'espace de noms «Pointerprogram». La classe a attribué un nom «Program2» et nous avons appelé la fonction principale avec un modificateur dangereux. Dans la fonction principale dangereuse, nous avons créé un tableau de référence de type int en tant que «MyArray». Nous avons stocké cinq valeurs différentes dans un tableau. Ensuite, nous avons créé une variable «PTR» avec notation du pointeur. La variable du pointeur a stocké un tableau et nous avons épinglé la variable du pointeur avec le mot-clé «fixe». Le mot-clé «fixe» limite la variable du tableau à une allocation de mémoire spécifique. L'instruction WriteLine est utilisée pour afficher l'adresse mémoire et la valeur de type de données du tableau.
Comme vous pouvez le voir, chaque élément du tableau, ainsi que son adresse, s'affiche dans la sortie du code ci-dessus.
Exemple # 3: Utilisation de pointeurs dans les structures en C # dans Ubuntu 20.04
En C #, les types de valeur sont les seuls composants des structures. Les pointeurs ne sont utilisés que dans les structures où les membres principaux sont tous des types de valeur. Les pointeurs sont utilisés pour accéder aux membres de structure dans le programme suivant écrit en C #.
Le code ci-dessus a une structure définie comme «employé» et dans la structure, nous avons défini ses membres «Empid» de type int et «empsalary» de la propriété de type double. Nous avons également construit le constructeur de la structure «employé» pour initialiser les valeurs de «Empid» et «Empsalary» comme «X» et «Y». Ensuite, nous avons créé une classe «Program3» qui a la fonction principale. Dans la fonction principale, nous avons une étiquette dangereuse qui n'aurait pas besoin d'utiliser l'instruction dangereuse pour encapsuler les variables du pointeur ou tout autre. Les valeurs sont définies pour les membres «Empid» et «Empsalary» dans l'objet «E1». Le pointeur est créé pour la structure «employé» comme «E1_PTR» et l'initialise avec l'adresse de «E1».
L'énoncé d'écriture est utilisé pour afficher les détails «employés» de la structure donnée. Nous avons utilisé un opérateur de flèches avec les pointeurs qui ont accédé aux variables et aux méthodes de la structure spécifiée.
L'exécution du programme ci-dessus a la sortie suivante affichée sur l'écran du terminal.
Exemple n ° 4: Utilisation de pointeurs dans les méthodes en C # dans Ubuntu 20.04
Un pointeur peut également être retourné par les méthodes. L'exemple ci-dessous a passé les pointeurs comme paramètre d'une méthode.
Nous avons une classe définie comme «Program4» dans le fichier d'espace de noms. La classe a une fonction principale en tant que «méthode» dans laquelle nous avons utilisé l'étiquette «dangereuse». Nous avons déclaré une variable «A1» et «A2» dans le bloc dangereux. Ces variables sont initialisées avec les valeurs entières. Nous avons créé deux pointeurs en tant que «PTR1» et «PTR2» de Type int. Maintenant, ces pointeurs sont appelés variables de pointeur entier. Nous avons donné l'adresse des variables «A1» et «A2» à ces pointeurs. La méthode écrite est appelée qui affichera la valeur et l'adresse des variables données. Ensuite, nous avons une autre «démo» de classe où nous devons déclarer un objet «P» pour la classe «Program4». La «méthode» est invoquée dans cette classe pour accéder à la valeur et à l'adresse de son membre dans la classe «démo».
Nous obtenons la sortie suivante sur la console après avoir compilé le code ci-dessus.
Conclusion
Nous sommes arrivés à la fin de l'article en découvrant que les pointeurs affichant l'adresse mémoire sont exécutés à l'aide d'un ensemble de déclarations dangereuses. Le code dangereux est nécessaire car le collecteur des ordures ne maintient pas les emplacements de mémoire dans un environnement non géré. Nous avons appris les moyens d'utiliser des pointeurs dans les méthodes, les structures et accéder à la gamme d'éléments à travers les différentes illustrations.