İşaretçiyle ilgili işleçler - bellek ve başvuru kaldırma bellek konumları - C# reference

İşaretçi işleçleri bir değişkenin adresini (& ) almanıza, bir işaretçiye başvurmamanıza (* ), işaretçi değerlerini karşılaştırmanıza ve işaretçilerle tamsayıları eklemenize veya çıkarmanıza olanak tanır.

C# dili başvuru belgesi, C# dilinin en son yayımlanan sürümünü gösterir. Ayrıca, yaklaşan dil sürümü için genel önizlemelerdeki özelliklere yönelik ilk belgeleri içerir.

Belgelerde ilk olarak dilin son üç sürümünde veya geçerli genel önizlemelerde sunulan tüm özellikler tanımlanır.

Tavsiye

Bir özelliğin C# dilinde ilk tanıtıldığı zamanları bulmak için C# dil sürümü geçmişi makalesine bakın.

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

Birli & (adres- adresi) işleci: bir değişkenin adresini almak için
Birli * (işaretçi dolaylı) işleci: bir işaretçi tarafından işaret edilen 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 . İşaretçi türleri.

Not

İşaretçileri olan herhangi bir işlem güvenli olmayan bir bağlam gerektirir. Güvenli olmayan bloklar içeren kodu AllowUnsafeBlocks derleyici seçeneğiyle derlemeniz gerekir.

İşlecin adresi &

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 , çöp toplayıcının etkilemediği 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ının etkileyebileceği depolama konumlarında bulunan değişkenlere (örneğin, yer değiştirme) taşınabilir değişkenler denir. Nesne alanları ve dizi öğeleri taşınabilir değişkenlere örnektir. Bir deyimini kullanarakfixed "düzeltir" veya "sabitlerseniz" taşınabilir değişkenin adresini alabilirsiniz. Alınan adres yalnızca bir fixed deyiminin bloğu içinde geçerlidir. Aşağıdaki örnekte deyimi fixed ve işlecinin nasıl kullanılacağı gösterilmektedir & :

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 sabitin veya 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.

İkili & işleç, Boole işlenenlerinin mantıksal AND'sini veya integral işlenenlerinin bit düzeyinde mantıksal AND'sini hesaplar.

İşaretçi dolaylı işleci *

Birli işaretçi dolaylı işleci * , işlenen noktalarının bulunduğu değişkene erişir. Başvuru kaldırma işleci olarak da bilinir. İşlecin işleneni * 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

işlecini * türünde void*bir ifadeye uygulayamazsınız.

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

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

işleci, -> işaretçi dolaylı ve üye erişimini birleştirir. Türün T* işaretçisiyse ve y türünün Terişilebilir bir üyesiysex, formun bir ifadesidir

x->y

eşdeğerdir

(*x).y

Aşağıdaki örnekte işlecin kullanımı gösterilmektedir -> :

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)
    }
}

türünde void*bir ifadede işlecini -> kullanamazsınız.

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

İşaretçi türündeki bir ifade p için, formun p[n] işaretçi öğesi erişimi olarak *(p + n)değerlendirilir. Değerin n , , uintlongveya ulongiçin örtük olarak dönüştürülebilir intbir türde olması gerekir. İşlecin işaretçilerle davranışı + hakkında bilgi için, işaretçiye veya işaretçiden integral değeri ekleme veya çıkarma bölümüne bakın.

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

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ızvoid*.

Dizi öğesi veya dizin oluşturucu erişimi[]işlecini de kullanabilirsiniz.

İşaretçi aritmetik işleçleri

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

İşaretçiye tamsayı değeri ekleme veya işaretçiden çıkarma
İki işaretçiyi çıkarma
İşaretçiyi artırma veya azaltma

Türünde işaretçilerle void*bu işlemleri gerçekleştiremezsiniz.

Sayısal türler kullanılarak desteklenen aritmetik işlemler hakkında bilgi için bkz. Aritmetik işleçler.

İşaretçiye tamsayı değeri ekleme veya işaretçiden çıkarma

Türün işaretçisi p ve örtük olarak , , longveya ulong, uinttoplama ve çıkarma işlemine intdönüştürülebilir bir tür ifadesi n için aşağıdaki gibi T* çalışır:

Her ikisi de p + n ve n + p türünde T*bir işaretçi verir. İşaret eden adrese p ekleyerek n * sizeof(T) bu işaretçiyi alırsınız.
ifadesi p - n size türünde T*bir işaretçi verir. İşaret eden adresten p çıkararak n * sizeof(T) bu işaretçiyi alırsınız.

işlecisizeof bir türün boyutunu bayt cinsinden alır.

Aşağıdaki örnekte, işlecin işaretçiyle nasıl kullanılacağı + gösterilmektedir:

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 ve türünde ifadep1 - p2, ve işaret eden adresler p1 arasındaki farkı size verir ve p2 değerine bölünürsizeof(T).T*p2p1 Sonuç türündedir long. Başka 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ırma ve azaltma

++ Artım işleci işaretçi işlenenine 1 ekler. -- Azaltma işleci, işaretçi işleneninden 1 çıkarır.

her iki işleç de iki biçimi destekler: sonek (p++ ve p--) ve ön ek (++p ve --p). ve sonucu, işlemden öncekip++.p--p ve sonucu, işlemden sonraki++p.--pp

Aşağıdaki örnekte hem sonek hem de ön ek artım işleçlerinin davranışı gösterilmektedir:

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

dahil olmak üzere ==herhangi bir işaretçi türünün işlenenlerini karşılaştırmak için , !=<>, , , <=, ve >= işleçlerini kullanabilirsinizvoid*. Bu işleçler, iki işlenen tarafından verilen adresleri, imzalanmamış tamsayılar gibi karşılaştırır.

Diğer türlerin işlenenleri için bu işleçlerin davranışı hakkında bilgi için, Eşitlik işleçleri ve Karşılaştırma işleçleri makalelerine bakın.

İşleç önceliği

Aşağıdaki liste, işaretçiyle ilgili işleçleri en yüksek önceliğe en düşükten başlayarak sıralar:

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

İşleç önceliği tarafından uygulanan değerlendirme sırasını değiştirmek için parantezleri ()kullanın.

Öncelik düzeyine göre sıralanmış C# işleçlerinin tam listesi için C# işleçleri makalesinin İşleç önceliği bölümüne bakın.

İşleç aşırı yüklenebilirliği

İşaretçiyle ilgili , , *->ve [] işleçlerini &kullanıcı tanımlı bir türde aşırı yükleyemezsiniz.

C# dili belirtimi

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

Ayrıca bkz.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-01-24