Tip silme teknikleri

^{(Tip silme ile, bir sınıfla ilgili tür bilgilerinin bir kısmını veya tamamını, Boost.Any gibi gizlemek istedim .)}
Bildiğim ^{bunları paylaşırken} , tip silme tekniklerinden de yararlanmak istiyorum. Umudum, birinin en karanlık saatinde düşündüğü çılgın bir teknik bulmak gibi. :)

Biliyorum, ilk ve en belirgin ve yaygın olarak ele alınan yaklaşım sanal işlevlerdir. Sınıfınızın uygulanmasını arayüz tabanlı bir sınıf hiyerarşisinde gizlemeniz yeterlidir. Birçok Boost kütüphanesi bunu yapar, örneğin Boost.Any bunu türünüzü gizlemek için yapar ve Boost.Shared_ptr bunu (de) ayırma mekanizmasını gizlemek için yapar.

Daha sonra, gerçek nesneyi Boostvoid* gibi bir işaretçide tutarken, ayarlanmış işlevlere işlev işaretçileri olan bir seçenek vardır. İşlev, işlevin gerçek türünü gizlemek için yapar. Örnek uygulamalar sorunun sonunda bulunabilir.

Yani, asıl sorum için:
Başka hangi tip silme tekniklerini biliyorsunuz? Lütfen mümkünse örnek bir kod, kullanım örnekleri, onlarla olan deneyiminizi ve daha fazla okuma için bağlantılar sağlayın.

Düzenle
(Bunu bir cevap olarak eklemek isteyip istemediğimden emin olmadığımdan veya sadece soruyu düzenlediğimden, daha güvenli olanı yapacağım.) Sanal işlevler veya uğraşmadan
gerçek bir şeyi gizlemek için başka bir güzel teknik , bir Gman istihdam buraya alaka ile, sorumu tam olarak nasıl bu eserlerin üzerinde.void*

Örnek kod:

#include <iostream>
#include <string>

// NOTE: The class name indicates the underlying type erasure technique

// this behaves like the Boost.Any type w.r.t. implementation details
class Any_Virtual{
        struct holder_base{
                virtual ~holder_base(){}
                virtual holder_base* clone() const = 0;
        };

        template<class T>
        struct holder : holder_base{
                holder()
                        : held_()
                {}

                holder(T const& t)
                        : held_(t)
                {}

                virtual ~holder(){
                }

                virtual holder_base* clone() const {
                        return new holder<T>(*this);
                }

                T held_;
        };

public:
        Any_Virtual()
                : storage_(0)
        {}

        Any_Virtual(Any_Virtual const& other)
                : storage_(other.storage_->clone())
        {}

        template<class T>
        Any_Virtual(T const& t)
                : storage_(new holder<T>(t))
        {}

        ~Any_Virtual(){
                Clear();
        }

        Any_Virtual& operator=(Any_Virtual const& other){
                Clear();
                storage_ = other.storage_->clone();
                return *this;
        }

        template<class T>
        Any_Virtual& operator=(T const& t){
                Clear();
                storage_ = new holder<T>(t);
                return *this;
        }

        void Clear(){
                if(storage_)
                        delete storage_;
        }

        template<class T>
        T& As(){
                return static_cast<holder<T>*>(storage_)->held_;
        }

private:
        holder_base* storage_;
};

// the following demonstrates the use of void pointers 
// and function pointers to templated operate functions
// to safely hide the type

enum Operation{
        CopyTag,
        DeleteTag
};

template<class T>
void Operate(void*const& in, void*& out, Operation op){
        switch(op){
        case CopyTag:
                out = new T(*static_cast<T*>(in));
                return;
        case DeleteTag:
                delete static_cast<T*>(out);
        }
}

class Any_VoidPtr{
public:
        Any_VoidPtr()
                : object_(0)
                , operate_(0)
        {}

