Возможно ли реализовать стратегии оптимальных аргументов для функций?

[_Bers]

Вопрос: как сделать так, что бы в зависимости от типа входящего аргумента, изменялся прототип принимающей его функции на оптимальный вариант?

template<class T>struct TOpt     { typedef T& Result; };
template<class T>struct TOpt<T&> { typedef T& Result; };
template<class T>struct TOpt<const T> { typedef const T& Result;  };
template<class T>struct TOpt<const T&>{ typedef const T& Result; };


template<class T>
void Foo( typename TOpt<T>::Result arg )
{

}

int main()
{
    int a=0;

    Foo(a);  //: error C2783: void Foo(TOpt<T>::Result): не удается составить аргумент шаблон для "T"

    return 0;
}

Задача - избежать конструкторов копий. Использование вида: Foo(a);

Делать явный инстанс вида Foo<int&>(a); нельзя.

[waleri]

Сделать специализацию шаблона для всех примитивных типов (ибо их количество ограничено). Шаблон сам по себе унаследовать от другого шаблона, который и будет имплементацией

[_Bers]

Сообщение от waleri

Сделать специализацию шаблона для всех примитивных типов (ибо их количество ограничено). Шаблон сам по себе унаследовать от другого шаблона, который и будет имплементацией

Ничего не понял. Какое наследование?

Речь идет о генерации типов аргументов в прототипах функций, а зависимости от типа вошедших аргументов.

[waleri]

O, только сейчас заметил, что речь идет от функциях - тогда еще легче:

template <typename type>
void TImplement(type arg)
{
}

template <typename type>
void TFunction(const type& ref)
{
    TImplement(ref);
}

template <typename type>
void TFunction(type& ref)
{
    TImplement(ref);
}

void TFunction(int var)
{
    TImplement(var);
}

[_Bers]

Сообщение от waleri

O, только сейчас заметил, что речь идет от функциях - тогда еще легче:

template <typename type>
void TImplement(type arg)
{
}

template <typename type>
void TFunction(const type& ref)
{
    TImplement(ref);
}

template <typename type>
void TFunction(type& ref)
{
    TImplement(ref);
}

void TFunction(int var)
{
    TImplement(var);
}

Теперь все тоже самое, только функция принимает 10ть аргументов.
Любой из них может быть константным, или не константным объектом. Простым, или тяжелым.

Ещё раз: речь идет о генерации типа аргумента в прототипе функции, в зависимости от типа вошедшего аргумента.

[_Bers]

А, все... нашел лекарство)

[waleri]

Ну так покажите

template <typename type> class TArgument
{
public:
    TArgument(const type& )     { }
};
template <>
class TArgument<int> 
{
public:
    TArgument(int)              { }
};

template <typename t0, typename t1>
void TImplement(TArgument<t0> a0, TArgument<t1> a1)
{
}

template <typename t0, typename t1>
inline void TFunction(t0 a0, t1 a1)
{
    TImplement(TArgument<t0>(a0), TArgument<t1>(a1));
}

[_Bers]

Сообщение от waleri

template <typename t0, typename t1>
inline void TFunction(t0 a0, t1 a1)
{
    TImplement(TArgument<t0>(a0), TArgument<t1>(a1));
}

Вы считаете, что таким образом можно избежать копирования тяжелых объектов?

[_Bers]

[QUOTE=waleri;1082487]Ну так покажите

Способ не без изъяна..

struct SOpt
{
    template<class T>
    SOpt(T& a) { cout<< "SOpt(T& a)\n"; }

    template<class T>
    SOpt(const T& a) { cout<< "SOpt(const T& a)\n"; }
};


void Foo( SOpt arg )
{

}

using namespace Den;
int main()
{
    Foo(10);
    return 0;
}

Мне нужно сохранить информацию о типах.. А тут она теряется. Нужно что то другое

[waleri]

Ну тогда так... добрый старый препроцессор:

template <typename type>
class TArgument
{
public:
    TArgument(type)
    {
    }
};

template <typename type>
TArgument<const type&> TGetArgument(const type& arg)
{
    return arg;
}
TArgument<int> TGetArgument(int val)
{
    return val;
}

template <typename type1, typename type2>
void TFunction(type1 a1, type2 a2)
{
}
#define TFunction(a, b)    TFunction(TGetArgument(a), TGetArgument(b))