Johdanto C-osoittimiin
Osoittimet määritellään muuttujana, joka sisältää toisen muuttujan muistiosoitteen. C # -osoittimia käytetään aina, kun on lause, joka on vaarallinen ja merkitty vaarallisella avainsanalla. Tämäntyyppiset lausunnot eivät hallitse roskien kerääjiä, ja ne käyttävät osoitinmuuttujia.
Syntaksi: Osoittimet voidaan ilmoittaa
type *var name;
int* a;
Täällä * kutsutaan referenssioperaattoriksi ja a on muuttuja, joka sisältää tyypin int osoitteen.
esimerkki
int *p = & x; // where &x is the memory address of x
Console.WriteLine((int)p) // displaying memory address
Console.WriteLine(*p) // displaying value at memory address
Kuinka osoittimet toimivat C #: ssä?
Alla on esimerkkejä, jotka osoittavat, miten se toimii C #: ssä.
C #: n osoittimet - esimerkki # 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Pointers
(
class Demo
(
public void Method()
(
unsafe
(
int a = 40;
int b = 20;
int* ptr1 = &a;
int* ptr2 = &b;
Console.WriteLine(*ptr1); // displaying the value
Console.WriteLine(*ptr2); // displaying the value
Console.WriteLine((int)ptr1); // displaying the address
Console.WriteLine((int)ptr2); // displaying the address
)
)
)
class Example
(
// main method
public static void Main()
(
Demo d = new Demo();
d.Method();
)
)
)
On olemassa erilaisia tapoja toteuttaa vaarallisia lauseita, kuten muuntaja, rakentaja jne. Yllä olevassa esimerkissä ryhmä lausekkeita on merkitty vaarallisiksi. Yllä olevassa koodissa on kaksi muuttujaa a ja b, joiden arvot ovat vastaavasti 40 ja 20, ja osoittimet sisältävät niiden osoitteet. Console.WriteLine (): tä käytetään muuttujien arvojen ja osoitteiden näyttämiseen.
lähtö:
C #: n osoittimet - esimerkki # 2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Pointers
(
class Demo
(
public unsafe void Method()
(
int a = 50;
int b = 20;
int* ptr1 = &a;
int* ptr2 = &b;
Console.WriteLine(*ptr1); // displaying the value
Console.WriteLine(*ptr2); // displaying the value
Console.WriteLine((int)ptr1); // displaying the address
Console.WriteLine((int)ptr2); // displaying the address
)
)
class Example
(
// main method
public static void Main()
(
Demo d = new Demo();
d.Method();
)
)
)
Yllä olevassa esimerkissä vaarallista käytetään menetelmässä, jolla on kaksi muuttujaa a ja b, joiden arvot ovat vastaavasti 50 ja 20. Osoittimet * ptr1 ja * ptr2 osoittavat muistiosoitteisiin.
lähtö:
C #: n osoittimet - esimerkki # 3
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Pointers
(
class Demo
(
public unsafe static void Main()
(
int() array = ( 10, 20, 30, 40, 50 ); // declaring array
fixed (int* ptr = array) // fixed for pinning the object
/* let us have array address in pointer */
for (int i = 0; i < 5; i++)
(
Console.WriteLine("Value of array((0))=(1)", i, *(ptr + i));
Console.WriteLine("Address of array((0))=(1)", i, (int)(ptr + i));
Console.ReadKey();
)
)
)
)
Yllä olevassa koodissa on määritelty taulukko, joka koostuu viidestä elementistä ja Console.WriteLine (): tä käytetään taulukkoelementtien arvon ja taulukkoelementtien osoituksen näyttämiseen. C #: ssä on käsite, jota kutsutaan kohteen kiinnittämiseksi. Yllä olevassa koodissa kiinteää käskyä käytetään objektin kiinnittämiseen, jotta roskien kerääjä ei anna esineen liikkua ja “kiinnittää” sitä. Se voi vaikuttaa ajonaikaiseen hyötysuhteeseen.
lähtö:
Osoittimet C # - esimerkki 4
using System;
namespace Pointers
(
// Struct employee
struct Employee
(
// members
// employee id and salary
public int empid;
public double salary;
// Constructor to initialize values
public Employee(int e, double s)
(
empid = e;
salary = s;
)
); // end of struct
class Program
(
// Main Method
static void Main(string() args)
(
// unsafe so as to use pointers
unsafe
(
// Declaring two employee Variables
Employee E1 = new Employee(798, 30000);
Employee E2 = new Employee(799, 31000);
// Declaring two employee pointers
// and initializing them with addresses
// of E1 and E2
Employee* E1_ptr = &E1;
Employee* E2_ptr = &E2;
// Displaying details of employees using pointers
// Using the arrow ( -> ) operator
Console.WriteLine("Details of Employee 1");
Console.WriteLine("Employee Id: (0) Salary: (1)",
E1_ptr->empid, E1_ptr->salary);
Console.WriteLine("Details of Employee 2");
Console.WriteLine("Employee Id: (0) Salary: (1)",
E2_ptr->empid, E2_ptr->salary);
) // end unsafe
) // end main
) // end class
)
Yllä olevassa esimerkissä työntekijä rakentaa jäsenten kanssa työntekijän tunnuksen ja palkan ja parametroi rakentajaa arvojen alustamiseksi. Osoittimet osoittavat rakenteita, jotka sisältävät alkeellista arvoa, viitetyyppiä sisältävien rakenteiden sijaan. Päämenetelmässä on kaksi työntekijämuuttujaa ja työntekijäosoittimet, jotka alustetaan osoitteilla E1 ja E2. Console.WriteLine (): tä käytetään työntekijän tietojen näyttämiseen osoittimien avulla.
lähtö:
Osoittimet C # -esimerkissä 5
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Pointers
(
class Demo
(
public static void Main()
(
unsafe
(
int* arr = stackalloc int(6); // declaring array
arr(0) = 10;
arr(1) = 20;
arr(2) = 30;
arr(3) = 40;
arr(4) = 50;
arr(5) = 60;
for (int i = 0; i < 6; i++)
(
Console.WriteLine($"Value at (i): (arr(i))");
Console.ReadKey();
)
)
)
)
)
Yllä olevassa koodissa käytetään pino-avainsanaa, jossa muisti varataan pinolle. Pinolohkossa suoritettu muisti luodaan menetelmän suorituksen aikana. stackalloc on parempi suorituskyky, eikä ryhmää tarvitse kiinnittää. Se on parempi kuin kasaan allokoitu taulukko, koska sitä ei tarvitse vapauttaa, koska se vapautuu automaattisesti, kun menetelmä palaa.
lähtö:
Osoittimissa muunnokset ovat implisiittistä ja eksplisiittistä tyyppiä. Epäsuora muunnostyyppi on kuin mikä tahansa osoittintyyppi tyhjäksi * -tyypiksi ja nolla mille tahansa osoittintyypille. Täsmällisessä muodossa muunnokset ovat tavusta, sbyteistä, ushortista, lyhyestä, uintista, intistä, ulongista, pitkästä mihin tahansa osoittintyyppiin tai päinvastoin ja yhdestä osoittimesta toiseen.
Johtopäätös - osoittimet C #
Joten osoittimia käytetään osoittamaan muistiosoitteet ja suorittamaan ne turvallisella lausekoodilla. Sitä käytetään vain hallitsemattomassa ympäristössä, eikä jätteiden kerääjä seuraa. Osoittimia käytetään pinossa, jonossa jne.
Suositellut artikkelit
Tämä on opas C #: n osoittimiin. Tässä keskustellaan johdannosta ja kuinka osoitin toimii C # -merkinnässä, sekä useita esimerkkejä. Voit myös katsoa seuraavia artikkeleita saadaksesi lisätietoja-
- C #: n käyttö
- Osoittimet C ++: ssa
- C # vs Java-suorituskyky
- Mikä on C?