Использовать разные наборы функций на основе параметров шаблона (черты C ++?) - PullRequest
Новая
       4

Использовать разные наборы функций на основе параметров шаблона (черты C ++?)

1 голос
/ 07 августа 2010

Я определил класс в C ++, который содержит массив скаляров типа T, для которого я хочу определить такие операторы, как sin, cos и т. Д. Для определения значения sin, примененного к объекту этого класса Мне нужно знать значение sin, примененного к единственному скалярному типу T. Это означает, что мне нужно использовать соответствующие математические библиотеки (соответствующие скалярному типу T) внутри класса. Вот код, как сейчас: 

template<class T>
class MyType<T>
{
    private:
        std::vector<T> list;

    // ...

        template<class U> friend const UTP<U> sin(const UTP<U>& a);
        template<class U> friend const UTP<U> cos(const UTP<U>& a);
        template<class U> friend const UTP<U> tan(const UTP<U>& a);

    //...
};

template<class T> const UTP<T> sin(const UTP<T>& a)
{
   // use the sin(..) appropriate for type T here 
   // if T were double I want to use double std::sin(double)
   // if T were BigNum I want to use BigNum somelib::bigtype::sin(BigNum)
}

В настоящее время у меня есть код, который предоставляет соответствующую математическую библиотеку (используя пространство имен std;), а затем использую ::sin(a) внутри функции sin для моего класса MyType. Хотя это работает, это похоже на серьезный взлом.

Я вижу, что черты C ++ можно использовать для хранения информации, специфичной для экземпляра (например, какой набор математических функций использовать, когда T равен double, когда T равен BigNum и т. Д.)

Я хочу сделать что-то вроде этого: (Я знаю, что это не компилируется, но я надеюсь, что это передает то, что я хочу сделать) 

template<T>
struct MyType_traits {
};

template<>
struct MyType_traits<double> {
    namespace math = std;
};

template<>
struct MyType_traits<BigNum> {
    namespace math = somelib::bigtype;
};

и затем переопределить мой класс MyType как: 

template<T, traits = MyType_traits<T> >
class MyType
{
// ...
}

и затем используйте traits::math::sin в функции моего друга. Есть ли способ, которым я могу получить правильное пространство имен (параметризованное T), содержащее математические функции?

Ответы [ 3 ]

5 голосов
/ 07 августа 2010

Разве поиск по аргументам не достаточно хорош? 

#include <cmath>
#include <iostream>

namespace xxx {
class X
{
};

X sin(X) { return X(); }
} //xxx

std::ostream& operator<< (std::ostream& os, xxx::X)
{
    return os << "X";
}

template <class T>
void use_sin(T t)
{
    using std::sin; //primitive types are not in a namespace,
                    //and with some implementation sin(double) etc might not be available
                    //in global namespace
    std::cout << sin(t) << '\n';
}

int main()
{
    use_sin(1.0);
    use_sin(xxx::X());
}

Это будет работать для X, потому что sin(X) определено в том же пространстве имен, что и X. Если вы ожидаете, что это не тактак что, вероятно, это не поможет ...

0 голосов
/ 08 августа 2010

Я включил этот ответ, потому что мне наконец-то удалось получить то, что я хочу (с помощью очень милого фолка на ## c ++ на irc.freenode.net). Этот метод позволяет как ADL, так и статическому набору мест (xxx :: math) искать определение математических функций.

Таким образом, если параметр типа T класса Test таков:

  1. если T определяет математические функции как члены, то мы можем использовать ADL и не трогать (добавлять) пространство имен xxx :: math.
  2. если T не определяет математические функции как члены, но использует функции из определенного пространства имен, тогда мы можем добавить в пространство имен xxx :: math, как в примере ниже.

Библиотека выглядит так: 

#include <vector>
#include <cmath>

namespace xxx {

// include the usual math
namespace math {
    using std::asin;
}

template <class T>
class Test
{
    std::vector<T> array;

    public:
    Test(const typename std::vector<T>::size_type length)
    {
        assert(length >= 1);
        array.assign(length, T(0.0));
    }
    friend std::ostream& operator<<(std::ostream& out, const Test<T>& a)
    {
        out << "(";
        std::copy(a.array.begin(), a.array.end(), std::ostream_iterator<T>(out, ", "));
        out << "\b\b)";
        return out;
    }

    template<class U> friend const Test<U> asin(const Test<U>& a);
};

template<class U> const Test<U> asin(const Test<U>& a)
{
    using math::asin;

    Test<U> ret(a.array.size());
    for (typename std::vector<U>::size_type i = 0; i < a.array.size(); ++i) 
        ret.array[i] = asin(a.array[i]);

    // note how we use have a using math::asin; and then a call to asin(..) here,
    // instead of a math::asin(..). This allows for ADL.

    return ret;
}

} // xxx

Клиент выглядит так: 

#include <iostream>
#include <boost/math/complex.hpp>

// client, with some foresight, includes complex math
namespace xxx { namespace math {
    using boost::math::asin;
} }

#include "test.h"

// demo
int main(int argc, char **argv)
{
    using std::cout; using std::endl;

    xxx::Test<double> atest(3);
    cout << "atest: " <<  atest << endl;
    cout << "asin(atest): " <<  asin(atest) << endl;
    cout << endl;

    xxx::Test<std::complex<double> > btest(3);
    cout << "btest: " <<  btest << endl;
    cout << "asin(btest): " <<  asin(btest) << endl;
    cout << endl;

    return 0;
}
0 голосов
/ 07 августа 2010

Это не конкретный ответ, который вы ищете, но не проще ли использовать специализацию шаблонов?

Как в ... 

template <typename T> T sin(T& t)
{
    // does nothing
}

template <> float sin(float& t)
{
    ...
}

template <> double sin(double& t)
{
    ...
}

И так далее?

...