Thread: implementing property in c++ just like c#?

hello all .
i was recently coding a test application in Visual C++.net and i faced sth that , to me was strange .
we all know that in c# we can access properties very easily sth like :

Code:

btn.Text = "Setting the text ";
string variable = btn.Text;

but in c++ we have sth like these:

Code:

btn->SetText("sth");
string var = btn->GetText();

there is always a Set() function to set the values, and Get() function to retrive the values.!
having all said , i saw the c# conventional use of property in c++, i mean i could write !:

Code:

btn->Text = "sth goes here!";
string variable = btn->Text;

!and i wondered if it is really possible to have sth like this in c++ .
thats all , so is it all MS VC++.net specific ? or no this can be achieved in general c++ too ?
i will be very thankful if anyone gives me an answer
and isn't there anyway to implement such thing in c++? ( i mean writing properties just like what we have in c# ?)
Thank you in advance

Code:

btn->Text = "sth goes here!";
string variable = btn->Text;

Yeah, if btn::Text is of type string as well as a public member that syntax will work as is.

But part of the Object-Oriented mantra of C++ is that you hide the innards (read: data members) of your class, so btn::Text is probably a private member, and that's why you have the get and set functions.

Properties don't mean that the members are public.

It is also possible to overload the accessor, so they have the same name.

Code:

btn->Text("sth");
string var = btn->Text();

Similarly, it is possible to use types that overload operator= and conversion for the value type.

For example:

Code:

namespace properties
{
    enum {
        no_restrictions = 0,
        no_setter = 1,
        no_mutable_getter = 2,
        no_getter = 4,
        immutable = no_setter | no_mutable_getter
    };

namespace detail
{
    template <class Derived, class ValueType, bool HasSetter>
    struct Setter
    {
        Derived& operator= (const ValueType& value)
        {
            static_cast<Derived&>(*this).value = value;
            return static_cast<Derived&>(*this);
        }
    };
    template <class Derived, class ValueType>
    struct Setter<Derived, ValueType, false> {};

    template <class Derived, class ValueType, bool HasGetter, bool HasMutableGetter>
    struct Getter
    {
        operator ValueType& ()
        {
            return static_cast<Derived&>(*this).value;
        }
        operator const ValueType& () const
        {
            return static_cast<const Derived&>(*this).value;
        }
    };

    template <class Derived, class ValueType>
    struct Getter<Derived, ValueType, true, false>
    {
        operator const ValueType& ()
        {
            return static_cast<Derived&>(*this).value;
        }
        operator const ValueType& () const
        {
            return static_cast<const Derived&>(*this).value;
        }
    };

    template <class Derived, class ValueType, bool Ignored>
    struct Getter<Derived, ValueType, false, Ignored>{};
} //detail
    template <class ValueType, unsigned DisabledFlag = properties::no_restrictions>
    class DefaultProperty:
        public detail::Setter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_setter) == 0
        >,
        public detail::Getter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_getter) == 0,
            (DisabledFlag & properties::no_mutable_getter) == 0
        >
    {
        ValueType value;
    public:
        explicit DefaultProperty(const ValueType& value = ValueType()): value(value) {}
        using detail::Setter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_setter) == 0
        >::operator=;
    private:
        friend class detail::Setter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_setter) == 0
        >;
        friend class detail::Getter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_getter) == 0,
            (DisabledFlag & properties::no_mutable_getter) == 0
        >;
    };
}

struct X
{
    properties::DefaultProperty<int> a;
    properties::DefaultProperty<int, properties::no_setter> b;
    properties::DefaultProperty<int, properties::immutable> c;
};

#include <iostream>
int main()
{
    X x, y;
    y.a = x.a = 100;
    std::cout << x.a << ' ' << y.a << '\n';
    //x.b = 50;
    std::cout << x.b << '\n';
    //x.c = 75;
    int c = x.c;
    //int& d = x.c;
    std::cout << c << '\n';
}

This example allows some customizability as to whether the default implementations of getters and setters are available or not (commented-out lines cause errors).

Other property types might be added that allow calling a method of the parent class.

Damn I can't believe I did that!

Sorry, I was going to start a new thread, and then posted here.

Originally Posted by anon

Properties don't mean that the members are public.

It is also possible to overload the accessor, so they have the same name.

