my new property class

[Cambalinho]

i'm doing my new property class, but i'm stuck with functions :(

#include <iostream>
#include <functional>

using namespace std;

template <typename T>
class property
{
private:
    T PropertyValue;
    std::function<void(void)> getf=NULL;
    std::function<void(T a)> setf=NULL;
public:
    property()
    {
        //nothing
    };

    property(std::function<void(void)> GetFunction,std::function<T(void)> SetFunction)
    {
        setf=SetFunction;
        getf=GetFunction;
    }

    property& operator=(T value)
    {
        if(setf==NULL)
            PropertyValue=value;
        else
            setf(value);
        return *this;
    }

    T& operator=(property value)
    {
        if(getf==NULL)
            return PropertyValue;
        else
            return getf();
    }

    friend ostream& operator<<(ostream& os, const property& dt)
    {
        os << dt.PropertyValue;
        return os;
    }

    friend istream& operator>>(istream &input,property &dt)
    {
        input>>dt.PropertyValue;
        return input;
    }
};

class test
{
public:
    property<string> Name;
    property<int> Age;
};

test a;
int main()
{
    a.Name="joaquim "  "Miguel";
    a.Age=10+15;
    cout << a.Name << endl;
    cout << "what is your name?\n";
    cin >> a.Name;
    cout << "your name is: " << a.Name << endl;
    return 0;
}

the code works like a charm. but imagine that i need more with Get and Set functions, how can i connect them to the T PropertyValue on class property?
yes... i'm a little confuse.... :(

[Cambalinho]

now i did these new test:

#include <iostream>
#include <functional>

using namespace std;

template <typename T>
class property
{
private:
    T PropertyValue;
    std::function<void(void)> getf=NULL;
    std::function<void(T a)> setf=NULL;
public:
    property()
    {
        //nothing
    };

    property(std::function<void(void)> GetFunction,std::function<T(void)> SetFunction)
    {
        setf=SetFunction;
        getf=GetFunction;
    }

    property& operator=(T value)
    {
        if(setf==NULL)
            PropertyValue=value;
        else
            setf(value);
        return *this;
    }

    T& operator=(property value)
    {
        if(getf==NULL)
            return PropertyValue;
        else
            return getf();
    }

    friend ostream& operator<<(ostream& os, const property& dt)
    {
        os << dt.PropertyValue;
        return os;
    }

    friend istream& operator>>(istream &input,property &dt)
    {
        input>>dt.PropertyValue;
        return input;
    }
};

void sethi(string b)
{
    b = b + " hi";
}

string gethi()
{
    return "hello";
}

class test
{
public:
    property<string> Name(&sethi,&gethi);
    property<int> Age;
};

test a;
int main()
{
    a.Name="joaquim "  "Miguel";
    a.Age=10+15;
    cout << a.Name << endl;
    cout << "what is your name?\n";
    cin >> a.Name;
    cout << "your name is: " << a.Name << endl;
    return 0;
}

but i get several errors and warnings.
please can anyone advice me?

[Cambalinho]

now the property works. but i have 1 problem with:
when i use it inside the class(test, for exemple), the 1st test instance works, but not the other instances :(

template <typename T>
class property
{
private:
    T PropertyValue;
    std::function<T(void)> getf;
    std::function<void(T)> setf;
public:

    property(T value)
    {
        PropertyValue=value;
    };

    property(std::function<T(void)> GetFunction=nullptr,std::function<void(T)> SetFunction=nullptr)
    {
        setf=SetFunction;
        getf=GetFunction;
    }

    property& operator=(T value)
    {
        if(getf==nullptr || setf==nullptr)
            PropertyValue=value;
        else
            setf(value);
        return *this;
    }

    T& operator=(property value)
    {
        if(value.getf==nullptr || value.setf==nullptr)
            return value.PropertyValue;
        else
            return value.getf();
    }


    friend ostream& operator<<(ostream& os, const property& dt)
    {
        if(dt.getf==nullptr && dt.setf==nullptr)
            os << dt.PropertyValue;
        else if (dt.getf!=nullptr)
            os << dt.getf();
        return os;
    }

    friend istream& operator>>(istream &input, property &dt)
    {
        input >> dt.PropertyValue;
        if (dt.setf!=nullptr)
            dt.setf(dt.PropertyValue);
        return input;
    }

    friend istream &getline(istream &in, property &dt)
    {
        getline(in, dt.PropertyValue);
        if (dt.setf!=nullptr)
            dt.setf(dt.PropertyValue);
        return in;
    }
};

i belive these is a pointer instance problem... or my class property have 1 error, that i don't know :(
please can anyone advice me?

[coder777]

what are you trying to achieve with that class?

[Cambalinho]

just create properties in a class for use the '=' operator instead the get and set functions.
but, like you see, i create the property with just 1 line of code ;)

[coder777]

right now you get the same result with:

class test
{
public:
    string Name;
    int Age;
};

The functions sethi and gethi are completely unrelated to anything within the class property. So I don't see the use of it.

I really don't see the use of property?

[Cambalinho]

ok... teste these entire code:

#include <iostream>
#include <sstream>

using namespace std;

template <typename T>
class property
{
private:
    T PropertyValue;
    std::function<T(void)> getf;
    std::function<void(T)> setf;
public:

    property(T value)
    {
        PropertyValue=value;
    };

    property(std::function<T(void)> GetFunction=nullptr,std::function<void(T)> SetFunction=nullptr)
    {
        setf=SetFunction;
        getf=GetFunction;
    }

    property& operator=(T value)
    {
        if(getf==nullptr || setf==nullptr)
            PropertyValue=value;
        else
            setf(value);
        return *this;
    }

    T& operator=(property value)
    {
        if(value.getf==nullptr || value.setf==nullptr)
            return value.PropertyValue;
        else
            return value.getf();
    }


    friend ostream& operator<<(ostream& os, const property& dt)
    {
        if(dt.getf==nullptr && dt.setf==nullptr)
            os << dt.PropertyValue;
        else if (dt.getf!=nullptr)
            os << dt.getf();
        return os;
    }

    friend istream& operator>>(istream &input, property &dt)
    {
        input >> dt.PropertyValue;
        if (dt.setf!=nullptr)
            dt.setf(dt.PropertyValue);
        return input;
    }

    friend istream &getline(istream &in, property &dt)
    {
        getline(in, dt.PropertyValue);
        if (dt.setf!=nullptr)
            dt.setf(dt.PropertyValue);
        return in;
    }
};

template<typename T, typename Fnc1_t, typename Fnc2_t, typename classthis>
property<T> GetProperty(Fnc1_t Getter, Fnc2_t Setter, classthis clsthis)
{
    return property<T>(std::bind(Getter, clsthis), std::bind(Setter, clsthis, std::placeholders::_1));
}

#define PROPERTY(TypeName,PropertyName,getfunction, setfunction) \
property<TypeName> PropertyName{std::bind(&getfunction, this),std::bind(&setfunction, this, std::placeholders::_1)}

class test
{
public:
    int x;
    int y;
    int getx()
    {
        return x;
    }
    void setx(int value)
    {
        x=value;
    }
    int gety()
    {
        return y;
    }
    void sety(int value)
    {
        y=value;
    }
public:
    std::string go()
    {
        std::ostringstream out;
        out << '(' << x << ',' << y << ')' << ':' << x + y << '\n';
        return(out.str());
    }


    test()
    {

    }
    property<int> X=GetProperty<int>(&test::getx, &test::setx,this);
    //PROPERTY(int, X,test::getx, test::setx);
    PROPERTY(int, Y,test::gety, test::sety);
};

int main()
{
    test a;
    cout << "what is the x?\n";
    cin >> a.X;
    cout << "what is the y?\n";
    cin >> a.Y;
    cout << "\nhere is the result:\n" << a.go() << '\n';
    test b = a;
    cout << b.x << "\t" << b.y << endl;
    cout << "what is a different x?\n";
    cin >> b.X;
    cout << "what is a different y?\n";
    cin >> b.Y;
    cout << "\nhere is the result:\n" << b.go() << '\n';
    cout << "\noh wait, no; here is the result:\n" << a.go() << '\n';
    return 0;
}

just compile and execute and you will see what i mean of the error.
yes i can have normal variables, but these is a normal test for my property class

[coder777]

Yes, I see what's wrong. It's an really sophisticated way to shoot yourself in the foot;)

