"Struct hack" teknik olarak tanımlanmamış bir davranış mı?

Sorduğum şey, iyi bilinen "bir yapının son üyesinin değişken uzunluklu" numarasıdır. Şöyle bir şey oluyor:

struct T {
    int len;
    char s[1];
};

struct T *p = malloc(sizeof(struct T) + 100);
p->len = 100;
strcpy(p->s, "hello world");

Yapının belleğe yerleştirilme şekli nedeniyle, yapıyı gerekenden daha büyük bir bloğun üzerine yerleştirebilir ve son üyeye 1 charbelirtilenden daha büyükmiş gibi davranabiliriz.

Yani soru şu: Bu teknik teknik olarak tanımlanmamış bir davranış mı? . Öyle olmasını beklerdim, ancak standardın bunun hakkında ne söylediğini merak ediyordum.

Not: Bu konudaki C99 yaklaşımının farkındayım, cevapların özellikle yukarıda listelenen numaraya bağlı kalmasını istiyorum.

As C SSS diyor:

Yasal mı yoksa taşınabilir mi olduğu net değil, ancak oldukça popüler.

ve:

... resmi bir yorum, bilinen tüm uygulamalar altında işe yarıyor gibi görünse de, C Standardına tam olarak uymadığını kabul etmiştir. (Dizi sınırlarını dikkatlice kontrol eden derleyiciler uyarılar verebilir.)

'Kesinlikle uyumlu' bitinin ardındaki mantık , tanımsız davranışlar listesine dahil olan J.2 Tanımlanmamış davranış bölümündeki spesifikasyondadır :

• Bir nesne belirli bir alt simge ile görünürde erişilebilir olsa bile ( a[1][7]bildirime verilen lvalue ifadesinde olduğu gibi int a[4][5]) (6.5.6) bir dizi alt simgesi aralık dışındadır.

Bölüm 6.5.6 Katkı operatörlerinin 8. paragrafında , tanımlanmış dizi sınırlarının ötesinde erişimin tanımsız olduğuna dair başka bir ifade daha vardır:

Hem işaretçi işleneni hem de sonuç aynı dizi nesnesinin öğelerini işaret ederse veya dizi nesnesinin son öğesini geçerse, değerlendirme bir taşma üretmemelidir; aksi takdirde davranış tanımsızdır.

Teknik olarak bunun tanımlanmamış bir davranış olduğuna inanıyorum. Standart (muhtemelen) onu doğrudan ele almıyor, bu nedenle "herhangi bir açık davranış tanımının ihmal edilmesiyle" kapsamına giriyor. tanımsız bir davranış olduğunu söyleyen madde (C99 §4 / 2, C89 §3.16 / 2).

Yukarıdaki "tartışmalı olarak", dizi abone oluşturma operatörünün tanımına bağlıdır. Özellikle şöyle der: "Köşeli parantez [] içindeki bir ifadenin ardından gelen bir sonek ifadesi, bir dizi nesnesinin alt simgeli bir atamasıdır." (C89, §6.3.2.1 / 2).

Burada "bir dizi nesnesinin" ihlal edildiğini iddia edebilirsiniz (dizi nesnesinin tanımlanmış aralığının dışında abone olduğunuz için), bu durumda davranış (biraz daha fazla), tanımsız olmak yerine açıkça tanımsızdır. onu tam olarak tanımlayan hiçbir şeyin nezaketi.

Teoride, dizi sınırlarını kontrol eden ve (örneğin) aralık dışı bir alt simge kullanmaya çalıştığınızda / çalıştığınızda programı iptal eden bir derleyici hayal edebiliyorum. Aslında, böyle bir şeyin var olduğunu bilmiyorum ve bu kod tarzının popülaritesi göz önüne alındığında, bir derleyici bazı durumlarda abonelikleri zorlamaya çalışsa bile, herhangi birinin bunu yapmaya katlanacağını hayal etmek zor. bu durum.

Evet, tanımlanmamış bir davranış.

C Dil Kusur Raporu # 051, bu soruya kesin bir cevap verir:

Deyim, yaygın olmakla birlikte, kesinlikle uymuyor

