Question

I’m writing properties in C++. I came up with this code(not as good as the below).

Then i wanted to make it possible so i can write Property<int>& and use either version. I came up with the below. I have two problems.

1) At the moment i have a compile error when calling fn(a);

error C2243: 'type cast' : conversion from 'Property1<T> *' to 'Property<T> &' exists, but is inaccessible

2) Would it be possible to write this in such a way i don’t have to specify if its Property1 or Property2?

The code i came up

#include <cstdio>
#include <functional>

template <class T>
class Property{
    Property(const Property&p) {}
    Property() {}
public:
    virtual Property& operator=(const Property& src)=0;
    virtual Property& operator=(const T& src)=0;
    virtual operator T() const=0;
};

template <class T>
class Property1 : Property<T> {
    T v;
public:
    Property1(const Property1&p) {*this=static_cast<T>(p);}
    //Property1() { printf("ctor %X\n", this);}
    Property1(){}
    Property& operator=(const Property& src) { return*this=static_cast<T>(src); }
    Property& operator=(const T& src) {
        printf("write %X\n", this);
        v = src; 
        return *this; 
    }
    operator T() const {
        printf("Read %X\n", this);
        return v;
    }
};

template <class T>
class Property2 : Property<T> {
    typedef T(*Gfn)();
    typedef void(*Sfn)(T);
    Gfn gfn;
    Sfn sfn;
public:
    Property2(const Property2&p) {*this=static_cast<T>(p);}
    //Property2() { printf("ctor %X\n", this);}
    Property2(Gfn gfn_, Sfn sfn_):gfn(gfn_), sfn(sfn_) {}
    Property& operator=(const Property& src) { return*this=static_cast<T>(src); }
    Property& operator=(const T& src) {
        printf("write %X\n", this);
        sfn(src);
        return *this; 
    }
    operator T() const {
        printf("Read %X\n", this);
        return gfn();
    }
};

void set(int v) {}
int get() {return 9;}

Property1<int> a, b;
Property2<int> c(get,set), d(get,set);
void fn(Property<int>& v) { v=v=31; }
int main(){
    a=b=5;
    c=d=11;
    a=c=b=d=15;
    fn(a);
    fn(c);
}

Answer 1

You are using private inheritance. That means the base class of Property1 and Property2 is inaccessible. You should replace this..

template <class T>
class Property1 : Property<T> {

with this

template <class T>
class Property1 : public Property<T> {