C++ correct syntax for triple-nested template parameter - c++

Question

I'm confused why the below code gets rejected by the compiler. Some help please?
template<template<template<class> class> class Ptr,
template<class> class Container, class T>
inline void print(Ptr<Container<T>> l) {
std::cout << '[';
for (auto it = l->begin(); it != l->end() - 1; ++it) {
std::cout << *it << ", ";
}
std::cout << l->back() << ']' << std::endl;
}

Answer 1

I got confused of what works and what not in #RSahu answer and whether it solves the problem in general.
But, inspired by it, I get the following solution. Which simply exploits the fact that the class template class can be variadic. So for example is now compatible with std::vector<T, A> or other classes (containers hopefuly) that have more or less template parameters. In fact it is useful to do the same with the Ptr parameter so it is also compatible with std::unique_ptr that takes more template parameters than std::shared_ptr.
http://coliru.stacked-crooked.com/a/40d43526ed77eb9d
#include <iostream>
#include <vector>
#include <memory>
template<template<class...> class Ptr, template<class...> class Container, class T>
inline void f(Ptr<Container<T>> p) {
std::cout << "bla" << std::endl;
}
int main() {
f(std::make_shared<std::vector<int>>());
}
Note: having said that, I think there are better ways to constrain the argument types than forcing patterns.
For example, this could be an alternative:
template<class PtrContainerT, typename = decltype( std::declval<PtrContainerT>()->back())> //probably pretty much constrains the intended use
inline void f(PtrContainerT&& p) {
using T = typename PtrContainerT::element_type::value_type; //in case you need to know T
std::cout << "bla" << std::endl;
}
http://coliru.stacked-crooked.com/a/fbe43aab94364764
or even more to the point (although not 100% equivalent) :
template<class PtrContainerT, typename T = typename PtrContainerT::element_type::value_type> //probably pretty much constrains the intended use
inline void f(PtrContainerT&& p) {
std::cout << "bla" << std::endl;
}
Use std::decay<PtrContainerT>::...etc if necessary.

Answer 2

I can think of the following two ways to resolve the problem.
template <template <template <class> class> class Ptr,
template<class> class Container, class T>
inline void print(Ptr<Container> l) {
// ^^^ Not Ptr<Container<T>>
std::cout << '[';
for (auto it = l->begin(); it != l->end() - 1; ++it) {
std::cout << *it << ", ";
}
std::cout << l->back() << ']' << std::endl;
}
or
template <template<class> class Ptr,
// One less level of template for Ptr
template<class> class Container, class T>
inline void print(Ptr<Container<T>> l) {
// Containe<T> is a class
std::cout << '[';
for (auto it = l->begin(); it != l->end() - 1; ++it) {
std::cout << *it << ", ";
}
std::cout << l->back() << ']' << std::endl;
}
Looking at your code, it not clear which one will work for you.
Update
The following code does not work
#include <vector>
#include <memory>
template<template<class> class Ptr, template<class> class Container, class T>
inline void f(Ptr<Container<T>> p) {}
int main() {
f(std::make_shared<std::vector<int>>());
}
since std::vector is defined as:
template<
class T,
class Allocator = std::allocator<T>
> class vector;
It is not
template<
class T,
> class vector;
This works:
template<template<class> class Ptr, template<class> class Container, class T>
inline void f(Ptr<Container<T>> p) {}
template <typename T> using MyVector = std::vector<T>;
int main() {
f<std::shared_ptr, MyVector, int>(std::make_shared<MyVector<int>>());
}
This also works:
template<template<class> class Ptr, template<class> class Container, class T>
inline void f(Ptr<Container<T>> p) {}
template <typename T> struct Foo {};
int main() {
f(std::make_shared<Foo<int>>());
}