"İnt * nums = {5, 2, 1, 4}" bölümleme hatasına neden olur

int *nums = {5, 2, 1, 4};
printf("%d\n", nums[0]);

segfault'a neden olurken

int nums[] = {5, 2, 1, 4};
printf("%d\n", nums[0]);

değil. Şimdi:

int *nums = {5, 2, 1, 4};
printf("%d\n", nums);

baskılar 5.

Buna dayanarak, dizi başlatma gösteriminin, {}, bu veriyi, soldaki değişkene körü körüne yüklediğini tahmin ettim. İnt [] olduğunda, dizi istenildiği gibi doldurulur. İnt * olduğunda, işaretçi 5 ile doldurulur ve işaretçinin saklandığı yerin ardından bellek yerleri 2, 1 ve 4 ile doldurulur. Bu yüzden nums [0], 5'i iptal etmeye çalışır ve bir segfault'a neden olur.

Yanılıyorsam lütfen düzeltin. Ve eğer haklıysam, lütfen ayrıntılandırın, çünkü dizi başlatıcılarının neden bu şekilde çalıştığını anlamıyorum.

C'de herhangi bir düz değişkenin ayraçlı bir başlatıcı listesiyle, tıpkı bir diziymiş gibi başlatılabileceğini söyleyen (aptalca) bir kural vardır.

Örneğin int x = {0};, tamamen eşdeğer olan yazabilirsiniz int x = 0;.

Yani yazarken int *nums = {5, 2, 1, 4};aslında tek bir işaretçi değişkenine bir başlatıcı listesi veriyorsunuz. Ancak, yalnızca tek bir değişkendir, bu nedenle yalnızca ilk 5 değeri atanır, listenin geri kalanı göz ardı edilir (aslında fazla başlatıcıya sahip kodun katı bir derleyici ile derlenmesi gerektiğini bile düşünmüyorum) - öyle değil hafızaya yazılsın. Kod eşdeğerdir int *nums = 5;. Bu nums, adresi göstermesi gerektiği anlamına gelir 5.

Bu noktada zaten iki derleyici uyarısı / hatası almış olmalısınız:

• Atamasız işaretçiye tamsayı atama.
• Başlatıcı listesindeki fazla öğeler.

Ve sonra elbette kod çökecek ve yanacaktır 5, çünkü büyük olasılıkla referansını kaldırmanıza izin verilen geçerli bir adres değildir nums[0].

Bir yan not olarak, printfadresleri %pbelirticiyle göstermelisiniz, aksi takdirde tanımsız davranışı çağırırsınız.

Burada ne yapmaya çalıştığınızdan tam olarak emin değilim, ancak bir göstericiyi bir diziyi gösterecek şekilde ayarlamak istiyorsanız, yapmanız gereken:

int nums[] = {5, 2, 1, 4};
int* ptr = nums;

// or equivalent:
int* ptr = (int[]){5, 2, 1, 4};

Veya bir dizi işaretçi oluşturmak istiyorsanız:

int* ptr[] = { /* whatever makes sense here */ };

DÜZENLE

Biraz araştırmadan sonra "fazla eleman başlatıcı listesi" nin gerçekten geçerli C olmadığını söyleyebilirim - bu bir GCC uzantısıdır .

Standart 6.7.9 Başlatma diyor ki (vurgu benim):

2 Hiçbir başlatıcı, başlatılan varlık içinde yer almayan bir nesne için bir değer sağlamaya çalışmayacaktır.

/ - /

11 Bir skaler için başlatıcı, isteğe bağlı olarak parantez içine alınmış tek bir ifade olacaktır. Nesnenin başlangıç ​​değeri, ifadenin değeridir (dönüştürmeden sonra); Basit atamayla aynı tür kısıtlamaları ve dönüştürmeleri geçerlidir, skalerin türünü, bildirilen türünün nitelenmemiş sürümü olarak alır.

"Skaler tip", dizi, yapı veya birleşim tipi olmayan tek değişkenlere atıfta bulunan standart bir terimdir (bunlara "toplu tip" denir).

Yani düz İngilizce'de standart şöyle der: "Bir değişkeni başlattığınızda, sadece yapabildiğiniz için, başlatıcı ifadesinin etrafına fazladan parantezler atmakta özgürsünüz."

SENARYO 1

int *nums = {5, 2, 1, 4};    // <-- assign multiple values to a pointer variable
printf("%d\n", nums[0]);    // segfault

Bu neden segfault yapıyor?

numsİnt için bir gösterici olarak ilan ettiniz - bu, bellekte bir tamsayının numsadresini tutması gerekiyor .

