How to deduce the type of template argument based on some conditions and return information about that type

Suppose I have a class C that has holds a std::variant<A, B>. The constructor of C must be a templated constructor that can accept any type, and based on that type it must initialize the variant in different ways.

Here is a simplified overview:

struct A {
    // ...
};

struct B {
    // ...
};

class C {
    public:
        template <typename T>
        C(T arg) {
            if constexpr (std::same_v<B, T>) {
                var = B{arg};
            }
            else if constexpr (std::is_constructible<A, T>) {
                var = A{arg};
            }
        }

    private:
        std::variant<A, B> var;
};

I am looking for a way to squash these if constexpr statements by using some template metaprogramming magic, so I may rewrite the constructor like this (hoping to avoid the extra initialization of the variant):

template<T>
struct DeduceAOrB {
  // ..... somehow check the conditions here 
};

template <typename T>
        C(T arg)
            : var(DeduceAOrB<T>::type{arg})
        {}

Important note is that the variant may need to be expanded in the future, so the solution must be viable for arbitrarily many types

One way is to create a helper function containing the conditions and use it in initializer list as shown below:

class C {
    private:
        //helper function checking for different conditions and returning based on result
        template<typename T>
        static constexpr auto helperFunc(T arg)
        {
            if constexpr (std::is_same_v<B, T>) {
                        return B{arg};
            }
            else if constexpr (std::is_constructible_v<A, T>) {
                        return A{arg};
            } else {
                        return A{};
            }
        }
    public:
        template <typename T>
//----------------VVV------------------>use helperFunc initializer list
        C(T arg): var(helperFunc(arg)){
            
            
        }

    private:
        std::variant<A, B> var;
};

> I am looking for a way to squash these if constexpr statements by using some template metaprogramming magic

std::conditional was created for cases like this. It's type will be one of two supplied types depending on the supplied condition:

std::conditional_t<boolean,
                   true-type,
                   false-type>

and you can of course nest them with as many conditions as you'd like, which will be needed in this case:

std::conditional_t<boolean1,
                   true-type1,
std::conditional_t<boolean2,
                   true-type2,
                   false-type>>

DeduceAOrB could therefore be defined as such:

template<class T>
using DeduceAOrB = 
std::conditional_t<std::is_same_v<B, std::remove_cv_t<std::remove_reference_t<T>>>,
    B,
std::conditional_t<std::is_constructible_v<A, T>,
    A,
    defaulter<A>>>;

Your current constructor using if constexpr could then be rewritten like so:

template <class T>
C(T&& arg) : var{DeduceAOrB<T>{std::forward<T>(arg)}} {}

It uses the exact same logic as you use in your constructor:

• if std::is_same_v<B, T> - construct a B from arg, else
• if std::is_constructible_v<A, T> - construct an A from arg, else
• default construct an A

The defaulter class template is used to create a type that can be constructed from any arguments and is implicitly convertible to T, which is used to default construct an A in case both conditions fails.

template <class T>
struct defaulter {
    template <class... Args> defaulter(Args&&...) {}
    operator T() const { return T{}; }
};

Full demo

If this is a one time thing, you can use lambda as shown below. Otherwise you can create a helper function.

class C {
    public:
        template <typename T>
//--------------v-------------------->use constructor initializer list
        C(T arg): var([&](){
            if constexpr (std::is_same_v<B, T>) {
                return B{arg};
            }
            else if constexpr (std::is_constructible_v<A, T>) {
                return A{arg};
            }}()) {
            
        }

    private:
        std::variant<A, B> var;
};

This is a candidate for std::type_identity as a wrapper for types:

template<class T>
struct DeduceAOrB : decltype([]
    {
        if constexpr (std::same_v<B, T>) {
            return std::type_identity<B>();
        } else if constexpr (std::is_constructible<A, T>) {
            return std::type_identity<A>();
        }
    }()) {
    // 'type' alias inherited from 'std::type_identity' base class
};

You can even inline this decision, should you want to:

class C {
    public:
        template <typename T>
        C(T arg) : var(typename decltype([&]
        {
            if constexpr (std::same_v<B, T>) {
                return std::type_identity<B>();
            } else if constexpr (std::is_constructible<A, T>) {
                return std::type_identity<A>();
            }
        }())::type{arg}) {
        }

    private:
        std::variant<A, B> var;
};