http://www.open-std.org/jtc1/sc22/wg14/www/docs/dr_051.html

C99 Gerekçe belgesinde C Komitesi şunları ekler:

Bu yapının geçerliliği her zaman şüpheli olmuştur. Bir Kusur Raporuna yanıt olarak, Komite bunun tanımlanmamış bir davranış olduğuna karar verdi, çünkü p-> öğeleri dizisi, alanın var olup olmadığına bakılmaksızın yalnızca bir öğe içeriyordu.

Bunu yapmanın bu özel yolu, herhangi bir C standardında açıkça tanımlanmamıştır, ancak C99, dilin bir parçası olarak "struct hack" i içerir. C99'da, bir yapının son üyesi, char foo[](yerine istediğiniz türden) olarak bildirilen bir "esnek dizi üyesi" olabilir char.

Resmi ya da başka birinin ne söylediğine bakılmaksızın tanımsız bir davranış değildir , çünkü standart tarafından tanımlanmıştır. p->s, bir değer olarak kullanılması dışında, özdeş bir gösterici olarak değerlendirilir (char *)p + offsetof(struct T, s). Özellikle, bu, charmalloc'lu nesnenin içinde geçerli bir göstericidir ve hemen ardından char, tahsis edilen nesnenin içindeki nesneler olarak da geçerli olan 100 (veya daha fazla, hizalama hususlarına bağlı olarak) ardışık adres vardır . İmlecin, ->döndürme tarafından döndürülen işaretçiye açıkça eklemek yerine kullanılarak türetilmiş olması malloc, çevirme ile char *, alakasızdır.

Teknik olarak, yapı içindeki dizinin p->s[0]tek öğesidir char, sonraki birkaç öğe (örneğin p->s[1]aracılığıyla p->s[3]) muhtemelen yapı içindeki doldurma baytlarıdır; bu, yapıya bir bütün olarak atama gerçekleştirirseniz bozulabilir, ancak yalnızca bireye erişirseniz değil üyeler ve diğer öğeler, tahsis edilen nesnede, hizalama gereksinimlerine uyduğunuz sürece (ve charhizalama gereksinimleri olmadığı sürece) istediğiniz gibi kullanmakta serbest olduğunuz ek alandır .

Eğer dolgu ile örtüşen olasılığı her nasılsa burun iblisler çağırmak, sen değiştirerek bu önlemek olabilir belki yapı içinde bayt endişe varsa 1içinde [1]yapı sonunda hiçbir doldurma halde kalmasını sağlayan bir değere sahip. Bunu yapmanın basit ama savurgan bir yolu, sonunda hiçbir dizi dışında aynı üyelere sahip bir yapı s[sizeof struct that_other_struct];oluşturmak ve dizi için kullanmak olacaktır. Daha sonra, p->s[i]yapıdaki dizinin bir öğesi ve için yapının i<sizeof struct that_other_structsonunu izleyen bir adreste bir char nesnesi olarak açıkça tanımlanır i>=sizeof struct that_other_struct.

Düzenleme: Aslında, doğru boyutu elde etmek için yukarıdaki numarada, dizinin kendisinin başka bir öğenin dolgusunun ortasından ziyade maksimum hizalamayla başlamasını sağlamak için diziden önce her basit türü içeren bir birleşim koymanız gerekebilir. . Yine, bunların hiçbirinin gerekli olduğuna inanmıyorum, ama bunu en paranoyak dil avukatları için öneriyorum.

Düzenleme 2: Standardın başka bir parçası nedeniyle dolgu baytlarıyla örtüşme kesinlikle sorun teşkil etmez. C, eğer iki yapı, elemanlarının bir ilk alt dizisinde uyuşursa, ortak ilk elemanlara herhangi bir tip için bir gösterici aracılığıyla erişilebilmesini gerektirir. Özdeş bir yapı, eğer bir sonucu olarak, struct Tancak daha büyük bir nihai dizi ile beyan edilmiştir, eleman s[0]elemanına denk gerekir s[0]olarak struct Tve bu ilave elemanların varlığı etkilemez olabilir ya da daha büyük bir yapı ortak elemanları erişmek etkilenebilir bir işaretçi kullanarak struct T.

