我可以为缺少的模板成员类型创建默认类型吗？

Question

If I have an algorithm with template parameters, something like

struct DemoParameters
{
    typedef float Price;
    typedef std :: list <Price> Prices;
}

template <typename Parameters>
void foo (int arg)
{
    typename Parameters :: Prices prices = ...;
    // blah
}

foo <DemoParameters> (123);

Is there a way I can write foo so that if something is missing from Parameters I can supply a default. For example

struct PartialParameters
{
     typedef float Price;
     // Prices is missing
}

template <typename Parameters>
void foo (int arg)
{
    Prices_type<Parameters>::type prices = ...;
}

foo<DemoParameters>    (123); // will use list<Price>
foo<PartialParameters> (123); // will use vector<Price>

Where Prices_type<Parameters>::type is Parameters::Prices if Prices is a member of Parameters , or std::vector<Parameters::Price> otherwise.

Is this possible?

Answer 1

This is named SFINAE :

#include <iostream>

struct Foo {
    using Type = int;
};
struct Bar {
};

template <typename T, typename Default >
struct TypeOrDefault {
    template <typename U>
    static auto call( int ) -> typename U::Type;

    template <typename U>
    static auto call(...) -> Default;

    using type = decltype( call<T>( 1 ) );
};

int main() {
    std::cout << std::is_same<int,typename TypeOrDefault<Foo,float>::type > ::value << std::endl;
    std::cout << std::is_same<int,typename TypeOrDefault<Bar,float>::type > ::value << std::endl;
}

The example above give to the type type member of TypeOrDefault int for Foo and float for Bar.

you can also simplify the syntax on use with a template alias.

template < typename T, typename Default >
using TypeOrDefaultType = typename TypeOrDefault<T,Default>::type;

then

int main() {
        std::cout << std::is_same<int,TypeOrDefaultType<Foo,float> > ::value << std::endl;
        std::cout << std::is_same<int,TypeOrDefaultType<Bar,float> > ::value << std::endl;
    }

Answer 2

You may do something like this (Tag dispatching and SFINAE):

template <typename T> struct has_Prices
{
private:
    template <typename U> static std::uint8_t check(typename U::Prices*);
    template <typename U> static std::uint16_t check(...);
public:
    static const bool value = sizeof(check<T>(0)) == sizeof(std::uint8_t);
};

template <typename T, bool = has_Prices<T>::value> struct Prices_type;

template <typename T>
struct Prices_type<T, true>
{
    typedef typename T::Prices type;
};

template <typename T, bool>
struct Prices_type
{
    typedef std::vector<typename T::Price> type;
};

Test it:

struct DemoParameters
{
    typedef float Price;
    typedef std :: list <Price> Prices;
};

struct PartialParameters
{
     typedef float Price;
     // Prices is missing
};

static_assert(std::is_same<std::list<float>, Prices_type<DemoParameters>::type>::value, "");
static_assert(std::is_same<std::vector<float>, Prices_type<PartialParameters>::type>::value, "");