Bevezetés a C # mutatóira
A mutatókat olyan változóként definiálják, amely egy másik változó memóriacímét tartalmazza. A C # mutatók akkor használatosak, amikor van egy nem biztonságos állítás, amelyet nem biztonságos kulcsszó jelöl. Az ilyen típusú állítások nem irányítják a hulladékgyűjtőket, és mutató változókat használnak.
Szintaxis: A mutatók deklarálhatók
type *var name;
int* a;
Itt * referencia-mentes operátornak nevezzük, és az a változó, amely az int típus címét tartalmazza.
Példa
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
Hogyan működik a Pointers a C # -ben?
Az alábbiakban bemutatjuk azokat a példákat, amelyek megmutatják, hogyan működik a C #.
C # mutatók - 1. példa
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();
)
)
)
Különböző módok vannak a nem biztonságos utasítások végrehajtására, mint például módosító, kivitelező, stb. A fenti példában az utasítások egy csoportja nem biztonságosként van megjelölve. A fenti kódban két a és b változó létezik, amelyek értéke 40, illetve 20, és a mutatók a címüket tartalmazzák. A Console.WriteLine () a változók értékeinek és címeinek megjelenítésére szolgál.
Kimenet:
C # mutatók - 2. példa
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();
)
)
)
A fenti példában nem biztonságos az a módszer, amelynek két a és b változója van, 50, illetve 20 értékkel. A * ptr1 és * ptr2 mutatók a memória címükre mutatnak.
Kimenet:
C # mutatók - 3. példa
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();
)
)
)
)
A fenti kódban egy tömb van meghatározva, amely öt elemből áll, és a Console.WriteLine () a tömb elemek értékének és a tömb elemek címének megjelenítésére szolgál. A C #-ben létezik egy koncepció, amelyet egy objektum rögzítésének hívnak. A fenti kódban egy rögzített nyilatkozatot használunk az objektumok rögzítéséhez, így a szemetesgyűjtő nem engedi, hogy az objektum mozogjon, és „rögzítse” azt. Ez befolyásolhatja a futásidejű hatékonyságot.
Kimenet:
C # mutatók - 4. példa
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
)
A fenti példában az alkalmazott felépíti a tagok alkalmazottainak azonosítóját és fizetését, és paraméterezi a konstruktort az értékek inicializálásához. A mutatók olyan primitív értéket tartalmazó struktúrákra mutatnak, mint a referenciatípust tartalmazó struktúrák. A fő módszerben két alkalmazott változó és alkalmazott mutató található, amelyeket az E1 és E2 címekkel inicializálnak. A Console.WriteLine () a munkavállaló adatainak mutatók segítségével történő megjelenítésére szolgál.
Kimenet:
C # mutatók - 5. példa
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();
)
)
)
)
)
A fenti kódban a stackalloc kulcsszó kerül felhasználásra, amelyben a memóriát a veremre osztják. A verem blokkon végrehajtott memória a metódus végrehajtása során jön létre. A stackalloc jobb teljesítményű, és nincs szükség a tömb rögzítésére. Ez jobb, mint a halom számára kiosztott tömb, mivel nem kell felszabadítani, mert automatikusan felszabadul, amikor a módszer visszatér.
Kimenet:
A mutatókban az átalakítások implicit és explicit típusúak. Az implicit konvertálás típusa olyan, mint bármelyik mutató típusa érvénytelen * típushoz, és nulla bármely mutató típushoz. Kifejezetten tipikusan az átalakítások bájt, sbyte, ushort, rövid, uint, int, ulong, hosszúak bármelyik mutató típusra vagy fordítva, és az egyik mutató a másikra mutat.
Következtetés - C # mutatók
Tehát a mutatókat arra használják, hogy a memóriacímeket rámutassák és egy nem biztonságos utasításkóddal hajtsák végre őket. Csak nem kezelt környezetben használják, és a szemetesgyűjtő nem követi nyomon. A mutatókat veremben, sorban stb. Használják.
Ajánlott cikkek
Ez egy útmutató a C # mutatóira. Itt tárgyaljuk a Bevezetést és a mutató működését a C # -ben, különféle példákkal együtt. A következő cikkeket is megnézheti további információkért -
- A C # felhasználása
- C ++ mutatók
- C # vs Java teljesítmény
- Mi a C?