Is there a way to match a nested template type implicitly in C++?

Question

I have the following MWE:

#include <iostream>
#include <memory>

class A {
public:
    int n = 42;
    typedef std::shared_ptr<A> Ptr;
};

template<typename T>
void foo(typename T::Ptr arg) {
    std::cout << arg->n << std::endl;
}

template<typename T>
void bar(T arg) {
    std::cout << arg.n << std::endl;
}

int main() {
    A::Ptr a = A::Ptr(new A());
    foo<A>(a); // Can I avoid giving <A> here explicitly.
    // foo(a); // does not compile
    bar(*a); // after all this does work
    return 0;
}

To me it looks like it should also be possible to call foo(a) instead of foo<A>(a). Why is this not possible and can I somehow change the definition of foo to make this possible?

I realize that I could just skip the ::Ptr in the signature, but I still want to have access to the A type without the pointer.

score 7 · Accepted Answer · edited May 23 '17 at 12:15

7

That is not possible because that is non-deducible context.

The type of a is just std::shared_ptr<A>, which means if foo(a) works, then the following should also work:

std::shared_ptr<A> x(new A());
foo(x);

If so, then what should T be deduced to — and why? You might be tempted to say "T should be deduced to A, because A has a nested type Ptr which is same as std::shared_ptr<A>". Well, what if there is another class defined as:

struct B
{
    typedef std::shared_ptr<A> Ptr;
};

What should T be deduced to? A or B? or something else?

Here is another topic that discusses non-deducible context using a different example:

C++, template argument can not be deduced

Hope that helps.

edited May 23 '17 at 12:15

Community

1
1

answered Aug 26 '16 at 09:45

Nawaz

353,942
115
666
851

what is a "non-deducible context"? how does it work? where does it apply? – Ven Aug 26 '16 at 09:45
3

@Ven In a nutshell, it applies whenever the compiler has no sane way to deduce the parameter which remains sane in the presence of corner cases and an unbounded set of types and values. For a more formal treatment, refer to chapter 14 of the C++ standard. – Angew is no longer proud of SO Aug 26 '16 at 09:56
@Angew I just wanted a more complete answer than the one-line. – Ven Aug 26 '16 at 10:24

songyuanyao · Answer 2 · 2016-08-26T10:31:54.833

Nawaz's answer has explained why the code doesn't work, I'll focus on this question:

but I still want to have access to the A type without the pointer.

std::shared_ptr has a member type element_type, you could use it like typename T::element_type. And if you want the code works well with raw pointer too, you could provide a trait class template:

template <typename T>
struct trait_element_type {
    using element_type = std::remove_pointer_t<T>;
};

template <typename T>
struct trait_element_type<std::shared_ptr<T>> {
    using element_type = T;
};

And then use it as:

template<typename T>
void foo(T arg) {

    std::cout << arg->n << std::endl;

    typename trait_element_type<T>::element_type x; // retrieve the element type
    std::cout << x.n << std::endl;
}

LIVE

In the specialization, it could be just `using element_type = T;` instead of `using element_type = typename std::shared_ptr::element_type;`. — Nawaz, Aug 26 '16 at 10:29

Is there a way to match a nested template type implicitly in C++?

2 Answers2