template of template c++?

Question

i've managed to create some preperty class with all the thing we expect from one. I mean when using it you don't need to call functions just using operator = will do all the work. but there is only one thing I guess it would be nice if we could resolve :

template <class T, class X,void (T::*setFunc)(const X&),const X& (T::*getFunc)()const> class property
{ 
    T* const owner;
    X data;
    friend T;
    property(T*const  pOwner) : owner (pOwner)
    {
    }
public:
    property& operator = (const X& input){(owner->*setFunc)(input);return *this;}
    operator const X&()const {return (owner->*getFunc)();}
};

struct c
{
protected:
    void setInt(const int& data);
    const int& getInt() const;
public:
    c();
    property<c, int ,&setInt,&getInt> myInt;
};

c::c() : myInt(this)
{
}

void c::setInt(const int& data)
{
    myInt.data = data;
}
const int& c::getInt() const
{
    return myInt.data;
}

see class property has 4 arguments and the first argument is the class type itself. I'd like to know if we could possibly do anything to extract class type from two function pointers property needs. somwthing like property <int, &setInt, &getInt> myInt;.

do you know any way to eliminate first template parameter?

Answer 1

If you'd like to omit specifying the type parameters explicitly, the following code will meet the purpose. However, this code requires VC2010.

template <class> struct class_type;
template <class C, class T> struct class_type< T(C::*) > { typedef C type; };

template <class> struct param_type;
template <class C, class T> struct param_type< void(C::*)(const T&) > {
    typedef T type;
};

template <class S, S setFunc, class G, G getFunc> struct property {
    typedef typename class_type<S>::type T;
    typedef typename param_type<S>::type X;
    T* const owner;
    X data;
    ....
};

#define PROPERTY(set, get) property<decltype(&set), &set, decltype(&get), &get>

struct c {
    void setInt(const int& data);
    const int& getInt() const;
    PROPERTY(setInt, getInt) myInt;
};

Incidentally, MSVC has its own property. Probably this is easier if it serves the purpose.

Answer 2

Success at last! http://ideone.com/XJ7of

This slightly better version works only on Comeau (not sure whether Comeau or gcc is correct, but gcc complains about the friend designation).

#include <iostream>
#include <typeinfo>

template <class T, class X,void (T::type::*setFunc)(const typename X::type&),const typename X::type& (T::type::*getFunc)()const> class property_impl
{ 
    typename T::type* const owner;
    friend typename T::type;
    property_impl(typename T::type* const pOwner) : owner (pOwner)
    {
    }
public:
    property_impl& operator = (const typename X::type& input){(owner->*setFunc)(input); return *this;}
    operator const typename X::type&()const {return (owner->*getFunc)();}
};

template<typename T> struct identity { typedef T type; };

template<typename Arg, typename T>
identity<T> match_memfn_classtype( void (T::*fn)(Arg) );

template<typename Arg, typename T>
identity<Arg> match_memfn_argtype( void (T::*fn)(Arg) );

#define property(setter,getter) property_impl<decltype(match_memfn_classtype(setter)), decltype(match_memfn_argtype(setter)), setter, getter>

struct C
{
private:
    int hiddenData;
protected:
    void setInt(const int& data) { hiddenData = data; std::cout << "setter used\n"; }
    const int& getInt() const { std::cout << "getter used\n"; return hiddenData; }
public:
    C() : myInt(this), hiddenData(5) {}
    property(&C::setInt,&C::getInt) myInt;
};

int main(void)
{
    C c;
    std::cout << "c.myInt = " << c.myInt << '\n';
    c.myInt = -1;
    std::cout << "c.myInt = " << c.myInt << '\n';
    return 0;
}

And VC++ 2010 chokes on all variations, although it does work for very simple use of match_memfn_classtype.

Bug report filed (please upvote):

C++ compiler loses member-ness of pointer-to-member-function during template deduction, causes ICE

---

Microsoft updated the bug report to say they've figured out a fix.

Answer 3

I'd like to know if we could possibly do anything to extract class type from two function pointers property needs.

Not really. There's no way to know what the class type of a member pointer is, even with metaprogramming type traits.

Oh, and those are member pointers, not function pointers. They're not the same thing.

Answer 4

If removing template parameters is what you need, then you can do that, but not by removing the first template parameter. What you can do is remove the method pointer template parameters, because those are truly not needed. The code below compiled with gcc with no problems, it's a simplified version of you need but you can see what can be done with it:

template<class T, class X> class Foo {
public:
    typedef const X& (T::*GetterFunc)() const;
    typedef void (T::*SetterFunc)(const X&);
    Foo(T* instance, GetterFunc getter, SetterFunc setter):
        _owner(instance), _getter(getter), _setter(setter) { }

    T* _owner;
    GetterFunc _getter;
    SetterFunc _setter;

};

class FooBar {
};

class Bar {
public:
    Bar(FooBar& foobar):_foobar(foobar) { }
    const FooBar& get() const { return _foobar; }
    void set(const FooBar& foobar) { _foobar = foobar; }
    FooBar _foobar;
};


int main() {
    FooBar foobar;
    Bar bar(foobar);
    Foo<Bar, FooBar> foo(&bar, &Bar::get, &Bar::set);
    return 0;
}