Boş taban sınıfı da üye değişken olduğunda boş taban optimizasyonu neden yasaklanmıştır?

Boş taban optimizasyonu harika. Ancak, aşağıdaki kısıtlama ile birlikte gelir:

Aynı tabandaki iki temel alt nesnenin nesne temsili içinde farklı adreslere sahip olması gerektiğinden, boş taban sınıflarından birinin de ilk statik olmayan veri üyesinin türü veya tabanı olması durumunda boş taban optimizasyonu yasaktır. türetilmiştir.

Bu kısıtlamayı açıklamak için aşağıdaki kodu göz önünde bulundurun. static_assertBaşarısız olur. Halbuki ikisinden birini değiştirmek ya Fooda Bardevralmak yerine Base2hatayı önlemek için:

#include <cstddef>

struct Base  {};
struct Base2 {};

struct Foo : Base {};

struct Bar : Base {
    Foo foo;
};

static_assert(offsetof(Bar,foo)==0,"Error!");

Bu davranışı tamamen anlıyorum. Ne yapmak değil anlamaya olduğunu neden bu özel davranış var . Bir nedenden dolayı açık bir şekilde eklenmiştir, çünkü açık bir eklenti, bir gözetim değil. Bunun mantığı nedir?

Özellikle, iki temel alt nesnenin neden farklı adreslere sahip olması gerekir? Yukarıda, Barbir türdür ve foobu türün bir üye değişkenidir. Temel sınıfın neden temel sınıf Bartürüyle ilgili olduğunu anlamıyorum fooveya tam tersi.

Gerçekten de, eğer bir şey varsa, bunun onu içeren örneğin &fooadresi ile aynı olmasını beklerdim Bar- diğer durumlarda olması gerektiği gibi ⁽¹⁾ . Sonuçta, virtualkalıtımla süslü bir şey yapmıyorum , temel sınıflar ne olursa olsun boş ve bu derleme Base2, bu özel durumda hiçbir şeyin kırılmadığını gösteriyor.

Ancak bu mantık bir şekilde yanlıştır ve bu sınırlamanın gerekli olacağı başka durumlar da vardır.

Diyelim ki cevaplar C ++ 11 veya daha yeni bir sürüm için olmalı (şu anda C ++ 17 kullanıyorum).

_{^{(1) Not: EBO, C ++ 11'de yükseltildi ve özellikle StandardLayoutTypes için zorunlu hale geldi (ancak Bar, yukarıda a değil StandardLayoutType).}}

Tamam, her zaman yanlış yapmışım gibi görünüyor, çünkü tüm örneklerim için, temel nesne için boş bir taban optimizasyonunun başlamasını önleyecek bir vtable olması gerekiyor. Örneklerin durmasına izin vereceğim çünkü benzersiz adreslerin normalde neden iyi bir şey olduğuna dair ilginç örnekler verdiklerini düşünüyorum.

Bütün bunları daha derinlemesine inceledikten sonra, ilk üye boş temel sınıfla aynı türdeyse boş temel sınıf optimizasyonunun devre dışı bırakılması için teknik bir neden yoktur. Bu sadece geçerli C ++ nesne modelinin bir özelliğidir.

Ancak C ++ 20 ile [[no_unique_address]], derleyiciye statik olmayan bir veri üyesinin benzersiz bir adrese ihtiyaç duymayabileceğini söyleyen yeni bir öznitelik olacaktır (teknik olarak, potansiyel olarak çakışan [intro.object] / 7 ).

Bu (benim vurgu)

Statik olmayan veri üyesi, başka bir statik olmayan veri üyesinin veya bir temel sınıfın adresini paylaşabilir , [...]

dolayısıyla, ilk veri üyesine öznitelik vererek boş temel sınıf optimizasyonunu "yeniden etkinleştirebilir" [[no_unique_address]]. Buraya (ve aklıma gelen diğer tüm vakaların) nasıl çalıştığını gösteren bir örnek ekledim .

Bu sayede yanlış sorun örnekleri

Boş bir sınıfın sanal yöntemleri olmayabilir gibi göründüğünden, üçüncü bir örnek ekleyeyim:

int stupid_method(Base *b) {
  if( dynamic_cast<Foo*>(b) ) return 0;
  if( dynamic_cast<Bar*>(b) ) return 1;
  return 2;
}

Bar b;
stupid_method(&b);  // Would expect 0
stupid_method(&b.foo); //Would expect 1

Ancak son iki çağrı aynı.

Eski örnekler (Muhtemelen soruyu cevaplamayın çünkü boş sınıflar sanal yöntemler içermeyebilir, öyle görünüyor)

Yukarıdaki kodunuzu (eklenen sanal yıkıcılar ile) aşağıdaki örneği düşünün

void delBase(Base *b) {
    delete b;
}

Bar *b = new Bar;
delBase(b); // One would expect this to be absolutely fine.
delBase(&b->foo); // Whoaa, we shouldn't delete a member variable.

Ancak derleyici bu iki durumu nasıl ayırt etmelidir?

Ve belki biraz daha az çelişkili:

struct Base { 
  virtual void hi() { std::cout << "Hello\n";}
};

struct Foo : Base {
  void hi() override { std::cout << "Guten Tag\n";}
};

struct Bar : Base {
    Foo foo;
};

Bar b;
b.hi() // Hello
b.foo.hi() // Guten Tag
Base *a = &b;
Base *z = &b.foo;
a->hi() // Hello
z->hi() // Guten Tag

Ancak boş temel sınıf optimizasyonumuz varsa son ikisi aynıdır!