the problem is rather easy. On line 126 you copy everything including the function objects which include the this pointer of a. Which means even though you access b you really modify a

[Cambalinho]

realy i never knew that... thanks for correct me... thanks
before you shoot me, take off the bullets, please ;)

[Cambalinho]

that problem can be resolved with my class or it's a C++ thing?

[JLBorges]

I haven't looked at the code, except to note that property<T> is a Copyable and Moveable type.

That being the case, clients can trivially violate the encapsulation of the property.
Any one can bypass the setter and assign directly to the property. For instance:

int main()
{
    some_class_with_properties a;
    
    decltype(a.some_int_property) my_value(1234);

    std::swap( a.some_int_property, my_value ) ;
}

[Cambalinho]

but how can i avoid that problem?

[JLBorges]

The property needs to have a narrow interface which is accessible to everyone; the narrow interface provides just the get and set functionality.

And a wide interface which is only accessible to the class that contains the property. Constructors and other foundation operations would be part of this wide interface.

Something along these lines (caveat: this is merely an illustrative outline sketch):

#include <functional>
#include <iostream>

template < typename T, typename C > struct property // getter elided for brevity
{
    ////////////// the narrow interface is public //////////////////

    operator const T& () const& { return value ; }
    operator T () const&& { return value ; }

    property<T,C>& operator= ( const T& v )
    { if(setter) setter(v) ; else value = v ; return *this ; }

    // compound assignment operators (if required)
    // eg.
    property<T,C>& operator+= ( const T& v )
    {
        if(setter) setter(value+v) ; else value += v ;
        return *this ;
    }

    private:
        T value ;

        using setter_type = std::function< void( const T& ) > ;
        std::function< void( const T& ) > setter ;

        ////////////// the wide interface is private //////////////////

        property( T&& v ) : value( std::move(v) ) {}

        property( const T& v = T() ) : value(v) {}

        template < typename FN, typename... ARGS >
        property( const T& v, FN fn, ARGS... args ) : value(v),
                 setter( std::bind( fn, args..., std::placeholders::_1 ) ) {}

        // additional constructors (if required)

        property<T,C>( const property<T,C>& ) = default ;
        property<T,C>( property<T,C>&& ) = default ;
        property<T,C>& operator= ( const property<T,C>& ) = default ;
        property<T,C>& operator= ( property<T,C>&& ) = default ;

        ////////////// the containing class is a friend  //////////////////
        ////////////// and can access the wide interdace //////////////////
        friend C ;
};

