Чего-то я сегодня разошелся

Был вот такой шаблон

template<class T>
inline t_numeric_limits<T> get_numeric_limits(T /*x*/)
{
 //это типа аналог std::numeric_limits
 return t_numeric_limits<T>();
}//get_numeric_limits

Замечательная вещь, для получения нижних/верхних границ переменных по их типам.

Сегодня понадобилось получить такие сведения для члена структуры. Типа что-то вроде

struct TData {int n};

//...
TData* p=NULL;

//...
cout<<get_numeric_limits(p->n).max_value();

Фигня в том, что p может так и остатья NULL-ом. Что приводит к AV. После небольшого тыкания, я переписал функцию так

template<class T>
inline t_numeric_limits<T> get_numeric_limits(const T& /*x*/)
{
 //это типа аналог std::numeric_limits
 return t_numeric_limits<T>();
}//get_numeric_limits

Все стало так, как хотел. Но появился червь сомнения — о простоте решения

Но ведь, в конечном итоге — sizeof(p->n) тоже не падает.

Что скажете по этому поводу?

Здравствуйте, Коваленко Дмитрий, Вы писали:

КД>cout<<get_numeric_limits(p->n).max_value();
КД>Фигня в том, что p может так и остатья NULL-ом.

template <class C, class I>
inline t_numeric_limits<T> get_numeric_limits(I C::*)
{
    return t_numeric_limits<I>();
}

std::cout << get_numeric_limits(&Data::n).max_value();

Здравствуйте, Roman Odaisky, Вы писали:

template <class C, class I>
inline t_numeric_limits<T> get_numeric_limits(I C::*)

"Моя в дауне"

Здравствуйте, Roman Odaisky, Вы писали:

RO>std::cout << get_numeric_limits(&Data::n).max_value();
А почему это должно компилироваться, ведь Data::n — не статический мембер?

Здравствуйте, Vain, Вы писали:

V>Здравствуйте, Roman Odaisky, Вы писали:

RO>>std::cout << get_numeric_limits(&Data::n).max_value();
V>А почему это должно компилироваться, ведь Data::n — не статический мембер?

Результатом выражения &Data::n является особый тип указателя — указатель на член. Такой указатель можно использовать в комбинации с каким-либо объектом типа Data:

#include <iostream>

struct Data
{
    int l;
    int m;
    int n;
};

int main()
{
    Data data = {1, 2, 3};
    
    int Data::*pointer_to_member;

    pointer_to_member = &Data::l;
    std::cout << data.*pointer_to_member << std::endl; //Output: 1

    pointer_to_member = &Data::m;
    std::cout << data.*pointer_to_member << std::endl; //Output: 2

    pointer_to_member = &Data::n;
    std::cout << data.*pointer_to_member << std::endl; //Output: 3
}

Здравствуйте, Vain, Вы писали:

RO>>std::cout << get_numeric_limits(&Data::n).max_value();
V>А почему это должно компилироваться, ведь Data::n — не статический мембер?

&Data::n — это указатель на член, RTFM.

struct x
{
    int a, b;
    x(): a(), b()
    {
    }
};

typedef int x::*field_t;

int main()
{
    x ab;
    field_t p = &x::a;
    ab.*p = 4;
    p = &x::b;
    ab.*p = 2;
    std::cout << ab.a << ab.b << std::endl;
}

Здравствуйте, Roman Odaisky, Вы писали:

RO>>>std::cout << get_numeric_limits(&Data::n).max_value();
V>>А почему это должно компилироваться, ведь Data::n — не статический мембер?
RO>&Data::n — это указатель на член, RTFM.
Я знал что это указатель на член и что это такое, просто не знал что он может именно так получаться.

Здравствуйте, Roman Odaisky, Вы писали:

template <class C, class I>
inline t_numeric_limits<T> get_numeric_limits(I C::*)

КД>"Моя в дауне"

Хотя, в прочем, мой промежуточный вариант тоже заключался в том, что бы передавать по указателю. Правда без претензий. Типа

get_numeric_limits_for_ptr(const T* ptr)

Но потом, созерцая get_numeric_limits и get_numeric_limits_for_ptr, решил что ссылка будет не хуже. На ней и остановился