Code:

btn->Text("sth");
string var = btn->Text();

Similarly, it is possible to use types that overload operator= and conversion for the value type.

For example:

Code:

namespace properties
{
    enum {
        no_restrictions = 0,
        no_setter = 1,
        no_mutable_getter = 2,
        no_getter = 4,
        immutable = no_setter | no_mutable_getter
    };

namespace detail
{
    template <class Derived, class ValueType, bool HasSetter>
    struct Setter
    {
        Derived& operator= (const ValueType& value)
        {
            static_cast<Derived&>(*this).value = value;
            return static_cast<Derived&>(*this);
        }
    };
    template <class Derived, class ValueType>
    struct Setter<Derived, ValueType, false> {};

    template <class Derived, class ValueType, bool HasGetter, bool HasMutableGetter>
    struct Getter
    {
        operator ValueType& ()
        {
            return static_cast<Derived&>(*this).value;
        }
        operator const ValueType& () const
        {
            return static_cast<const Derived&>(*this).value;
        }
    };

    template <class Derived, class ValueType>
    struct Getter<Derived, ValueType, true, false>
    {
        operator const ValueType& ()
        {
            return static_cast<Derived&>(*this).value;
        }
        operator const ValueType& () const
        {
            return static_cast<const Derived&>(*this).value;
        }
    };

    template <class Derived, class ValueType, bool Ignored>
    struct Getter<Derived, ValueType, false, Ignored>{};
} //detail
    template <class ValueType, unsigned DisabledFlag = properties::no_restrictions>
    class DefaultProperty:
        public detail::Setter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_setter) == 0
        >,
        public detail::Getter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_getter) == 0,
            (DisabledFlag & properties::no_mutable_getter) == 0
        >
    {
        ValueType value;
    public:
        explicit DefaultProperty(const ValueType& value = ValueType()): value(value) {}
        using detail::Setter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_setter) == 0
        >::operator=;
    private:
        friend class detail::Setter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_setter) == 0
        >;
        friend class detail::Getter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_getter) == 0,
            (DisabledFlag & properties::no_mutable_getter) == 0
        >;
    };
}

struct X
{
    properties::DefaultProperty<int> a;
    properties::DefaultProperty<int, properties::no_setter> b;
    properties::DefaultProperty<int, properties::immutable> c;
};

#include <iostream>
int main()
{
    X x, y;
    y.a = x.a = 100;
    std::cout << x.a << ' ' << y.a << '\n';
    //x.b = 50;
    std::cout << x.b << '\n';
    //x.c = 75;
    int c = x.c;
    //int& d = x.c;
    std::cout << c << '\n';
}

This example allows some customizability as to whether the default implementations of getters and setters are available or not (commented-out lines cause errors).

Other property types might be added that allow calling a method of the parent class.

Nice approach!

Properties do not destroy encapsulation. They are a different form of get/set syntax. That's all.

Originally Posted by anon

Properties don't mean that the members are public.

It is also possible to overload the accessor, so they have the same name.

Code:

btn->Text("sth");
string var = btn->Text();

Similarly, it is possible to use types that overload operator= and conversion for the value type.

For example:

Code:

namespace properties
{
    enum {
        no_restrictions = 0,
        no_setter = 1,
        no_mutable_getter = 2,
        no_getter = 4,
        immutable = no_setter | no_mutable_getter
    };

namespace detail
{
    template <class Derived, class ValueType, bool HasSetter>
    struct Setter
    {
        Derived& operator= (const ValueType& value)
        {
            static_cast<Derived&>(*this).value = value;
            return static_cast<Derived&>(*this);
        }
    };
    template <class Derived, class ValueType>
    struct Setter<Derived, ValueType, false> {};

    template <class Derived, class ValueType, bool HasGetter, bool HasMutableGetter>
    struct Getter
    {
        operator ValueType& ()
        {
            return static_cast<Derived&>(*this).value;
        }
        operator const ValueType& () const
        {
            return static_cast<const Derived&>(*this).value;
        }
    };

    template <class Derived, class ValueType>
    struct Getter<Derived, ValueType, true, false>
    {
        operator const ValueType& ()
        {
            return static_cast<Derived&>(*this).value;
        }
        operator const ValueType& () const
        {
            return static_cast<const Derived&>(*this).value;
        }
    };

