Sissejuhatus kursoritesse C #
Osutid on määratletud muutujana, mis sisaldab mõne muu muutuja mäluaadressi. C # osutit kasutatakse alati, kui on olemas lause, mis pole ohtlik ja on tähistatud ohtliku märksõnaga. Seda tüüpi avaldused ei kontrolli prügivedajaid ja kasutavad osuti muutujaid.
Süntaks: viiteid saab kuulutada kui
type *var name;
int* a;
Siin nimetatakse * viiteoperaatoriks ja a on muutuja, mis sisaldab tüübi int aadressi.
Näide
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
Kuidas Pointers C #-s töötab?
Allpool on toodud näited, mis näitavad, kuidas see C #-s töötab.
C # osuti - näide # 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();
)
)
)
Ohtlike avalduste täitmiseks on erinevaid viise, nagu modifikaator, konstruktor jne. Ülaltoodud näites tähistatakse avalduste rühma ebaturvalisena. Ülaltoodud koodis on kaks muutujat a ja b vastavalt väärtustega 40 ja 20 ning osutid sisaldavad nende aadresse. Console.WriteLine () kasutatakse muutujate väärtuste ja aadresside kuvamiseks.
Väljund:
C # osuti - näide # 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();
)
)
)
Ülaltoodud näites kasutatakse ebaturvalist meetodit, millel on kaks muutujat a ja b vastavalt väärtustega 50 ja 20. Osutid * ptr1 ja * ptr2 osutavad nende mäluaadressidele.
Väljund:
C # osuti - näide # 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();
)
)
)
)
Ülaltoodud koodis on määratletud massiiv, mis koosneb viiest elemendist ja Console.WriteLine () kasutatakse massiivi elementide väärtuse ja massiivi elementide aadressi kuvamiseks. C #-s on olemas kontseptsioon, mida tuntakse kui objekti kinnistamist. Ülaltoodud koodis kasutatakse objektide kinnitamiseks fikseeritud lauset, nii et prügikoguja ei lase objektil liikuda ega “kinnita” seda. See võib mõjutada käitustöö efektiivsust.
Väljund:
C # osuti - näide # 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
)
Ülaltoodud näites koostab töötaja liikmetega töötaja ID ja palga ning parameetrib konstruktorit väärtuste lähtestamiseks. Osutid osutavad algset väärtustüüpi sisaldavatele konstruktsioonidele, mitte võrdlustüüpi sisaldavatele konstruktsioonidele. Põhimeetodi puhul on olemas kaks töötaja muutujat ja töötaja viit, mis lähtestatakse aadressidega E1 ja E2. Console.WriteLine () kasutatakse kursori abil töötaja üksikasjade kuvamiseks.
Väljund:
C # osuti - näide # 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();
)
)
)
)
)
Ülaltoodud koodis kasutatakse märksõna stackalloc, milles virnale eraldatakse mälu. Virnaplokis täidetav mälu luuakse meetodi täitmise ajal. stackalloc on parem jõudlus ja pole vaja massiivi kinnitada. See on parem kui hunnikutega eraldatud massiiv, kuna pole vaja seda vabastada, kuna see vabastatakse meetodi naasmisel automaatselt.
Väljund:
Osutites on teisendused kaudset ja selgesõnalist tüüpi. Kaudne teisendustüüp on nagu iga osuti tüüp tühiseks * tüübiks ja null ükskõik milliseks osuti tüübiks. Selgesõnalise tüübi puhul on teisendused baitist, baitist, ushortist, lühikesest, uindist, int, ulongist, pikad suvalisse osutitüüpi või vastupidi ja ühest osutist teise osuti.
Järeldus - viited C-le
Niisiis kasutatakse viiteid mäluaadresside osutamiseks ja ebaturvalise avalduste koodiga täitmiseks. Seda kasutatakse ainult haldamata keskkonnas ja prügikoguja ei jälgi seda. Viiteid kasutatakse korstnas, järjekorras jne.
Soovitatavad artiklid
See on juhend kursorile C #. Siin käsitleme sissejuhatust ja seda, kuidas osuti töötab C #-s koos erinevate näidetega. Lisateabe saamiseks võite vaadata ka järgmisi artikleid -
- Kasutab C #
- C ++ osutid
- C # vs Java jõudlus
- Mis on C?