Neden bir dizinin adresi C'deki değerine eşittir?

Aşağıdaki kod bitinde, işaretçi değerleri ve işaretçi adresleri beklendiği gibi farklılık gösterir.

Ancak dizi değerleri ve adresleri yok!

Bu nasıl olabilir?

Çıktı

my_array = 0022FF00
&my_array = 0022FF00
pointer_to_array = 0022FF00
&pointer_to_array = 0022FEFC

#include <stdio.h>

int main()
{
  char my_array[100] = "some cool string";
  printf("my_array = %p\n", my_array);
  printf("&my_array = %p\n", &my_array);

  char *pointer_to_array = my_array;
  printf("pointer_to_array = %p\n", pointer_to_array);
  printf("&pointer_to_array = %p\n", &pointer_to_array);

  printf("Press ENTER to continue...\n");
  getchar();
  return 0;
}

Bir dizinin adı, dizi birinci elemanının adresine değerlendirilir, bu nedenle arrayve &arrayaynı değere sahip (fakat farklı tipte çok array+1ve &array+1olacak olmayan dizi 1'den fazla eleman uzunsa eşit).

Bunun iki istisnası vardır: dizi adı bir işlenen sizeofveya tekli &(adres-değeri) olduğunda, ad dizi nesnesinin kendisine karşılık gelir. Böylece sizeof array, işaretçinin boyutunu değil, tüm dizinin bayt cinsinden boyutunu verir.

Olarak tanımlanan bir dizi T array[size]için türe sahip olacaktır T *. Artırdığınızda / artırdığınızda, dizideki bir sonraki öğeye erişirsiniz.

&arrayaynı adresi değerlendirir, ancak aynı tanım göz önüne alındığında, bu tür bir işaretçi oluşturur T(*)[size]- yani, tek bir öğeye değil, bir diziye işaret eder. Bu işaretçiyi artırırsanız, tek bir öğenin boyutunu değil tüm dizinin boyutunu ekler. Örneğin, böyle bir kodla:

char array[16];
printf("%p\t%p", (void*)&array, (void*)(&array+1));

İkinci işaretçinin birinciden 16 daha büyük olmasını bekleyebiliriz (çünkü 16 karakterlik bir dizi). % P tipik olarak işaretçileri onaltılık biçime dönüştürdüğünden, şuna benzeyebilir:

0x12341000    0x12341010

Bunun nedeni, dizi adının ( my_array) işaretçiden diziye farklı olmasıdır. Bir dizinin adresinin takma adıdır ve adresi dizinin kendisinin adresi olarak tanımlanır.

Ancak işaretçi yığındaki normal bir C değişkenidir. Böylece adresini alabilir ve içerdiği adresten farklı bir değer elde edebilirsiniz.

Bu konu hakkında burada yazdım - lütfen bir göz atın.

Bir ifadede, bir dizinin adı kullanmak zaman adres ve (işlenen olmadıkça C, (bir işleve geçen dahil) &) operatör veya sizeofoperatör, bu azalır ilk elemana için bir işaretçi.

Yani, çoğu bağlamda hem tür hem de değer arrayile eşdeğerdir &array[0].

Örnekte, my_arraytürüne sahip char[100]bir zayıflar char*Eğer printf bunu geçerken.

&my_arraytürü vardır char (*)[100](100'den diziye işaretçi char). İşlenen olduğu için &, bu, my_arrayilk öğesinin bir işaretçisine hemen çürümeyen durumlardan biridir .

Dizinin işaretçisi, bir dizi nesnesi olarak dizinin ilk öğesine bir işaretçi ile aynı adres değerine sahiptir, ancak bir dizinin işaretçisi öğenin işaretçisi için farklı bir türe sahiptir. o dizi. İki işaretçi türünde işaretçi aritmetiği yaptığınızda bu önemlidir.

pointer_to_arraytype char *- dizinin ilk öğesini işaret my_arrayetmek için başlatıcı ifadesinde çürütülen şey olarak başlatıldı - ve &pointer_to_array türüne char **(işaretçi a işaretçisi char).

Bunlardan: my_array(çürüme sonrasında char*) &my_arrayve pointer_to_arraytümü doğrudan diziye veya dizinin ilk öğesine işaret eder ve böylece aynı adres değerine sahiptir.

Bir dizinin bellek düzenine baktığınızda, aynı adresin neden my_arrayve &my_arraysonucunun kolayca anlaşılabilir.

Diyelim ki 10 karakterlik bir diziniz var (bunun yerine kodunuzdaki 100 karakter).

char my_array[10];

İçin bellek my_arrayşuna benzer:

+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
^
|
Address of my_array.

C / C ++ 'da bir dizi, bir ifadedeki ilk öğenin imlecine işaret eder.

printf("my_array = %p\n", my_array);

Dizinin ilk öğesinin nerede olduğunu incelerseniz, adresinin dizinin adresiyle aynı olduğunu görürsünüz:

my_array[0]
|
v
+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
^
|
Address of my_array[0].

C'nin hemen öncüsü olan B programlama dilinde, işaretçiler ve tamsayılar serbestçe değiştirilebilirdi. Sistem, tüm bellek dev bir diziymiş gibi davranırdı. Her değişken adının kendisiyle ilişkilendirilmiş genel veya yığınla ilişkili bir adresi vardı, her değişken adı için derleyicinin izlemesi gereken tek şey, genel veya yerel bir değişken olup olmadığı ve ilk genel veya yerel ile ilgili adresi değişken.

Gibi küresel bir deklarasyon Verilen i;: [herşey bir tamsayı / işaretçi beri bir türünü belirtmek gerek vardı] derleyici olarak tarafından işlenmiş olur address_of_i = next_global++; memory[address_of_i] = 0;gibi ve bir bildiri i++olarak işlenecektir: memory[address_of_i] = memory[address_of_i]+1;.

Gibi bir bildirim arr[10];olarak işlenir address_of_arr = next_global; memory[next_global] = next_global; next_global += 10;. Bu bildirim işlenir yapılmaz derleyicinin arrbir dizi olduğunu hemen unutabileceğini unutmayın . Gibi bir ifade arr[i]=6;olarak işlenir memory[memory[address_of_a] + memory[address_of_i]] = 6;. Derleyici, arrbir diziyi ve ibir tamsayıyı temsil etmeyi umursamaz ya da tam tersi olmaz. Aslında, her ikisinin de dizi veya tam sayı olması önemli değildir; ortaya çıkan davranışın muhtemelen faydalı olup olmadığına bakılmaksızın, kodu açıklandığı gibi mükemmel bir şekilde oluşturur.

C programlama dilinin amaçlarından biri B ile büyük ölçüde uyumlu olmaktı. B'de, bir dizinin adı [B'nin terminolojisinde "vektör" olarak adlandırılır], başlangıçta işaret etmek için atanmış bir işaretçi tutan bir değişken tanımladı verilen büyüklükte bir ayırmanın ilk öğesine gönderilir, böylece bu ad bir işlev için bağımsız değişken listesinde görünürse, işlev vektöre bir işaretçi alır. C, başlangıçta tahsise işaret eden bir işaretçi değişkeni yerine tahsisin adresi ile sıkı bir şekilde ilişkili olan "gerçek" dizi türlerini eklese de, dizilerin bir C-tipi dizinin aynı şekilde davrandığını belirten işaretçiler için kod ayrıştırması bir vektörü bildiren ve daha sonra adresini tutan değişkeni asla değiştirmeyen B koduna.

Aslında &myarrayve myarrayher ikisi de temel adres.

Kullanmak yerine farkı görmek istiyorsanız

printf("my_array = %p\n", my_array);
printf("my_array = %p\n", &my_array);

kullanım

printf("my_array = %s\n", my_array);
printf("my_array = %p\n", my_array);