c++: überschreiben von template-member-Funktion in übergeordneten Klasse

Nehmen wir an, ich habe so eine Struktur der Klassen: Basisklasse Object, die in einer übergeordneten Klasse Bool, Int, Float, Bytes und Unicode Klassen. Ich hatte vor, einige Funktionen wie Bool cast_bool() const, Int cast_int() const usw. als virtuelle Funktionen in der Object Klasse und in allen Kind-Klassen, die ich habe, umgesetzt werden diese Funktionen getrennt.

Scheint es, dass eine bessere Lösung ist die Umsetzung template <typename TYPE> TYPE cast() const - Funktion statt. Da jedoch C++ verbietet virtual-template-Funktionen, die ich don ' T wissen, wie kann ich diese Aufgabe abzuschließen. Was ich brauche ist template <typename TYPE> TYPE cast() const für Object und seine childs. Generische Object::cast<TYPE>() const wird nur werfen CastError; dann für jeden Typ, wie Bool, Int usw. Ich werde implementieren, die Funktionen wie Bool::cast<Bool>() const, Int::cast<Bool>() const usw. Ich bin auch in Planung cast builtin-Objekte, obwohl ich jetzt nur überlastung operator bool() const, operator signed short() const usw. Wenn es keine Implementierung, template wechseln müssen, um seine generische form von Object Klasse, gerade zu werfen ist ein Fehler. Gibt es einen Weg, es zu tun (vielleicht brauche ich, um verwenden einige Muster)? Oder es ist einfacher zu verlassen Funktionen wie Int cast_int() const? Vielen Dank im Voraus!

Wenn Ihre Umwandlung von Daten in der base-Klasse, es gibt keinen Grund, warum können Sie nicht fügen Sie ein Vorlagen-member-Funktion auf der gleichen Basis-Klasse. Dann haben die Kind-Klassen aufrufen, die. Oder vielleicht bin ich missunderstanding die Frage.

InformationsquelleAutor ghostmansd | 2013-07-11

c++function templates virtual-functions

Fügen Sie eine Zwischenklasse wie im Beispiel unten, oder verwenden Sie einfach dynamic_cast ohne template-Methoden.

#include <iostream>
#include <string>
using namespace std;

template <class> class ObjectImpl;

class Object
{
public:
    virtual ~Object() {}

    template <class T>
    T cast() const
    {
        if (auto obj = dynamic_cast<const ObjectImpl<T>*>(this))
        {
            return obj->cast();
        }
        else
        {
            throw std::string("cast error");
        }
    }
};

template <class T>
class ObjectImpl : public Object
{
public:
    virtual T cast() const = 0;
};

class Bool : public ObjectImpl<bool>
{
public:
    bool cast() const override { return true; }
};
class Float : public ObjectImpl<float>
{
public:
    float cast() const  override { return 12.34f; }
};

int main()
{
    Object* obj = new Float;

    cout << obj->cast<float>() << endl;

    try
    {
        cout << obj->cast<bool>() << endl;
    }
    catch (std::string e)
    {
        cout << e << endl;
    }

    return 0;
}

InformationsquelleAutor catscradle

Was du machst klingt nicht wie eine sehr gute Idee, den C++ ist nicht Java oder C#... trotzdem konnte man es so machen:

class Object
{
public:

     template<typename T>
     T& cast()
     {
          return cast_impl(std::declval<T>());
     }

private:
     virtual bool& cast_impl(bool&){ throw std::bad_cast(); }
     virtual int& cast_impl(int&){ throw std::bad_cast(); }
};

class Boolean : public Object
{
    bool value_;
public:

private:
     bool& cast_impl(bool) override
     { 
         return value_;
     }
};

InformationsquelleAutor ronag

Können Sie halten eine Reihe von flags

enum Castablity{
    intable    = 0x1,
    floatable  = 0x2,
    doubleable = 0x4,
    bytable    = 0x8,
    stringable = 0x10,
    unicodable = 0x20,
};

halten und eine virtual int castable() const Funktion in jeder dieser Klasse, z.B. Ihre Int::castable() zurück intable | floatable | doublable | stringable . und Sie müssen eine andere Vorlagen-Karte, die dauert eine Castablity enum-Wert und return-Ziel-Typ in typedef .

template <typename T>
struct type_value;

template <enum v>
struct value_type;

template <>
struct type_value<Int>{
    enum {value = intable;}
};
template <>
struct value_type<intable>{
    typedef Int data_type;
};

und eine Globale cast-Funktion

template <typename T, typename U>
U cast(const T& original){
    if(!original.castable(type_value<U>::value))
        //throw exception
    return detail::cast<U>(original.internal_data());
}

Können Sie eine virtuelle Methode, die einen integer-Wert, statt der Typen zur Kompilierzeit. oder Sie können eine interne Struktur, die zum speichern aller Arten von Objekt-Werte. so etwas wie boost::any

und Sie können schreiben, eine weitere Spezialisierung im detail-namespace, die sich bekehren werden, dass der interne Typ Zieltyp

namespace detail{
  template <typename T>
  ///you may have specialization for different types
  struct casting_helper{
    static T cast(const internal_type& data){

    }
  }
  template <typename T>
  T cast(const internal_data& data){
      return casting_helper<T>::cast(data);
  }
}

InformationsquelleAutor Neel Basu

Andere alternative, wenn Sie fein mit Laufzeit-casts.

class Object
{
public:

     template<typename T>
     T& cast()
     {
          return *dynamic_cast<T*>(get());
     }

private:
     virtual void* get() = 0;
};

class Boolean : public Object
{
    bool value_;
public:

private:
    void* get() override
    {
        return &value_;
    }
}

InformationsquelleAutor ronag

Können Sie erstellen eine Art wrapper für das Objekt.

struct TypeWrapperBase
{
protected:
    static int m_counter;
};

int TypeWrapperBase::m_counter = 0;

template<typename T>
struct TypeWrapper:
    TypeWrapperBase
{
    static int m_type;
protected:
    static int AllocateType()
    {
        m_counter++;
        return m
    }
public:
    static int GetType()
    {
        return m_type;
    }   
};

template<typename T>
int TypeWrapper<T>::m_type = TypeWrapperBase::m_counter++;

void main()
{
    std::cout << TypeWrapper<int>::GetType() << std::endl;   //prints 0
    std::cout << TypeWrapper<float>::GetType() << std::endl;  //prints 1
    std::cout << TypeWrapper<bool>::GetType() << std::endl; //prints 2
}

Nun auf diese Weise können Sie simulieren ein beliebiges Objekt durch den Vergleich el1.GetType() mit el2.GetType(). Wenn es gleich ist, können Sie führen Sie eine statische cast

InformationsquelleAutor Martin Kosicky

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.