Daha sonra birden çok değerden numsoluşan bir diziyi başlatmaya çalıştınız . Bu nedenle, çok fazla ayrıntıya girmeden, bu kavramsal olarak yanlıştır - tek bir değeri tutması gereken bir değişkene birden fazla değer atamak mantıklı değildir. Bu bağlamda, bunu yaparsanız tam olarak aynı etkiyi görürsünüz:

int nums = {5, 2, 1, 4};    // <-- assign multiple values to an int variable
printf("%d\n", nums);    // also print 5

Her iki durumda da (bir işaretçiye veya bir int değişkenine birden çok değer atayın), o zaman değişkenin ilk değeri alması, 5kalan değerler göz ardı edilir. Bu kod uyumludur ancak atamada olmaması gereken her ek değer için uyarılar alırsınız:

warning: excess elements in scalar initializer.

İşaret değişkenine birden çok değer atanması durumunda, program eriştiğinizde hata verir nums[0], bu da adres 5'te depolanan her şeyi harfi harfine ertelediğiniz anlamına gelir . numsBu durumda işaretçi için geçerli bir bellek ayırmadınız .

İnt değişkenine birden çok değer atama durumunda herhangi bir segfault olmadığını belirtmekte fayda var (burada herhangi bir geçersiz göstericiye başvuruda bulunmuyorsunuz).

SENARYO 2

int nums[] = {5, 2, 1, 4};

Bu, segfault değildir, çünkü yığında yasal olarak 4 inçlik bir dizi tahsis ediyorsunuz.

SENARYO 3

int *nums = {5, 2, 1, 4};
printf("%d\n", nums);   // print 5

Bu, beklendiği gibi segfault vermez, çünkü siz işaretçinin değerini yazdırıyorsunuz - başvurunun iptalini DEĞİL (bu geçersiz bellek erişimidir).

Diğerleri

Bir işaretçinin değerini bu şekilde kodladığınızda neredeyse her zaman segfault'a mahkumdur (çünkü hangi işlemin hangi bellek konumuna erişebileceğini belirlemek işletim sisteminin görevidir).

int *nums = 5;    // <-- segfault

Dolayısıyla, temel bir kural, her zaman bazı tahsis edilmiş değişkenlerin adresine bir gösterici başlatmaktır , örneğin:

int a;
int *nums = &a;

veya,

int a[] = {5, 2, 1, 4};
int *nums = a; 

int *nums = {5, 2, 1, 4};kötü biçimlendirilmiş koddur. Bu kodu şu şekilde değerlendiren bir GCC uzantısı var:

int *nums = (int *)5;

bellek adresi 5'e bir işaretçi oluşturmaya çalışmak (Bu bana kullanışlı bir uzantı gibi görünmüyor, ancak sanırım geliştirici tabanı bunu istiyor).

Bu davranıştan kaçınmak için (veya en azından bir uyarı alabilirsiniz), örneğin standart modda derleyebilirsiniz -std=c11 -pedantic.

Geçerli kodun alternatif bir biçimi şöyle olabilir:

int *nums = (int[]){5, 2, 1, 4};

ile aynı depolama süresine sahip değiştirilebilir bir değişmezi işaret eder nums. Ancak, int nums[]sürüm daha az depolama alanı kullandığından genellikle daha iyidir sizeofve dizinin ne kadar uzun olduğunu saptamak için kullanabilirsiniz .

int *nums = {5, 2, 1, 4};

numsbir tür göstericidir int. Bu nedenle, bunu geçerli bir bellek konumuna yönlendirmelisiniz. num[0]bazı rasgele bellek konumlarından ve dolayısıyla bölümleme hatasından vazgeçmeye çalışıyorsunuz.

Evet, işaretçi 5 değerini tutuyor ve siz bunun sisteminizde tanımsız bir davranış olan referansını kaldırmaya çalışıyorsunuz. (Görünüşe göre 5sisteminizde geçerli bir bellek konumu değil)

Buna karşılık

int nums[] = {1,2,3,4};

bir numstür dizisi olduğunu söylediğiniz intve belleğin, başlatma sırasında geçen öğelerin sayısına göre tahsis edildiği geçerli bir bildirimdir .

Atayarak {5, 2, 1, 4}

int *nums = {5, 2, 1, 4};

5'e numsatıyorsunuz (int'ten int'e işaretçiye örtük bir typecast'ten sonra). Aktarıldıktan sonra adresindeki hafıza konumuna bir erişim çağrısı yapar 0x5. Programınızın erişimine izin verilmeyebilir.

Deneyin

printf("%p", (void *)nums);