Внутренний typedef изменяется в зависимости от родительского класса

Я сдаюсь, пожалуйста, помогите объяснить это поведение. Пример, представленный ниже, является самым простым, о котором я мог подумать, но он суммирует проблему (используя g++ 4.9.2 в Cygwin с включенным С++ 14). Я хочу создать класс, который будет вести себя аналогично std::mem_fn. Вот мой класс:

template <class R, class T, R(T::*P)() const >
struct property {

    static R get(const T& t) {
        return (t.*P)();
    }
};

где R - тип возврата, а T - тип объекта, в котором я интересен. Третий параметр шаблона - это указатель на функцию-член. Пока что так хорошо.

Затем я создаю простой класс, который содержит целое число следующим образом

class data_class {

public:

    unsigned get_data() const {
        return m_data;
    }

private:
    unsigned m_data;
};

Это класс, который будет использоваться в классе property, показанном ранее.

Теперь я создаю два класса, которые наследуют от data_class следующим образом

struct my_classA
: public data_class {

    using data = property<unsigned, data_class, &data_class::get_data>;
};

//same as my_classA, only templated
template <int I>
struct my_classB
: public data_class {

    using data = property<unsigned, data_class, &data_class::get_data>;
};

Они имеют то же самое внутреннее typedef, но my_classB является шаблоном. Теперь следующие теории теоретически должны быть одинаковыми:

using target_t = property<unsigned, data_class, &data_class::get_data>;
using test1_t = typename my_classA::data;
using test2_t = typename my_classB<1>::data;

Однако мой компилятор говорит, что только test1_t и target_t совпадают. Тип, выведенный для test2_t, по-видимому,

property<unsigned int, data_class, (& data_class::get_data)> >

где этот тип имеет эти скобки вокруг указателя на функцию-член. Почему test2_t не совпадает с target_t? Вот полный код, если вы хотите попробовать его в своей системе. Любая помощь очень ценится.

#include <type_traits>

class data_class {

public:

    unsigned get_data() const {
        return m_data;
    }

private:
    unsigned m_data;
};

//takes return type, class type, and a pointer to member function
//the get function takes an object as argument and uses the above pointer to call the member function
template <class R, class T, R(T::*P)() const >
struct property {

    static R get(const T& t) {
        return (t.*P)();
    }
};

struct my_classA
: public data_class {

    using data = property<unsigned, data_class, &data_class::get_data>;
};

//same as my_classA, only templated
template <int I>
struct my_classB
: public data_class {

    using data = property<unsigned, data_class, &data_class::get_data>;
};

//used to produce informative errors
template <class T>
struct what_is;

//all 3 types below should, in theory, be the same
//but g++ says that test2_t is different
using target_t = property<unsigned, data_class, &data_class::get_data>;
using test1_t = typename my_classA::data;
using test2_t = typename my_classB<1>::data;

static_assert(std::is_same<target_t, test1_t>::value, ""); //this passes
static_assert(std::is_same<target_t, test2_t>::value, ""); //this does not

int main() {

    what_is<test1_t> t1;
    what_is<test2_t> t2;
}

Ответ 1

Я запустил ваш код с помощью С++ 11, потому что я еще не знаком с С++ 14. Но все, что я заменил, было использование (aliases) с typedefs и немного упростило код. Ничего не влияет на его выход.

Я получил желаемые результаты, добавив имя типа T в наследуемый шаблон класса B, который при создании экземпляра заменит R на T, поэтому в этом случае "unsigned".

#include <iostream>
#include <type_traits>

template <typename R, typename T, R(T::*P)() const>
struct property
{
    static R get(const T& t)
    {
        return (t.*P)();
    }
};


struct data_class
{
    private:
        unsigned m_data;

    public:
        unsigned get_data() const
        {
            return m_data;
        }
};

struct my_classA : public data_class
{
    typedef property<unsigned, data_class, &data_class::get_data> data;
};

template <typename T, int>
struct my_classB : public data_class
{
    typedef property<T, data_class, &data_class::get_data> data;
};


int main()
{

    typedef typename my_classA::data normClassA;
    typedef typename my_classB<unsigned,1>::data tmplClassB;

    std::cout<< std::is_same< property<unsigned, data_class, &data_class::get_data> , normClassA >::value <<std::endl;
    std::cout<< std::is_same< property<unsigned, data_class, &data_class::get_data> , tmplClassB >::value <<std::endl;

}

В результате получится следующее:

~$g++ -std=c++11 test.cpp
~$./a.out 
1
1

Я думаю, что проблема связана с критериями создания экземпляра класса, потому что, когда я изначально пытался напечатать sizeof двух классов, my_classA:: data возвратил 1, но my_classB < 1 > :: data закончил ошибку компилятора, Я все еще неясен, почему это происходит. Технически это должно было создать экземпляр шаблона класса просто отлично. Возможно, это свойство внутри шаблона класса B было ложно создано. Я посмотрю больше на это, но если вы найдете ответ, отправьте его. Это интересно!

EDIT: Исходный код отлично работает на Cygwin GCC 4.8.2. Результат равен 1 и 1. Возможно, это просто проблема компилятора gcc4.9.2.