C++ Template Function Ambiguity for Wrapper Type Specialization

Question

I have a C++ function template:

#include <string_view>

template<typename T>
T get_gadget(std::string_view str);

I also added explicit specializations for some user-defined types, e.g., GadgetA and GadgetB:

template<>
GadgetA get_gadget<GadgetA>(std::string_view str) {
    // implementation
}

template<>
GadgetB get_gadget<GadgetB>(std::string_view str) {
    // implementation
}

Now, I want to make it work for a Wrapper type like this:

template<typename T>
Wrapper<T> get_gadget(std::string_view str) {
    auto underlying = get_gadget<T>(str);
    // implementation
}

However, when I compile, I get an ambiguous call error. I think this happens because the compiler cannot distinguish between the primary template and the Wrapper specialization.

I would like to solve this using concepts or template metaprogramming, without using void pointers, tag dispatching, or unnecessary boilerplate.

#include <iostream>
#include <string_view>

// Primary template (only declared)
template<typename T>
T get_gadget(std::string_view str);

// --- Some user-defined types ---
struct GadgetA {
    std::string name;
};
struct GadgetB {
    int value;
};

// --- Explicit specializations ---
template<>
GadgetA get_gadget<GadgetA>(std::string_view str) {
    return GadgetA{std::string(str)};
}

template<>
GadgetB get_gadget<GadgetB>(std::string_view str) {
    return GadgetB{static_cast<int>(str.size())};
}

// --- A generic Wrapper ---
template<typename T>
struct Wrapper {
    T inner;
};

// --- Generic overload for Wrapper<T> ---
template<typename T>
Wrapper<T> get_gadget(std::string_view str) {
    auto underlying = get_gadget<T>(str); // delegate
    return Wrapper<T>{underlying};
}

// --- Demo ---
int main() {
    auto a = get_gadget<GadgetA>("HelloA");
    auto b = get_gadget<GadgetB>("HelloB");
    auto wa = get_gadget<Wrapper<GadgetA>>("WrappedA");

    std::cout << "GadgetA: " << a.name << "\n";
    std::cout << "GadgetB: " << b.value << "\n";
    std::cout << "Wrapper<GadgetA>: " << wa.inner.name << "\n";
}

Please post a minimal reproducible example, and also include the compiler error you get, verbatim. — wohlstad
– wohlstad, Commented Sep 10 at 11:33
how do you intend the compiler to pick the template that returns T or the one that returns Wrapper<T> when you call get_gadget<Foo> ? Forget about templates for a moment, then you are trying to overload based on return type alone, which is not possible — 463035818_is_not_an_ai
– 463035818_is_not_an_ai, Commented Sep 10 at 11:37
in other words, its not clear how you want your code to work. You have to clarify that before we can help fix it — 463035818_is_not_an_ai
– 463035818_is_not_an_ai, Commented Sep 10 at 11:37
suppose Wrapper<T> get_gadget(std::string_view str) would work, then auto underlying = get_get_gadget<T>(str); would just recursively call the same function again and again without end — 463035818_is_not_an_ai
– 463035818_is_not_an_ai, Commented Sep 10 at 11:39
If T is GadgetA or GadgetB, then use the specialization. Then if I write get_gadget<Wrapper<Foo>>(str), then this function is called ! — Roger World
– Roger World, Commented Sep 10 at 11:40

HolyBlackCat · Accepted Answer · 2025-09-10 11:36:44Z

11

I'm going to assume that the intended call syntax for last overload is get_gadget<Wrapper<X>>("...") (not get_gadget<X>("..."), which would make no sense, as noted in the comments).

In that case, the T template parameter of that function will be Wrapper<X>, not X.

So you need something like:

template <typename T>
struct WrapperTraits
{
    static constexpr bool is_wrapper = false;
};

template <typename T>
struct WrapperTraits<Wrapper<T>>
{
    static constexpr bool is_wrapper = true;
    using elem_type = T;
};

And then:

template <typename T> requires WrapperTraits<T>::is_wrapper
T get_gadget(std::string_view str)
{
    auto underlying = get_gadget<typename WrapperTraits<T>::elem_type>(str);
    // implementation
}

answered Sep 10 at 11:36

HolyBlackCat

102k13 gold badges182 silver badges306 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

463035818_is_not_an_ai Sep 10 at 11:40

turns out your interpretation is correct. Imho the question still should be clarified

463035818_is_not_an_ai Sep 10 at 11:43

alternatively one could specialize for T= Wrapper<U>. Either way it requires something extra, not sure which is nicer...

HolyBlackCat Sep 10 at 11:51

Specialize what, the function? They can't be partially specialized, only fully specialized.

Roger World Sep 10 at 12:02

Can concepts be used instead of type traits?

HolyBlackCat Sep 10 at 12:06

You can wrap WrapperTraits<T>::is_wrapper in a concept, but the class template isn't going anywhere, the concept would have to call it. The class template could be replaced with a bool variable template, but then you lose elem_type (which could work if Wrapper<T> has a member typedef pointing to T).

463035818_is_not_an_ai Sep 10 at 12:03

oh right .... sorry my confusion

Collectives™ on Stack Overflow

C++ Template Function Ambiguity for Wrapper Type Specialization

1 Answer 1

6 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

6 Comments

Your Answer

Sign up or log in

Post as a guest

Related