Thread: a C++ library of mine.

Originally Posted by citizen

Accessors are not horrible if they are relevant to the problem domain.
How is that not an accessor, anyway? I mean yeah, you didn't name the pair get and set, but a rose by any other name ...

I can accept

form.caption(str); //set
str = form.caption(); //get

the name caption is more flexibler than get_caption/set_catpion, it's easy and harmless.

a property has to face an important issue. e.g.

Code:

template<typename T>
struct property
{
        operator T()const { return T(); }
        
};

assume a form has a caption property object by type of property<std::string>

Code:

std::string str;
str = form.property; //OK,  operator T() works
str == form.property; //!!

Can't deduce the template parameter of bool operator==(const std::basic_string<C, T, A>&, const std::basic_string<C, T, A>&) with form.property.

fix the issue by overloading the operator==, but this solution is not good enough in my opinion, too many operators need to be overloaded.

I just think about whether the property is necessary in a C++ class. the form::caption is not only an assignment operation, but also setting the caption of a window. Actually, a generic property template is not cheap for some situations.

Code:

form.SetCaption(str);
str = form.GetCaption();

I honestly don't see the problem with this. It's so beautifully verbose. I realize you already reached a consensus. So never mind me.

I have a problem with it mostly due to two [four] reasons:
1) Having to write two functions to do thing (basically).
2) Having two functions littering the definition instead of one.
And the [optional] 3rd) It's just ugly to have to type Get/Set.
And the [optional] 4th) It just feels more natural to be able to use operator = to assign and nothing to get since it feels like it's a property of the object - not some function that changes the state of the object.

1 and 2 can be solved using a generic template, alternatively two functions for advanced functionality.

Is there a reason you have your own custom license for the project instead of just releasing it under the GPL or BSD license (or even public domain)?

Originally Posted by Elysia

The function pointer can be passed via the template declaration instead to save some bytes...
4 bytes overhead is not much. It's typically what a smart pointer takes (or less).
I find it acceptable between functionality and overhead/size.

I have implemented a generic property template before. like this

Code:

template<typename T, typename Class>
class property
{
    typedef property self_type;
public:
    property(Class& obj, void (Class::* setter)(const T&), const T& (Class::*getter)() const)
        :object_(obj), setter_(setter), getter_(getter)
    {}

    operator T() const
    {
         return object_.getter_();
    }

    self_type& operator=(const T&t)
    {
         object_.setter_(t);
         return *this;
    }
    
private:
    Class& object_;
    void (Class::* setter_)(const T&);
    const T& (Class::*getter_)() const;
};

the length setter_ and getter_ is depend on compiler and Class. one property object takes 20 bytes, a widget has 10 property objects, a program has 20 widgets, so the program needs more 4000 bytes. it's not cheap. -_-!

Originally Posted by Mad_guy

Is there a reason you have your own custom license for the project instead of just releasing it under the GPL or BSD license (or even public domain)?

I don't like GPL.. -_-! releasing with my own license. refer to http://stdex.sourceforge.net/LICENSE_1_0.txt

I don't like GPL.. -_-! releasing with my own license. refer to http://stdex.sourceforge.net/LICENSE_1_0.txt

While your license appears to comply with the Open Source Definition, it is not OSI approved, and is similiar to the BSD license and perhaps the MIT/Expat license, so why not use an existing OSI approved permissive license?

The reason is that i've not read BSD/MIT license -_-!

Originally Posted by jinhao

I have implemented a generic property template before. like this

Code:

template<typename T, typename Class>
class property
{
    typedef property self_type;
public:
    property(Class& obj, void (Class::* setter)(const T&), const T& (Class::*getter)() const)
        :object_(obj), setter_(setter), getter_(getter)
    {}

    operator T() const
    {
         return object_.getter_();
    }

    self_type& operator=(const T&t)
    {
         object_.setter_(t);
         return *this;
    }
    
private:
    Class& object_;
    void (Class::* setter_)(const T&);
    const T& (Class::*getter_)() const;
};

the length setter_ and getter_ is depend on compiler and Class. one property object takes 20 bytes, a widget has 10 property objects, a program has 20 widgets, so the program needs more 4000 bytes. it's not cheap. -_-!

This can be changed. Let me demonstrate.

Code:

template<typename T, typename Class, void (Class::* setter_)(const T&), const T& (Class::*getter_)() const>
class property
{
    typedef property self_type;
public:
    property(Class& obj)
        :object_(obj)
    {}

    operator T() const
    {
         return object_.getter_();
    }

    self_type& operator=(const T&t)
    {
         object_.setter_(t);
         return *this;
    }
    
private:
    Class& object_;
};

Given, I did not compile and test this, but try it - it should work.
That leaves just 4 bytes overhead.
And mate - 4KB of memory is nothing.

Originally Posted by Elysia

This can be changed. Let me demonstrate.

Code:

template<typename T, typename Class, void (Class::* setter_)(const T&), const T& (Class::*getter_)() const>
class property
{
    typedef property self_type;
public:
    property(Class& obj)
        :object_(obj)
    {}

    operator T() const
    {
         return object_.getter_();
    }

    self_type& operator=(const T&t)
    {
         object_.setter_(t);
         return *this;
    }
    
private:
    Class& object_;
};

Given, I did not compile and test this, but try it - it should work.
That leaves just 4 bytes overhead.
And mate - 4KB of memory is nothing.

this version is too restrictive. the property just can set/get one thing. if it gets/sets caption and how it gets/sets size/position and so on...