Re: address of virtual member function passed as template argument

On 19 Mrz., 20:38, "Ben Voigt" <r...@nospam.nospam> wrote:


Yes, that's the library i was talking about. Sorry for not posting a
link.
Thank you all for your great ideas for good property solution.

The proxy-Version from Ben Voigt compiles very well, but it is a lot
of work to write a wrapper function for every function.
The Observer-Version from Igor Tandetnik is also very interesting,
but what about class-inheritance ? i think you will run into problems
with that.
Another problem is that the value is stored within the property which
is a restriction in a way.

You should also be able to write properties which don't store values
but only call C-API functions or so.

I think it would be best if we could specify the get/set - functions
is a separate struct.
Like this:

class Car
{
public:
struct SpeedProp
{
int get() {}
void set(int) {}
}
}

So here is my solution:
// main.cpp - draft for properties

#include <iostream>

template<class T>
class IPropertyImplementation
{
public:
    virtual ~IPropertyImplementation() {}

public:
    virtual void set(const T& value) = 0;
    virtual T get() const = 0;
};

template<class T>
class property
{
private:
    IPropertyImplementation<T>* prop;

public:
    property(IPropertyImplementation<T>* prop)
        : prop(prop)
    {
    }

    ~property()
    {
        if(prop) // i know that this is not safe, but this is only a draft
version
            delete prop;
    }

    property<T>& operator=(const T& value)
    {
        prop->set(value);
        return *this;
    }

    operator T()
    {
        return prop->get();
    }

        // more operators etc.
};

class Car
{
private:
    int speed;

public:
    struct SpeedProperty : public IPropertyImplementation<int>
    {
        Car* base; // pointer to car object
        SpeedProperty(Car* base) : base(base) {}

        void set(const int& value) { base->speed = value; }
        int get() const { return base->speed; }
    };
    friend struct SpeedProperty; // needed?

    property<int> Speed;

public:
    Car()
        : Speed(new SpeedProperty(this))
    {}
};

int main(int argc, char* argv[])
{
    Car c;
    c.Speed = 2007;
    std::cout << c.Speed << std::endl; // -> 2007
    return 0;
}

What do you guys think about it? Any ideas for improvements or other
concepts?