Penunjuk dalam C#

Penunjuk ditakrifkan sebagai pembolehubah yang mengandungi alamat memori pembolehubah lain. Penunjuk dalam C# digunakan apabila terdapat pernyataan yang tidak selamat dan ditandakan dengan kata kunci yang tidak selamat. Jenis pernyataan tersebut tidak mengawal pemungut sampah dan menggunakan pembolehubah penunjuk.

Sintaks: Penunjuk boleh diisytiharkan sebagai

type  *var name;
int* a;

Di sini * dipanggil pengendali nyah rujukan dan a ialah pembolehubah yang mengandungi alamat jenis int.

Contoh

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

Bagaimanakah Penunjuk berfungsi dalam C#?

Di bawah ialah contoh yang menunjukkan cara ia berfungsi dalam C#.

Penunjuk dalam C# – Contoh #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();
}
}
}

Terdapat cara berbeza untuk melaksanakan pernyataan sebagai tidak selamat seperti Pengubah suai, pembina, dll. Dalam contoh di atas, sekumpulan pernyataan ditandakan sebagai tidak selamat. Dalam kod di atas, terdapat dua pembolehubah a dan b dengan nilai masing-masing 40 dan 20 dan penunjuk mengandungi alamatnya. Console.WriteLine() digunakan untuk memaparkan nilai dan alamat pembolehubah.

Output:

Penunjuk dalam C# – Contoh #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();
}
}
}

Dalam contoh di atas, tidak selamat digunakan dengan kaedah yang mempunyai dua pembolehubah a dan b dengan nilai 50 dan 20 masing-masing. Penunjuk *ptr1 dan *ptr2 menunjuk ke alamat memori mereka.

Output:

Penunjuk dalam C# – Contoh #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();
}
}
}
}

Dalam kod di atas, tatasusunan ditentukan yang terdiri daripada lima elemen dan Console.WriteLine () digunakan untuk memaparkan nilai elemen tatasusunan dan alamat elemen tatasusunan. Terdapat konsep dalam C# yang dikenali sebagai Pinning objek. Dalam kod di atas, pernyataan tetap digunakan untuk menyemat objek supaya pengumpul sampah tidak akan membiarkan objek bergerak dan "menyematkannya". Ia mungkin menjejaskan kecekapan masa jalan.

Output:

Penunjuk dalam C# – Contoh #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
}

Dalam contoh di atas, struktur pekerja dengan id pekerja ahli dan gaji serta pembina parameter untuk memulakan nilai. Penunjuk menunjuk kepada struct yang mengandungi jenis nilai primitif dan bukannya struct yang mengandungi jenis rujukan. Dalam kaedah utama, terdapat dua pembolehubah pekerja dan penunjuk pekerja yang dimulakan dengan alamat E1 dan E2. Console.WriteLine() digunakan untuk memaparkan butiran pekerja menggunakan penunjuk.

Output:

Penunjuk dalam C# – Contoh #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();
}
}
}
}
}

Dalam kod di atas, kata kunci stackalloc digunakan, di mana memori diperuntukkan pada tindanan. Memori yang dilaksanakan pada blok tindanan dicipta semasa pelaksanaan kaedah. stackalloc adalah lebih baik dalam prestasi dan tidak perlu menyemat tatasusunan. Ia lebih baik daripada tatasusunan yang diperuntukkan timbunan kerana tidak perlu membebaskannya kerana ia dibebaskan secara automatik apabila kaedah itu kembali.

Output:

Dalam penunjuk, penukaran adalah daripada jenis tersirat dan tersurat. Jenis penukaran tersirat adalah seperti mana-mana jenis penunjuk kepada jenis void* dan nol kepada mana-mana jenis penunjuk. Dalam jenis eksplisit, penukaran adalah daripada bait, sbyte, ushort, pendek, uint, int, ulong, panjang kepada mana-mana jenis penunjuk atau sebaliknya dan satu penuding kepada penuding lain.

Kesimpulan – Penunjuk dalam C#

Jadi penunjuk digunakan untuk menunjukkan alamat memori dan melaksanakannya dengan kod penyata yang tidak selamat. Ia hanya digunakan dalam persekitaran yang tidak terurus dan tidak dijejaki oleh pemungut sampah. Penunjuk digunakan dalam tindanan, baris gilir, dsb.

Atas ialah kandungan terperinci Penunjuk dalam C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!