Nesne dilimleme nedir?

Birisi IRC'de dilimleme sorunu olarak bahsetti.

"Dilimleme", türetilmiş bir sınıfın bir nesnesini bir temel sınıf örneğine atadığınız ve böylece bilginin bir kısmını kaybettiğiniz yerdir - bazıları "dilimlenir".

Örneğin,

class A {
   int foo;
};

class B : public A {
   int bar;
};

Yani bir nesnenin Biki veri üyesi vardır foove bar.

Eğer bunu yazacak olsaydınız:

B b;

A a = b;

Sonra büye hakkında bilgi barkaybolur a.

Buradaki cevapların çoğu dilimleme ile ilgili asıl sorunun ne olduğunu açıklayamıyor. Hain olanları değil, sadece iyi huylu dilimleme vakalarını açıklarlar. Diğer cevaplar gibi, iki sınıfla uğraştığınızı Ave (herkese açık) Bnereden Bkaynaklandığını varsayın A.

Bu durumda, C ++ size bir örneğini geçmesine izin verir Betmek A'ın atama operatörü (ve ayrıca kopya yapıcısına). Bunun nedeni , atama işleçlerinin ve kopya oluşturucularının argümanlarının olmasını beklediği şey olan bir örneği a'ya Bdönüştürülebilir const A&.

İyi huylu dava

B b;
A a = b;

Orada kötü bir şey olmaz - bunun bir örneği Aolan bir kopyasını istediniz Bve tam olarak bunu elde edersiniz. Tabii, abazı büyelerini içermeyecek , ama nasıl olmalı? Her Aşeyden önce, bir değil B, bu yüzden onları saklayabilse bile , bu üyeleri bile duymamıştı .

Hain Dava

B b1;
B b2;
A& a_ref = b2;
a_ref = b1;
//b2 now contains a mixture of b1 and b2!

Bunun daha sonra b2bir kopyası olacağını düşünebilirsiniz b1. Ama ne yazık ki öyle değil ! Eğer incelerseniz, bunun b2bazı parçalarından b1( Bmiras alınan parçalar A) ve bazı parçalarından b2(sadece Biçeren parçalar ) yapılmış bir Frankensteinian yaratık olduğunu keşfedeceksiniz . Ah!

Ne oldu? Aslında, C ++ varsayılan olarak atama işleçlerini işlemez virtual. Böylece, hat a_ref = b1, atama operatörünü Adeğil , atama operatörünü çağırır B. Bu sanal olmayan fonksiyonlar için, çünkü ilan : (resmen statik tipi (olan) A&) karşıt olarak, denir fonksiyonu belirleyen gerçek (resmi: Dinamik ) türü (olurdu B, çünkü a_refreferansları bir örneği B) . Şimdi, Aatama operatörü açıkça beyan edilen üyeler hakkında bilgi Asahibi olduğundan, üyeleri Bdeğiştirmeden ekleyerek yalnızca üyeler kopyalanacak .

Bir çözüm

Bir nesnenin yalnızca parçalarına atamak genellikle çok mantıklı değildir, ancak C ++ maalesef bunu yasaklamak için yerleşik bir yol sağlamaz. Ancak kendiniz de yapabilirsiniz. İlk adım atama işlecini sanal hale getirmektir . Bu hep olduğunu garanti edecek fiili denir türünün atama operatörü değil beyan gibiler. İkinci adım, dynamic_castatanan nesnenin uyumlu bir türe sahip olduğunu doğrulamaktır. Üçüncü adım, bir (korumalı!) Üyesi gerçek atama yapmaktır assign(), çünkü B'ler assign()muhtemelen kullanmak isteyeceğiniz A' s assign()kopyalamak için A, 'in üyeleri.

class A {
public:
  virtual A& operator= (const A& a) {
    assign(a);
    return *this;
  }

protected:
  void assign(const A& a) {
    // copy members of A from a to this
  }
};

class B : public A {
public:
  virtual B& operator= (const A& a) {
    if (const B* b = dynamic_cast<const B*>(&a))
      assign(*b);
    else
      throw bad_assignment();
    return *this;
  }

protected:
  void assign(const B& b) {
    A::assign(b); // Let A's assign() copy members of A from b to this
    // copy members of B from b to this
  }
};

Saf kolaylık, Not B's operator=o zamandan beri covariantly, dönüş türü geçersiz kılar bilir o bir örneğini döndürüyor olduğunu B.

Bir temel sınıfınız Ave türetilmiş bir sınıfınız varsa B, aşağıdakileri yapabilirsiniz.

