Different behavior needed if template template parameter is vector - c++

Question

We are using one internal c++ library that takes std::vector as input however i want to write wrapper function that should be able to accept std::vector, std::set or std::unordered_set but when input passed to this wrapper function is std::vector itself i don't want to copy that in temporary vector so is there any way to avoid this unnecessary copy.
Sample Reference code will explain this issue with more clarity :
#include <iostream>
#include <set>
#include <vector>
#include <unordered_set>
void print(const std::vector<int>& argVec)
{
for(auto elem:argVec)
{
std::cout<<elem<<std::endl;
}
}
template<template<typename...>class VecOrSet>
void wrapper(const VecOrSet<int>& input)
{
//How to avoid this temporary vector if input argument is vector itself
std::vector<int> temp(input.begin(),input.end());
print(temp);
}
int main()
{
std::vector<int> v{1,2,3};
std::set<int> s{4,5,6};
std::unordered_set<int> us{7,8,9};
wrapper(v);
wrapper(s);
wrapper(us);
return 0;
}

Answer 1

You can add a full specialization.
template<>
void wrapper(const std::vector<int>& input)
{
print(input);
}
Or just add another overload.
void wrapper(const std::vector<int>& input)
{
print(input);
}
Or use constexpr if (since C++17).
template<template<typename...>class VecOrSet>
void wrapper(const VecOrSet<int>& input)
{
if constexpr (std::is_same_v<VecOrSet<int>, std::vector<int>>) {
print(input);
} else {
std::vector<int> temp(input.begin(),input.end());
print(temp);
}
}

Answer 2

Another solution could be initialize temp passing through another function: getIntVect(), with a generic version
template <typename VoS>
std::vector<int> getIntVect (VoS const & input)
{ return { input.cbegin(), input.cend() }; }
that copy the input in a std::vector<int>, and a specific version for std::version<int>
std::vector<int> const & getIntVect (std::vector<int> const & input)
{ return input; }
that return a const-reference to the input (that is: avoid the copy)
So, using decltype(auto),
template<template<typename...>class VecOrSet>
void wrapper(const VecOrSet<int>& input)
{
decltype(auto) temp { getIntVect(input) };
print( temp );
}
temp is a reference to input, when VecOrSet is std::vector, or a copy of input, otherwise.
-- EDIT --
The OP is dubious
I think this line decltype(auto) temp{getIntVect(input)}; will call copy constructor of vector if input is vector
This is true for auto temp{getIntVect(input)};, as pointed by T.C. (thanks!). Not for decltype(auto) temp{getIntVect(input)};
Try compiling and running the following code
#include <iostream>
struct A
{
A ()
{ std::cout << "- default constructor" << std::endl; }
A (A const &)
{ std::cout << "- copy constructor" << std::endl; }
A (A &&)
{ std::cout << "- move constructor" << std::endl; }
};
template <typename T>
A foo (T const &)
{ return {}; }
A const & foo (A const & a)
{ return a; }
int main ()
{
std::cout << "--- 000" << std::endl;
A a0;
std::cout << "--- 001" << std::endl;
auto a1 { foo(a0) };
std::cout << "--- 002" << std::endl;
decltype(auto) a2 { foo(a0) };
std::cout << "--- 003" << std::endl;
decltype(auto) a3 { foo(0) };
std::cout << "--- 004" << std::endl;
}
I get (from g++ and clang++) this output
--- 000
- default constructor
--- 001
- copy constructor
--- 002
--- 003
- default constructor
--- 004
As you can see, auto a1 { foo(a0) }; call the copy constructor of A (because auto become A and A a1 { foo(a0) }; cause the the copy of the value returned by foo()) but decltype(auto) a2 { foo(a0) }; doesn't call contructors (because decltype(auto) become A const & and A const & a2 { foo(a0) }; simply link a2 to foo(a0) (so to a0).