        Any_VoidPtr(Any_VoidPtr const& other)
                : object_(0)
                , operate_(other.operate_)
        {
                if(other.object_)
                        operate_(other.object_, object_, CopyTag);
        }

        template<class T>
        Any_VoidPtr(T const& t)
                : object_(new T(t))
                , operate_(&Operate<T>)
        {}

        ~Any_VoidPtr(){
                Clear();
        }

        Any_VoidPtr& operator=(Any_VoidPtr const& other){
                Clear();
                operate_ = other.operate_;
                operate_(other.object_, object_, CopyTag);
                return *this;
        }

        template<class T>
        Any_VoidPtr& operator=(T const& t){
                Clear();
                object_ = new T(t);
                operate_ = &Operate<T>;
                return *this;
        }

        void Clear(){
                if(object_)
                        operate_(0,object_,DeleteTag);
                object_ = 0;
        }

        template<class T>
        T& As(){
                return *static_cast<T*>(object_);
        }

private:
        typedef void (*OperateFunc)(void*const&,void*&,Operation);

        void* object_;
        OperateFunc operate_;
};

int main(){
        Any_Virtual a = 6;
        std::cout << a.As<int>() << std::endl;

        a = std::string("oh hi!");
        std::cout << a.As<std::string>() << std::endl;

        Any_Virtual av2 = a;

        Any_VoidPtr a2 = 42;
        std::cout << a2.As<int>() << std::endl;

        Any_VoidPtr a3 = a.As<std::string>();
        a2 = a3;
        a2.As<std::string>() += " - again!";
        std::cout << "a2: " << a2.As<std::string>() << std::endl;
        std::cout << "a3: " << a3.As<std::string>() << std::endl;

        a3 = a;
        a3.As<Any_Virtual>().As<std::string>() += " - and yet again!!";
        std::cout << "a: " << a.As<std::string>() << std::endl;
        std::cout << "a3->a: " << a3.As<Any_Virtual>().As<std::string>() << std::endl;

        std::cin.get();
}

C ++ 'daki tüm tip silme teknikleri, işlev göstergeleri (davranış için) ve void*(veri için) ile yapılır. "Farklı" yöntemler semantik şeker ekleme şekillerinde farklılık gösterir. Sanal işlevler, örneğin, sadece semantik şekerdir.

struct Class {
    struct vtable {
        void (*dtor)(Class*);
        void (*func)(Class*,double);
    } * vtbl
};

iow: fonksiyon göstergeleri.

Bununla birlikte, özellikle sevdiğim bir teknik var: Bunun shared_ptr<void>nedeni, bunu yapabileceğinizi bilmeyen insanların zihinlerini havaya uçurmasıdır: Herhangi bir veriyi bir a'da saklayabilir shared_ptr<void>ve yine de çünkü shared_ptrkurucu bir işlev şablonudur ve varsayılan olarak siliciyi oluşturmak için geçirilen gerçek nesnenin türünü kullanır:

{
    const shared_ptr<void> sp( new A );
} // calls A::~A() here

Tabii ki, bu sadece normal void*/ işlev işaretçisi tipi silme, ancak çok uygun bir şekilde paketlenmiş.

Temel olarak, bunlar seçeneklerinizdir: sanal işlevler veya işlev işaretçileri.

Verileri saklama ve işlevlerle ilişkilendirme şekli değişebilir. Örneğin, bir işaretçi-temel depolayabilir ve türetilmiş sınıfın verileri ve sanal işlev uygulamalarını içermesini sağlayabilir ya da verileri başka bir yerde (örneğin ayrı olarak ayrılmış bir arabellekte) depolayabilir ve türetilmiş sınıfın void*verilere işaret eden sanal işlev uygulamaları . Verileri ayrı bir arabellekte saklarsanız, sanal işlevler yerine işlev işaretçileri kullanabilirsiniz.