void wantAnA(A myA)
{
   // work with myA
}

B derived;
// work with the object "derived"
wantAnA(derived);

Şimdi yöntemin wantAnAbir kopyası gerekiyor derived. Ancak, derivedsınıf Btemel sınıfında olmayan ek üye değişkenleri icat edebileceğinden nesne tamamen kopyalanamaz A.

Bu nedenle, çağırmak wantAnAiçin derleyici türetilmiş sınıfın tüm ek üyelerini "keser". Sonuç, oluşturmak istemediğiniz bir nesne olabilir, çünkü

• eksik olabilir,
• bir A-nesne gibi davranır (sınıfın tüm özel davranışları Bkaybolur).

Bunların hepsi iyi cevaplar. Ben sadece referans ile değer vs nesneleri geçerken bir yürütme örneği eklemek istiyorum:

#include <iostream>

using namespace std;

// Base class
class A {
public:
    A() {}
    A(const A& a) {
        cout << "'A' copy constructor" << endl;
    }
    virtual void run() const { cout << "I am an 'A'" << endl; }
};

// Derived class
class B: public A {
public:
    B():A() {}
    B(const B& a):A(a) {
        cout << "'B' copy constructor" << endl;
    }
    virtual void run() const { cout << "I am a 'B'" << endl; }
};

void g(const A & a) {
    a.run();
}

void h(const A a) {
    a.run();
}

int main() {
    cout << "Call by reference" << endl;
    g(B());
    cout << endl << "Call by copy" << endl;
    h(B());
}

Çıktı:

Call by reference
I am a 'B'

Call by copy
'A' copy constructor
I am an 'A'

Google'da "C ++ dilimleme" için üçüncü maç bana bu Wikipedia makalesini http://en.wikipedia.org/wiki/Object_slicing ve bu (ısıtmalı, ancak ilk birkaç mesaj sorunu tanımlar) verir: http://bytes.com/ forum / thread163565.html

Süper sınıfa bir alt sınıf nesnesi atadığınızda. Üst sınıf, alt sınıftaki ek bilgilerin hiçbirini bilmez ve saklamak için yer yoktur, bu nedenle ek bilgiler "dilimlenir".

Bu bağlantılar "iyi yanıt" için yeterli bilgi vermezse, daha fazla aradığınızı bize bildirmek için lütfen sorunuzu düzenleyin.

Dilimleme sorunu ciddidir çünkü bellek bozulmasına neden olabilir ve bir programın bundan muzdarip olmadığını garanti etmek çok zordur. Dili dilden çıkarmak için, kalıtımı destekleyen sınıflara yalnızca referans olarak erişilebilir (değere göre değil). D programlama dili bu özelliğe sahiptir.

A sınıfını ve A sınıfından türetilmiş B sınıfını düşünün. A parçasında p işaretçisi ve p'nin B ek verilerine işaret eden bir B örneği varsa bellek bozulması oluşabilir. Daha sonra, ek veriler dilimlendiğinde, p çöplere işaret eder.

C ++ 'da, türetilmiş bir sınıf nesnesi temel sınıf nesnesine atanabilir, ancak diğer yol mümkün değildir.

class Base { int x, y; };

class Derived : public Base { int z, w; };

int main() 
{
    Derived d;
    Base b = d; // Object Slicing,  z and w of d are sliced off
}

Nesne dilimleme, türetilmiş bir sınıf nesnesi bir temel sınıf nesnesine atandığında, türetilmiş bir sınıf nesnesinin ek nitelikleri, temel sınıf nesnesini oluşturmak için dilimlenir.

C ++ 'da dilimleme sorunu, çoğunlukla C yapılarıyla uyumluluk nedeniyle kalan nesnelerinin değer semantiğinden kaynaklanmaktadır. Nesneleri yapan diğer birçok dilde bulunan "normal" nesne davranışını elde etmek için açık referans veya işaretçi sözdizimi kullanmanız gerekir; örneğin, nesneler her zaman başvuru ile iletilir.

Kısa cevaplar, bir temel nesneye değere göre türetilmiş bir nesne atayarak nesneyi dilimlemenizdir , yani kalan nesne türetilmiş nesnenin yalnızca bir parçasıdır. Değer semantiğini korumak için dilimleme makul bir davranıştır ve diğer birçok dilde mevcut olmayan nispeten nadir kullanımları vardır. Bazıları bunu C ++ 'ın bir özelliği olarak görürken, birçoğu onu C ++' ın tuhaflıklarından / yanlışlıklarından biri olarak görüyor.

