Ich habe eine variant-Klasse geschrieben, die ein beliebiges Objekt beinhalten kann. Ich kann allerdings u.a. das verhalten des = Operators nicht nachvollziehen. Wenn ich einem Variant-Objekt ein anderes Variant-Objekt zuweise, dann müsste doch das erste Objekt das ganze andere Objekt beinhalten und nicht nur dessen inhalt (in diesem Beispiel der String). Oder ist es ein Sonderfall weil es zwei Objekte vom selben Typ sind? Hat jemand eine Idee was da genau abgeht?

#ifndef VARIANT_H
#define VARIANT_H

#include <cstdlib>

class variant
{
    public:
        // constructor
        variant()
        {
            m_size = 0;
            m_data = NULL;
            }
        // initializer constructor
        template <typename T>
        variant(const T &obj)
        {
            store(&obj);
            }
        // copy constructor
        variant(const variant &v)
        {
            m_size = v.m_size;
            free(m_data);
            m_data = malloc(m_size);
            memcpy(m_data, v.m_data, m_size);
            }
        // destructor
        virtual ~variant()
        {
            free(m_data);
            }
        // = operator
        template <typename T>
        variant& operator = (const T &obj)
        {
            store(&obj);
            }
        // get object data
        template <typename T>
        T get()
        {
            return *((T*)m_data);
            }
        // get object size
        size_t size()
        {
            return m_size;
            }

    private:
        // store object in variant
        template<typename T>
        void store(const T *obj)
        {
            free(m_data);
            m_size = sizeof(T);
            m_data = malloc(m_size);
            memcpy(m_data, obj, m_size);
            }
        // object size    
        size_t  m_size;
        // object data
        void   *m_data;
    };

#endif

Das geht:

#include <cstdlib>
#include <iostream>
#include <string>
#include "variant.h"

using namespace std;

int main(int argc, char *argv[])
{

    variant x = string("Hallo");
    variant y;

    y = x;

    cout << y.get<string>() << endl;

    system("PAUSE");
    return EXIT_SUCCESS;
    }

Das geht nicht (crash), obwohl es meiner Meinung nach logischer wäre:

#include <cstdlib>
#include <iostream>
#include <string>
#include "variant.h"

using namespace std;

int main(int argc, char *argv[])
{

    variant x = string("Hallo");
    variant y;

    y = x;

    cout << (y.get<variant>()).get<string>() << endl;

    system("PAUSE");
    return EXIT_SUCCESS;
    }

hab gar nicht weitergelesen

template <typename T>
variant& operator = (const T &obj)

variant& operator = (const variant &v)

Kann ich dann davon ausgehen, dass 1. immer dann verwendet wird, wenn 2. nicht geht?

if(this != &obj)

ausschließen.

(Falls das überhaupt so kompiliert!)