    template <class Derived, class ValueType, bool Ignored>
    struct Getter<Derived, ValueType, false, Ignored>{};
} //detail
    template <class ValueType, unsigned DisabledFlag = properties::no_restrictions>
    class DefaultProperty:
        public detail::Setter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_setter) == 0
        >,
        public detail::Getter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_getter) == 0,
            (DisabledFlag & properties::no_mutable_getter) == 0
        >
    {
        ValueType value;
    public:
        explicit DefaultProperty(const ValueType& value = ValueType()): value(value) {}
        using detail::Setter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_setter) == 0
        >::operator=;
    private:
        friend class detail::Setter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_setter) == 0
        >;
        friend class detail::Getter<
            DefaultProperty<ValueType, DisabledFlag>,
            ValueType,
            (DisabledFlag & properties::no_getter) == 0,
            (DisabledFlag & properties::no_mutable_getter) == 0
        >;
    };
}

struct X
{
    properties::DefaultProperty<int> a;
    properties::DefaultProperty<int, properties::no_setter> b;
    properties::DefaultProperty<int, properties::immutable> c;
};

#include <iostream>
int main()
{
    X x, y;
    y.a = x.a = 100;
    std::cout << x.a << ' ' << y.a << '\n';
    //x.b = 50;
    std::cout << x.b << '\n';
    //x.c = 75;
    int c = x.c;
    //int& d = x.c;
    std::cout << c << '\n';
}

This example allows some customizability as to whether the default implementations of getters and setters are available or not (commented-out lines cause errors).

Other property types might be added that allow calling a method of the parent class.

Thank you, anon. You sure know how to recognize different types of trees from quite a long way away.

Thank you Dear anon , i really appreciate the time and effort you spent to clarify this for me and the others . big thanks .



but how is it possible to extend the functionality of this package ? i mean using this package we can only have simple assignment setters and getters avoided, and for any new setters/getters we need to recode some parts again alot !
any idea on this ?
i'm more specifically into knowing if making sth such as this in c++ is possible:
and if it is , it would be a nice idea to try and add it to the boost library maybe, before the standard committee does so ? ( in case they care to do such a thing at all! ?)

whats your idea?

Originally Posted by Bubba

Why would you want this in C++? C++ has multiple ways to do this but properties are not part of the language and really all they do is encapsulate getters/setters which C++ has been doing for many many years.

i know there are ways, but this elegant way , is really making stuff easier .

Originally Posted by Elysia

Properties do not destroy encapsulation. They are a different form of get/set syntax. That's all.

yes indeed .

Originally Posted by Bubba

Elysia is correct. There isn't anything magical about properties in C#. They are a welcome addition to any language b/c I know personally I get tired of writing getters and setters in C++ but alas C++ does not yet have them so I have to. Perhaps one day C++ will have them and perhaps not. The point is that C++ does not 'need' them but they would be 'nice to have.'

*

Originally Posted by Elkvis

C# doesn't *need* them either, but they make a lot of things easier, especially in GUI programming.

*
if im not mistaken , i've seen that c# itself is doing it in traditional c++ way ( using setters and getters ) at backstage, so that the redundancy is avoided , and the code is clearer and just more elegant .
all in all , Bubba's idea on the subject is greatly desired .

Originally Posted by EVOEx

So why not make them yourself? It's very well possible (as anon showed and as you undoubtedly knew), and he's only showing a very basic form. You could add a lot of functionality such setting functions to validate the set value, and templates where for instance you can specify allowed ranges.
When designed properly, it would be fairly easy to use, probably as easy as in C#.

really if sth can be done on this subject and get submitted to the c++ committee or boost libraries , that would be awesome !

There would seem to be great problems implementing more advanced properties.

For example, check out this.

1) Overhead for the property.
2) Limited signature for the getter and setter methods.
3) Need to give the pointer to parent to each property in the constructor.
4) Need to code a copy constructor to do the same.

It just doesn't seem to be worth it.

There is a problem with getters with the current C++ standard due to implicit conversion operators. They cause unwanted side effects.
This should be fixed in C++0x, though, when we can make them explicit.

Microsoft also have their own non-standard properties extension for C++, for those interested in such things.