Peki ... Elde edilen bilgileri kaybetmek neden kötü? ... çünkü türetilmiş sınıfın yazarı temsili değiştirmiş olabilir, böylece fazladan bilginin kesilmesi nesne tarafından temsil edilen değeri değiştirir. Bu, türetilmiş sınıfın, belirli işlemler için daha verimli, ancak temel gösterime geri dönüşü pahalı olan bir gösterimi önbelleğe almak için kullanılırsa oluşabilir.

Ayrıca birinin dilimlemekten kaçınmak için ne yapmanız gerektiğini de belirtmesi gerektiğini düşündüm ... C ++ Kodlama Standartları, 101 kural kılavuzları ve en iyi uygulamaların bir kopyasını alın. Dilimleme ile uğraşmak # 54.

Sorunu tamamen ele almak için biraz karmaşık bir model önermektedir: korumalı bir kopya oluşturucu, korumalı saf sanal DoClone ve (daha fazla) türetilmiş bir sınıfın DoClone'u doğru bir şekilde uygulayamadığını söyleyecek bir onaylayıcıya sahip bir genel Klon bulundurun. (Klonlama yöntemi, polimorfik nesnenin derinlemesine bir kopyasını oluşturur.)

İsterseniz, açık dilimlemeye izin veren temel oluşturucuda kopya kurucusunu da işaretleyebilirsiniz.

1. DİLİMLEME SORUNUNUN TANIMI

D temel sınıf B'nin türetilmiş bir sınıfıysa, Tür türündeki bir değişkene (veya parametreye) Türetilmiş türünde bir nesne atayabilirsiniz.

MİSAL

class Pet
{
 public:
    string name;
};
class Dog : public Pet
{
public:
    string breed;
};