Evet, teknik olarak tanımlanmamış bir davranıştır.

"Struct hack" uygulamasını uygulamanın en az üç yolu olduğunu unutmayın:

(1) Sondaki diziyi 0 boyutuyla bildirmek (eski koddaki en "popüler" yol). Bu açık bir şekilde UB'dir, çünkü sıfır boyutlu dizi bildirimleri C'de her zaman geçersizdir. Derleme yapsa bile, dil kısıtlamayı ihlal eden herhangi bir kodun davranışı hakkında hiçbir garanti vermez.

(2) Diziyi minimum yasal boyutta beyan etme - 1 (sizin durumunuz). Bu durumda, işaretçi alma p->s[0]ve onu ötesine geçen işaretçi aritmetiği için kullanma girişimleri p->s[1]tanımsız davranıştır. Örneğin, bir hata ayıklama uygulamasının katıştırılmış aralık bilgisine sahip özel bir işaretçi üretmesine izin verilir; bu, ötesinde bir işaretçi oluşturmaya çalıştığınız her seferinde yakalanacaktır p->s[1].

(3) Diziyi "çok büyük" boyutlu olarak bildirmek Örneğin, 10000 gibi . Buradaki fikir, beyan edilen boyutun gerçek uygulamada ihtiyaç duyabileceğiniz her şeyden daha büyük olması gerektiğidir. Bu yöntem, dizi erişim aralığı açısından UB içermez. Bununla birlikte, pratikte, elbette, her zaman daha küçük miktarda bellek ayıracağız (sadece gerçekten gerektiği kadar). Bunun yasallığından emin değilim, yani nesneye nesnenin beyan edilen boyutundan daha az bellek ayırmanın ne kadar yasal olduğunu merak ediyorum ("tahsis edilmemiş" üyelere asla erişemeyeceğimizi varsayarak).

Standart, bir dizinin sonundaki şeylere erişemeyeceğiniz konusunda oldukça açıktır. (ve dizi bittikten sonra işaretçileri birden fazla artırmanıza izin verilmediğinden işaretçiler üzerinden gitmek yardımcı olmaz).

Ve "pratikte çalışmak" için. Standardın bu bölümünü kullanan gcc / g ++ optimizer'ı gördüm, bu nedenle bu geçersiz C'yi karşılarken yanlış kod üretiyordum.

Bir derleyici aşağıdaki gibi bir şeyi kabul ederse

typedef struct {
  int len;
  char dat [];
};

Sanırım, uzunluğunun ötesinde 'dat' üzerindeki bir alt simgeyi kabul etmeye hazır olması gerektiği oldukça açık. Öte yandan, biri aşağıdaki gibi bir şeyi kodlarsa:

typedef struct {
  int her neyse;
  char dat [1];
} MY_STRUCT;

ve daha sonra somestruct-> dat [x]; Derleyicinin büyük x değerleriyle çalışacak adres hesaplama kodunu kullanma yükümlülüğü altında olduğunu düşünmüyorum. Bence biri gerçekten güvende olmak isterse, uygun paradigma daha çok şöyle olurdu:

#define LARGEST_DAT_SIZE 0xF000
typedef struct {
  int her neyse;
  char dat [LARGEST_DAT_SIZE];
} MY_STRUCT;

ve sonra (sizeof (MYSTRUCT) -LARGEST_DAT_SIZE + istenilen_array_length) baytlık bir malloc yapın (eğer istenen_array_length LARGEST_DAT_SIZE'den daha büyükse, sonuçların tanımlanmamış olabileceğini aklınızda bulundurun).

Bu arada, sıfır uzunluklu dizileri yasaklama kararının talihsiz bir karar olduğunu düşünüyorum (Turbo C gibi bazı eski lehçeler bunu destekliyor) çünkü sıfır uzunluklu bir dizi, derleyicinin daha büyük indekslerle çalışacak kod üretmesi gerektiğinin bir işareti olarak kabul edilebilir. .