类特化，没有用作特化模板参数的类的模板参数

Question

I currently work on a geo library, and I want to have a general-purpose vector class that can be used for lat/lng points, and projected points.

The direction for lat/lng points ist described by bearing and a length and the one in the projected space by a 2d vector and a length.

So the class should look like:

template <typename T>
struct vector {
    direction_t direction;
    lenght_t length;
};

The lat/lng point is defined as:

template <angle_unit T>
struct latlng {
  …
};

And the point is defined as:

template <typename projection_t,typename T = double>
struct point {
   …
};

So my initial idea was to define direction_t as direction_trait<T>::direction_type direction :

template <typename T>
struct vector {
    using direction_t = direction_trait<T>::direction_type;

    direction_t direction;
    lenght_t length;
};

And have a specialization of direction_trait for both latlng and point , without the need to define the specialization for each of the possible template parameters for latlng and point .

How can I have something like:

template <typename T>
struct direction_trait;


template <latlng>
struct direction_trait {
    using direction_t = double;
};

I don't want to add info that are related to the direction to the header where latlng or point is defined.

(I already figured out a way how to solve it while I was writing the question, but if there is a more elegant way how to solve that problem, without that helper class I would be happy to know it)

Answer 1

The following works as you wish:

#include <type_traits> // only for is_same_v in the tests

using angle_unit = int; // just so it compiled
template <angle_unit T>
struct latlng {
};

template <typename projection_t, typename T = double>
struct point {
};

template<typename T>
struct direction_trait;

template<angle_unit T>
struct direction_trait<latlng<T>> {
    using direction_type = double;
};

template<typename projection_t, typename T>
struct direction_trait<point<projection_t, T>> {
    using direction_type = T; // Or whatever you want
};

template <typename T>
struct vector {
    using direction_t = typename direction_trait<T>::direction_type;

    direction_t direction;
};

// Usage
static_assert(std::is_same_v<vector<latlng<5>>::direction_t, int>);
static_assert(std::is_same_v<vector<point<long>>::direction_t, double>);
static_assert(std::is_same_v<vector<point<long, float>>::direction_t, float>);

Answer 2

The solution I came up with is the following, to use a declaration of a class that is solely used for the specialization, and a reference to that class to the class body of latlng (point), using using trait = latlng_trait; . This alias is then used by the vector the get the direction type.

The latlng class:

struct latlng_trait; // a declaration of a class solely used for template specialization

template <angle_unit T>
struct latlng {
    using trait = latlng_trait;

    …
}

The specialization for latlng:

template <>
struct direction_trait<latlng_trait> {
    using direction_t = double;
};

The vector:

template <typename T>
struct vector {
    typename direction_trait<typename T::trait>::direction_t direction;
};