int main()
{   
    Dog dog;
    Pet pet;

    dog.name = "Tommy";
    dog.breed = "Kangal Dog";
    pet = dog;
    cout << pet.breed; //ERROR

Yukarıdaki atamaya izin verilse de, değişken evcil hayvana atanan değer cins alanını kaybeder. Buna dilimleme problemi denir .

2. DİLİMLEME SORUNUNUN DÜZELTİLMESİ

Sorunu yenmek için dinamik değişkenlere işaretçiler kullanıyoruz.

MİSAL

Pet *ptrP;
Dog *ptrD;
ptrD = new Dog;         
ptrD->name = "Tommy";
ptrD->breed = "Kangal Dog";
ptrP = ptrD;
cout << ((Dog *)ptrP)->breed; 

Bu durumda, ptrD (alt sınıf nesnesi) tarafından gösterilen dinamik değişkenin veri üyeleri veya üye işlevleri kaybolmaz. Ayrıca, işlevleri kullanmanız gerekirse, işlevin sanal bir işlev olması gerekir.

Bana öyle geliyor ki, dilimleme, kendi derslerinizin ve programınızın zayıf bir şekilde tasarlandığı / tasarlandığı durumdan başka bir sorun değil.

Bir alt sınıf nesnesini parametre olarak superclass türünde bir parametre alan bir yönteme geçirirsem, bunun farkında olmalı ve içsel olarak bilmeliyim, çağrılan yöntem yalnızca üst sınıf (aka baseclass) nesnesiyle çalışacaktır.

Bana öyle geliyor ki, sadece bir temel sınıfın talep edildiği bir alt sınıfın sunulmasının, bir şekilde alt sınıfa özgü sonuçlara yol açması, dilimlemenin bir sorun olmasına neden olacağı mantıksız beklentisi. Ya yöntem kullanımında zayıf tasarımı ya da kötü bir alt sınıf uygulaması. Genellikle iyi OOP tasarımından yararlanma veya performans kazanımları lehine feda etmenin sonucudur.

Tamam, nesne dilimlemeyi açıklayan birçok gönderiyi okuduktan sonra nasıl deneyeceğim ama nasıl sorunlu hale geldiğini değil.

Bellek bozulmasına neden olabilecek kısır senaryo şudur:

• Sınıf, polimorfik bir baz sınıfında (yanlışlıkla derleyici tarafından üretilen) atama sağlar.
• İstemci türetilmiş bir sınıf örneğini kopyalar ve dilimler.
• İstemci, dilimlenmiş duruma erişen bir sanal üye işlevini çağırır.

Dilimleme, bir alt sınıf tarafından eklenen verilerin, alt sınıfın bir nesnesi değere göre aktarıldığında veya döndürüldüğünde veya bir temel sınıf nesnesini bekleyen bir işlevden atıldığı anlamına gelir.

Açıklama: Aşağıdaki sınıf bildirimini göz önünde bulundurun:

           class baseclass
          {
                 ...
                 baseclass & operator =(const baseclass&);
                 baseclass(const baseclass&);
          }
          void function( )
          {
                baseclass obj1=m;
                obj1=m;
          }

Temel sınıf kopyalama işlevleri türetilmiş hakkında hiçbir şey bilmediğinden, türetilenin yalnızca temel kısmı kopyalanır. Bu genellikle dilimleme olarak adlandırılır.

class A 
{ 
    int x; 
};  

class B 
{ 
    B( ) : x(1), c('a') { } 
    int x; 
    char c; 
};  

int main( ) 
{ 
    A a; 
    B b; 
    a = b;     // b.c == 'a' is "sliced" off
    return 0; 
}

türetilmiş bir sınıf nesnesi bir temel sınıf nesnesine atandığında, türetilmiş bir sınıf nesnesinin ek nitelikleri temel sınıf nesnesinden dilimlenir (atılır).

class Base { 
int x;
 };

class Derived : public Base { 
 int z; 
 };

 int main() 
{
Derived d;
Base b = d; // Object Slicing,  z of d is sliced off
}

Temel sınıf Nesnesine Türetilmiş bir sınıf Nesnesi atandığında, türetilmiş sınıf nesnesinin tüm üyeleri, temel sınıfta bulunmayan üyeler dışında temel sınıf nesnesine kopyalanır. Bu üyeler derleyici tarafından dilimlenir. Buna Nesne Dilimleme denir.

İşte bir örnek:

#include<bits/stdc++.h>
using namespace std;
class Base
{
    public:
        int a;
        int b;
        int c;
        Base()
        {
            a=10;
            b=20;
            c=30;
        }
};
class Derived : public Base
{
    public:
        int d;
        int e;
        Derived()
        {
            d=40;
            e=50;
        }
};
int main()
{
    Derived d;
    cout<<d.a<<"\n";
    cout<<d.b<<"\n";
    cout<<d.c<<"\n";
    cout<<d.d<<"\n";
    cout<<d.e<<"\n";


    Base b = d;
    cout<<b.a<<"\n";
    cout<<b.b<<"\n";
    cout<<b.c<<"\n";
    cout<<b.d<<"\n";
    cout<<b.e<<"\n";
    return 0;
}

Üretecek:

[Error] 'class Base' has no member named 'd'
[Error] 'class Base' has no member named 'e'

Ben sadece dilimleme sorunu koştu ve hemen buraya indi. İki sentimi buna ekleyeyim.

"Üretim kodundan" bir örnek alalım (ya da yakın gelen bir şey):

Diyelim ki eylemler gönderen bir şeyimiz var. Örneğin bir kontrol merkezi kullanıcı arayüzü.
Bu kullanıcı arayüzünün şu anda gönderilebilen şeylerin bir listesini alması gerekiyor. Bu nedenle, gönderim bilgilerini içeren bir sınıf tanımlarız. Haydi diyelim Action. Yani bir Actionüye değişkenleri vardır. Sadelik için a std::string nameve a olmak üzere sadece 2 tane var std::function<void()> f. Sonra void activate()sadece birf üyeyi .

Böylece UI std::vector<Action>tedarik edilir. Şöyle bazı işlevleri düşünün:

void push_back(Action toAdd);

Şimdi arayüzün nasıl göründüğünü belirledik. Şimdiye kadar sorun yok. Ancak bu proje üzerinde çalışan başka bir adam aniden Actionnesnede daha fazla bilgiye ihtiyaç duyan özel eylemler olduğuna karar veriyor . Hangi sebepten ötürü. Bu da lambda yakalamaları ile çözülebilir. Bu örnek koddan 1-1 alınmaz.

Böylece adam Actionkendi lezzetini eklemekten geliyor.
Evde demlenmiş sınıfının bir örneğini geçirir, push_backancak program haywire'a gider.

Peki ne oldu?
Tahmin edebileceğiniz gibi: nesne dilimlenmiştir.

Örneğe ait fazladan bilgiler kaybolmuştur ve fşimdi tanımlanmamış davranışa eğilimlidir.

Ben bu örnek bahsederken gerçekten şeyleri hayal bile edemeyen insanlar için yaklaşık ışık getiriyor umut As ve Bbazı biçimde kullanılmasıyla elde edilen s.