template < typename CHAR_TYPE, typename TRAITS_TYPE, typename T, typename C >
std::basic_ostream<CHAR_TYPE,TRAITS_TYPE>&
operator << ( std::basic_ostream<CHAR_TYPE,TRAITS_TYPE>& stm, 
              const property<T,C>& prop ) { return stm << T(prop) ; }

#include <string>

struct A
{
    property<std::string,A> name{ "anonymous", &A::set_name, this, 3 };

    property<double,A> amount{ 12.3, &A::set_amount, this } ;

    private:
        void set_amount( double d )
        { /* validate */ amount.value = d ; std::cout << "set_amount\n" ; }

        void set_name( int excl, std::string new_name )
        {
            /* validate */
            name.value = new_name + std::string( excl, '!') ;
            std::cout << "set_name\n" ;
        }
};

int main()
{
    A a ;
    std::cout << a.name << ' ' << a.amount << '\n' ;

    a.name = "Cambalinho" ;
    a.amount += 567.89 ;

    std::cout << a.name << ' ' << a.amount << '\n' ;

    #ifdef TRY_BYPASS_SETTER
        decltype(a.amount) my_value(1234) ; // ***error: constructor is private
        std::swap( a.amount, my_value ) ; // ***error: move constructor is private
    #endif // TRY_BYPASS_SETTER
}

http://coliru.stacked-crooked.com/a/75d6657718276214