Virtuelle template Funktionen in Klassen

LukasBanana

Hi,
ich wollte wissen ob und wie man in C++ virtual template functions in einer class erstellen kann.

Meine Idee dafür sieht so aus:

class CFile
{
    public:
        CFile();
        virtual ~CFile();
        virtual template <typename T> void write(T Value) = 0; // Geht das bzw. geht das so?
};

class CFileHDD : public CFile
{
    public:
        CFileHDD();
        ~CFileHDD();
        template <typename T> void write(T Value)
        {
            fwrite(&Value, 1, sizeof(T), m_Handle);
        }
    private:
        FILE* m_Handle;
};

class CFileRAM : public CFile
{
    public:
        CFileRAM();
        ~CFileRAM();
        template <typename T> void write(T Value)
        {
            char* NewBuffer = (char*)&Value;
            for (int i = 0; i < sizeof(T); ++i, ++NewBuffer)
                m_Buffer.push_back(*NewBuffer);
        }
    private:
        std::vector<char> m_Buffer;
};

Kann mir da bitte jemand was zu sagen und mir helfen?

pumuckl

LukasBanana schrieb:

Hi,
ich wollte wissen ob und wie man in C++ virtual template functions in einer class erstellen kann.

Ganz kurze Antwort: nein.
Es wäre quasi unmöglich, dafür z.B. eine vtable zu implementieren.

hustbaer

Wie pumuckl schon sagte kann es keine virtuellen Funktions-Templates geben.

Die (vermutlich eh offensichtliche) 08/15 "Lösung":

class CFile
{
    public:
        CFile();
        virtual ~CFile();

        template <typename T> void write(T const& value)
        {
            write_impl(&value, sizeof(value));
        } 

    private:
        virtual void write_impl(void const* data, size_t size) = 0;
};

class CFileHDD : public CFile
{
        virtual void write_impl(void const* data, size_t size)
        {
            fwrite(data, 1, size, m_Handle);
        }

        FILE* m_Handle;
};

class CFileRAM : public CFile
{
        virtual void write_impl(void const* data, size_t size)
        {
            char const* pc = static_cast<char const*>(data);
            for (size_t i = 0; i < size; ++i)
                m_Buffer.push_back(pc[i]);
        }

        std::vector<char> m_Buffer;
};