Частичная специализация. Контейнеры

#include <vector>
#include <list>
#include <deque>
#include <iostream>
 
template <typename T>
void print(const T&)
{
   std::cout << "common print" << std::endl;
}
 
template <typename T>
void print(const std::vector<T>&)
{
   std::cout << "vector<T> print" << std::endl;
}
 
void print(const std::vector<char>&)
{
   std::cout << "vector<char> print" << std::endl;
}
 
int main()
{
   print(std::list<int>());
   print(std::deque<int>());
   print(std::vector<int>());
   print(std::vector<void*>());
   print(std::vector<char>());
   return 0;
}

...
    stack<int, vector<int>> sv;
    queue<int, list<int>> qd;
    priority_queue<int, vector<int>, less<int>> pql;
...
    Print(sv);
    Print(qd);
    Print(pql);

  print(std::list<int>());
  print(std::deque<int>());
  print(std::vector<int>());
  print(std::vector<void*>());
  print(std::vector<char>());

std::list<int> c1;
std::deque<int> c2;
std::vector<int> c3;
std::vector<void*> c4;
std::vector<char> c5;
 
  print(с1);
  print(с2);
  print(с3);
  print(с4);
  print(с5);

template <typename T>
void print(const std::vector<T>&)
{
   std::cout << "vector<T> print" << std::endl;
}

//---------------------------------------------------------------------------
template <class C>
print(C c)
{
    while(!c.empty())
     {
         std::cout<<c.top()<<" ";
         c.pop();
     }
}
//---------------------------------------------------------------------------
template <class T>
print(std::queue<T> c)
{
    while(!c.empty())
     {
         std::cout<<c.front()<<" ";
         c.pop();
     }
}
//---------------------------------------------------------------------------
int main()
{
using namespace std;
 
stack<int> s;
 
s.push(1);
s.push(2);
s.push(3);
 
queue<int> q;
 
q.push(1);
q.push(2);
q.push(3);
 
priority_queue<int> pq;
 
pq.push(1);
pq.push(2);
pq.push(3);
 
 
print(s);  cout<<endl;
print(q);  cout<<endl;
print(pq); cout<<endl;
 
return 0;
}

//---------------------------------------------------------------------------
template <class C>
void print(C& c);
//---------------------------------------------------------------------------
template <class T>
void print(std::queue<T>& c);
//--------------------------------------------------------------------------

#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <utility>
 
template <class Container>
void print(const Container& c, std::ostream& stream = std::cout)
{
    for(const auto& elem: c)
        stream << elem << ' ';
}
 
int main()
{
    std::vector<int>    v{1, 2, 3};
    std::deque<int>     d{3, 2, 1};
    std::set<int>       s{2, 3, 1};
 
    print(v);
    std::cout << std::endl;
 
    print(d);
    std::cout << std::endl;
 
    print(s);
    std::cout << std::endl;
 
    return 0;
}