İşaretçi ile ilgili işleçler (C# Başvurusu)

  • Makale
  • Okumak için 3 dakika

İşaretçilerle çalışmak için aşağıdaki işleçleri kullanabilirsiniz:

İşaretçi türleri hakkında bilgi için bkz. işaretçi türleri.

Not

İşaretçilerle herhangi bir işlem güvenli olmayan bir bağlam gerektirir. Güvenli olmayan bloklar içeren kodun AllowUnsafeBlocks derleyici seçeneğiyle derlenmesi gerekir.

Address-of işleci &

Birli & işleç, işleneninin adresini döndürür:

unsafe
{
    int number = 27;
    int* pointerToNumber = &number;

    Console.WriteLine($"Value of the variable: {number}");
    Console.WriteLine($"Address of the variable: {(long)pointerToNumber:X}");
}
// Output is similar to:
// Value of the variable: 27
// Address of the variable: 6C1457DBD4

&İşlecin işleneni sabit bir değişken olmalıdır. Sabit değişkenler, Atık toplayıcısınınişleminden etkilenmeyen depolama konumlarında bulunan değişkenlerdir. Yukarıdaki örnekte, yerel değişken number yığında bulunduğundan sabit bir değişkendir. Çöp toplayıcısından etkilenebilecek (örneğin, yeniden konumlandırılan) depolama konumlarında bulunan değişkenler Taşınabilir değişkenler olarak adlandırılır. Nesne alanları ve dizi öğeleri taşınabilir değişkenlerin örnekleridir. Taşınabilir bir değişkenin adresini, bir fixed ifadesiyle"düzelmiyor" veya "sabitle" yaparsanız alabilirsiniz. Alınan adres yalnızca bir deyimin bloğunun içinde geçerlidir fixed . Aşağıdaki örnek, bir fixed deyimin ve işlecin nasıl kullanılacağını gösterir & :

unsafe
{
    byte[] bytes = { 1, 2, 3 };
    fixed (byte* pointerToFirst = &bytes[0])
    {
        // The address stored in pointerToFirst
        // is valid only inside this fixed statement block.
    }
}

Bir sabit veya bir değerin adresini alamazsınız.

Sabit ve taşınabilir değişkenler hakkında daha fazla bilgi için C# dil belirtiminin sabit ve taşınabilir değişkenler bölümüne bakın.

Binary & işleci, Boolean işlenenlerinin mantıksal ve işlecini ya da tam sayı işlenenlerinin bit düzeyinde mantıksal ve işlecini hesaplar.

İşaretçi yöneltme işleci *

Birli işaretçi yöneltme işleci, * işleneninin gösterdiği değişkeni edinir. Başvuru operatörü olarak da bilinir. *İşlecin işleneni bir işaretçi türünde olmalıdır.

unsafe
{
    char letter = 'A';
    char* pointerToLetter = &letter;
    Console.WriteLine($"Value of the `letter` variable: {letter}");
    Console.WriteLine($"Address of the `letter` variable: {(long)pointerToLetter:X}");

    *pointerToLetter = 'Z';
    Console.WriteLine($"Value of the `letter` variable after update: {letter}");
}
// Output is similar to:
// Value of the `letter` variable: A
// Address of the `letter` variable: DCB977DDF4
// Value of the `letter` variable after update: Z

*İşleci türündeki bir ifadeye uygulayamazsınız void* .

İkili * işleç, sayısal işlenenlerinin çarpımını hesaplar.

İşaretçi üyesi erişim işleci->

->İşleci işaretçi yöneltme ve üye erişiminibirleştirir. Diğer bir deyişle, x türünde bir işaretçisiyse T* ve türünün erişilebilir bir üyesi ise, y T formun bir ifadesi

x->y

eşdeğerdir

(*x).y

Aşağıdaki örnek işlecinin kullanımını gösterir -> :

public struct Coords
{
    public int X;
    public int Y;
    public override string ToString() => $"({X}, {Y})";
}

public class PointerMemberAccessExample
{
    public static unsafe void Main()
    {
        Coords coords;
        Coords* p = &coords;
        p->X = 3;
        p->Y = 4;
        Console.WriteLine(p->ToString());  // output: (3, 4)
    }
}

->İşleci türündeki bir ifadeye uygulayamazsınız void* .

İşaretçi öğesi erişim işleci []

İşaretçi türünün bir ifadesi için p , formun işaretçi öğesi erişimi p[n] olarak değerlendirilir *(p + n) , burada,, veya ' a n örtülü olarak dönüştürülebilir bir tür olması gerekir int uint long ulong . İşaretçilerle işlecin davranışı hakkında daha fazla bilgi için + , bir tam sayı değerinin bir Işaretçi bölümüne eklenmesi veya çıkarılması bölümüne bakın.

Aşağıdaki örnek, bir işaretçi ve işleçle dizi öğelerine nasıl erişileceğini göstermektedir [] :

unsafe
{
    char* pointerToChars = stackalloc char[123];

    for (int i = 65; i < 123; i++)
    {
        pointerToChars[i] = (char)i;
    }

    Console.Write("Uppercase letters: ");
    for (int i = 65; i < 91; i++)
    {
        Console.Write(pointerToChars[i]);
    }
}
// Output:
// Uppercase letters: ABCDEFGHIJKLMNOPQRSTUVWXYZ

Yukarıdaki örnekte, bir stackalloc ifade yığında bir bellek bloğu ayırır.

Not

İşaretçi öğesi erişim işleci, sınır dışı hataları denetlemez.

[]Türünde bir ifadeyle işaretçi öğesi erişimi için kullanamazsınız void* .

[] Dizi öğesi veya Dizin Oluşturucu erişimiiçin işlecini de kullanabilirsiniz.

İşaretçi aritmetik işleçleri

İşaretçilerle aşağıdaki aritmetik işlemleri gerçekleştirebilirsiniz:

  • Bir işaretçiye veya işaretçiden tamsayı değer ekleme veya çıkarma
  • İki işaretçileri çıkar
  • Bir işaretçiyi artırma veya azaltma

Bu işlemleri türündeki işaretçilerle gerçekleştiremezsiniz void* .

Sayısal türlerle desteklenen aritmetik işlemler hakkında daha fazla bilgi için bkz. Aritmetik işleçler.

Bir işaretçiye veya bir işaretçiye tamsayı değer ekleme veya çıkarma

Türünde bir işaretçi p ve bir T* türün bir ifadesi için n örtük olarak dönüştürülebilir,, int uint long , veya ulong , toplama ve çıkarma için aşağıdaki gibi tanımlanır:

  • Hem hem de p + n n + p ifadeleri, T* tarafından verilen adrese eklenmesinin sonucu olan türünde bir işaretçi üretir n * sizeof(T) p .
  • p - nİfade, T* n * sizeof(T) tarafından verilen adresten çıkarılmasına neden olan türde bir işaretçi oluşturur p .

sizeof İşleci bir türün boyutunu bayt cinsinden edinir.

Aşağıdaki örnek, + bir işaretçi ile işlecinin kullanımını gösterir:

unsafe
{
    const int Count = 3;
    int[] numbers = new int[Count] { 10, 20, 30 };
    fixed (int* pointerToFirst = &numbers[0])
    {
        int* pointerToLast = pointerToFirst + (Count - 1);

        Console.WriteLine($"Value {*pointerToFirst} at address {(long)pointerToFirst}");
        Console.WriteLine($"Value {*pointerToLast} at address {(long)pointerToLast}");
    }
}
// Output is similar to:
// Value 10 at address 1818345918136
// Value 30 at address 1818345918144

İşaretçi çıkarması

İki işaretçi p1 ve p2 türü için T* , ifadesi p1 - p2 tarafından verilen p1 ve p2 tarafından bölünen adresler arasındaki farkı üretir sizeof(T) . Sonucun türü long . Diğer bir deyişle, p1 - p2 olarak hesaplanır ((long)(p1) - (long)(p2)) / sizeof(T) .

Aşağıdaki örnekte işaretçi çıkarma gösterilmektedir:

unsafe
{
    int* numbers = stackalloc int[] { 0, 1, 2, 3, 4, 5 };
    int* p1 = &numbers[1];
    int* p2 = &numbers[5];
    Console.WriteLine(p2 - p1);  // output: 4
}

İşaretçi artışı ve azaltma

++Artış işleci, işaretçi işleneni 1 ekler . --Azaltma işleci, 1 işaretçi işlenenden çıkartır .

İki tür işleç desteklenir: sonek ( p++ ve p-- ) ve ön ek ( ++p ve --p ). Ve sonucu, p++ p-- p işlemden önceki değeridir. Ve sonucu, ++p --p p işlemden sonraki değeridir.

Aşağıdaki örnek, hem sonek hem de önek artırma işleçlerinin davranışını gösterir:

unsafe
{
    int* numbers = stackalloc int[] { 0, 1, 2 };
    int* p1 = &numbers[0];
    int* p2 = p1;
    Console.WriteLine($"Before operation: p1 - {(long)p1}, p2 - {(long)p2}");
    Console.WriteLine($"Postfix increment of p1: {(long)(p1++)}");
    Console.WriteLine($"Prefix increment of p2: {(long)(++p2)}");
    Console.WriteLine($"After operation: p1 - {(long)p1}, p2 - {(long)p2}");
}
// Output is similar to
// Before operation: p1 - 816489946512, p2 - 816489946512
// Postfix increment of p1: 816489946512
// Prefix increment of p2: 816489946516
// After operation: p1 - 816489946516, p2 - 816489946516

İşaretçi karşılaştırma işleçleri

,,,, == != < Ve işleçlerini, > gibi <= >= herhangi bir işaretçi türünün işlenenlerini karşılaştırmak için kullanabilirsiniz void* . Bu işleçler, iki işlenen tarafından verilen adresleri işaretsiz tamsayılar gibi karşılaştırır.

Diğer türlerin işlenenleri için bu işleçlerin davranışı hakkında daha fazla bilgi için bkz. eşitlik işleçleri ve karşılaştırma işleçleri makaleleri.

İşleç önceliği

Aşağıdaki liste, işaretçinin ilgili işleçlerini en yüksek öncelikten en düşüğe başlayarak sıralar:

  • Sonek artırma x++ ve azaltma x-- işleçleri ve -> ve [] işleçleri
  • Ön ek artırma ++x ve azaltma --x işleçleri ve & ve * işleçleri
  • Eklenebilir + ve - işleçler
  • Karşılaştırma < , > , <= , ve >= işleçler
  • Eşitlik == ve != işleçler

()İşleç önceliğine göre uygulanan değerlendirmenin sırasını değiştirmek için parantez ' nu kullanın.

Öncelik düzeyine göre sıralanan C# işleçlerinin tüm listesi için c# işleçleri makalesinin operatör önceliği bölümüne bakın.

Operatör overloadability

Kullanıcı tanımlı bir tür, işaretçiyle ilgili işleçleri,, & * -> ve ile aşırı yükleyemez [] .

C# dili belirtimi

Daha fazla bilgi için C# dil belirtimininaşağıdaki bölümlerine bakın:

Ayrıca bkz.