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

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

  • Birli (Adres-of) işleci: bir değişkenin adresini almak için
  • Birli (işaretçi yöneltme) işleci: bir işaretçiye işaret eden değişkeni almak için
  • (Üye erişimi) ve (öğe erişimi) işleçleri
  • Aritmetik işleçler , - , ++ , ve --
  • Karşılaştırma işleçleri , !=<=<> ,,, ve >=

İş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 ifadesiyle"düzelmiyor" veya "sabitle" yaparsanız alabilirsiniz. Alınan adres yalnızca bir fixed deyimin bloğunun içinde geçerlidir. 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 belirtimininsabit ve taşınabilir değişkenler bölümüne bakın.

Binary & işleci, Boolean işlenenlerinin & 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 void* bir ifadeye uygulayamazsınız * .

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

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

->İşleci -> ve üye erişiminibirleştirir. Diğer bir deyişle, x türünde T* bir işaretçisiyse ve y türünün T erişilebilir bir üyesi ise, 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 void* bir ifadeye uygulayamazsınız -> .

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

İşaretçi türünün bir ifadesi p için, formun p[n] işaretçi öğesi erişimi olarak *(p + n) değerlendirilir, burada n , uintlong , veya ulong ' a örtülü olarak dönüştürülebilir int bir tür olması gerekir. İşaretçilerle işlecin davranışı + hakkında daha fazla bilgi için, + 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 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 void* bir ifadeyle işaretçi öğesi erişimi için kullanamazsınız.

[]iç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 void* işaretçilerle gerçekleştiremezsiniz.

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 T* bir işaretçi p ve bir türün bir ifadesi n için örtük olarak dönüştürülebilir int , uintlong ,, veya ulong , toplama ve çıkarma için aşağıdaki gibi tanımlanır:

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

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

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 ++ . Azaltma işleci, -- 1 işaretçi işlenenden -- .

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

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 void* işlenenlerini karşılaştırmak için kullanabilirsiniz. == 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.