İşaretçi-tabana saklamak, veriler ayrı olarak depolansa bile, tür tarafından silinen verilerinize uygulamak istediğiniz birden çok işlem olsa bile bu bağlamda iyi çalışır. Aksi takdirde, birden çok işlev işaretçisi (tür silinmiş işlevlerin her biri için bir tane) veya gerçekleştirilecek işlemi belirten bir parametreye sahip işlevlerle sonuçlanırsınız.

Ben de (benzer dikkate alacağını void*"ham depolama" kullanımı): char buffer[N].

C ++ 0x'de bunun için var std::aligned_storage<Size,Align>::type.

İstediğiniz her şeyi, yeterince küçük olduğu ve hizalama ile düzgün bir şekilde uğraştığınız sürece saklayabilirsiniz.

Stroustrup, C ++ programlama dilinde (4. baskı) §25.3 , şunları belirtir:

Bir dizi tipin değerleri için tek bir çalışma zamanı gösterimi kullanma tekniğinin varyantlarına ve (statik) tip sistemine dayanarak bunların sadece beyan edilen tiplerine göre kullanılmalarını sağlamak için tip silme olarak adlandırılmıştır .

Özellikle, şablonlar kullanırsak tür silme işlemini gerçekleştirmek için sanal işlevler veya işlev işaretçileri kullanılmasına gerek yoktur. Diğer cevaplarda daha önce sözü edilen, a'da saklanan tipe göre doğru yıkıcı çağrısının durumu buna std::shared_ptr<void>bir örnektir.

Stroustrup'un kitabında verilen örnek aynı derecede eğlencelidir.

Uygulanması düşünün template<class T> class Vector, çizgisinde bir kap std::vector. VectorÇok sayıda farklı işaretçi türüyle kullanacağınız zaman , sıkça olduğu gibi, derleyici her işaretçi türü için farklı kod üretecektir.

Bu kod bloat'ı , işaretçiler için Vector uzmanlığını tanımlayarak void*ve daha sonra bu uzmanlığı Vector<T*>diğer tüm türler için ortak bir temel uygulama olarak kullanarak önlenebilir T:

template<typename T>
class Vector<T*> : private Vector<void*>{
// all the dirty work is done once in the base class only 
public:
    // ...
    // static type system ensures that a reference of right type is returned
    T*& operator[](size_t i) { return reinterpret_cast<T*&>(Vector<void*>::operator[](i)); }
};

Gördüğünüz gibi, biz kesinlikle yazılı konteyner ama var Vector<Animal*>, Vector<Dog*>, Vector<Cat*>, ..., aynı (C ++ paylaşacak ve onların işaretçi tipi olan ikili) uygulanması için kod sildim arkasında void*.

Tip silme tekniklerinin (oldukça kısa) bir listesi ve ödünleşimler hakkında tartışma için bu yazı dizisine bakın: Bölüm I , Bölüm II , Bölüm III , Bölüm IV .

Henüz bahsetmediğim Adobe.Poly ve Boost.Variant , bir dereceye kadar bir tür silme olarak kabul edilebilir.

Marc tarafından belirtildiği gibi, döküm kullanılabilir std::shared_ptr<void>. Örneğin, türü bir işlev işaretçisinde saklayın, yayınlayın ve yalnızca bir tür bir işleçte saklayın:

#include <iostream>
#include <memory>
#include <functional>

using voidFun = void(*)(std::shared_ptr<void>);

template<typename T>
void fun(std::shared_ptr<T> t)
{
    std::cout << *t << std::endl;
}

int main()
{
    std::function<void(std::shared_ptr<void>)> call;

    call = reinterpret_cast<voidFun>(fun<std::string>);
    call(std::make_shared<std::string>("Hi there!"));

    call = reinterpret_cast<voidFun>(fun<int>);
    call(std::make_shared<int>(33));

    call = reinterpret_cast<voidFun>(fun<char>);
    call(std::make_shared<int>(33));


    // Output:,
    // Hi there!
    // 33
    // !
}