Is condensing 'std::vector<T>&' into just 'T&' is permitted in C++ template?

I have been using the following overloading of print_vector to print out elements of the input array ([1]).

//////[1]///////
template<typename T>
void print_vector(T& vec) { // this function is for lagacy arrays in C/C++
                            // e.g. int x[3] = {1,2,3};

  std::cout << "- print vector" << std::endl;
  for (const auto& elem : vec) {
    std::cout << elem << std::endl;
  }
}

template<typename T>
void print_vector(std::vector<T>& vec) {
  std::cout << "- print vector" << std::endl;
  for (const auto& elem : vec) {
    std::cout << elem << std::endl;
  }
}

template<typename T>
void print_vector(thrust::host_vector<T>& vec) {
  std::cout << "- print vector" << std::endl;
  for (const auto& elem : vec) {
    std::cout << elem << std::endl;
  }
}

template<typename T>
void print_vector(thrust::device_vector<T>& vec) {
  std::cout << "- print vector" << std::endl;
  for (const auto& elem : vec) {
    std::cout << elem << std::endl;
  }
}

The reason why I did like this was that it seemed to require 'two' types for each function - for example, std::vector and T for the second one.

But I noticed that the following function [2] alone can do the desired functions for all types of inputs.

//////[2]///////

template<typename T>
void print_vector(T& vec) {
  std::cout << "- print vector" << std::endl;
  for (const auto& elem : vec) {
    std::cout << elem << std::endl;
  }
}

At the first glance, it seems that it had overly condensed two types into one T, so I thought this should be something like

//////[3]///////

template<typename T1, typename T2>
void print_vector(T1<T2>& vec) {
  std::cout << "- print vector" << std::endl;
  for (const auto& elem : vec) {
    std::cout << elem << std::endl;
  }
}

Is using [2] function to represent function overloadings in [1] in C++ is standard? Or is it somehow a coincidence that [2] worked properly?

And the fact still confuses me is that the ranged-for for (const auto& elem : vec) {} is applicable to legacy C/C++ arrays. When I search for the ranged-for, I found this sentence - "defined as anything that you can iterate through—for example, std::vector, or any other C++ Standard Library sequence whose range is defined by a begin() and end()". Although the pointers and iterators are quite similar, they are not the same and the lagacy arrays do not have 'iterators' that can be accessed by begin(), and end() but still ranged-for works. Why?

ADDED

Thanks to 273K, I feel I am getting closer but still cannot get some points.

For example the following code works fine with the vec.begin() part being commented.

template<typename T>
void print_vector(T& vec) {
  //std::cout << vec.begin() << std::endl;
  std::cout << "- print vector" << std::endl;
  for (const auto& elem : vec) {
    std::cout << elem << std::endl;
  }
}

int main(void) {

  int x[5] = {1,2,3,4,5};
  print_vector(x);

  return 0;
}

But when I turn on the commented line, I met the following errors during compilation.

main.cu(12): error: expression must have class type but it has type "int *"
          detected during instantiation of "void print_vector(T &) [with T=int [5]]"

So, could you give a little more explanation on your words - "There are common std::begin(c) and std::end(c) for all containers and T(&)[N]." ?

Here is another way of explaining it. The range-based for loop merely exists to let you write simpler loops in case you don't need the value of an index, pointer or iterator. Your example, through the magic of the std::begin and std::end abstractions, is essentially the same as this code:

#include <iostream>

void print_vector(int (&vec)[5]) {
  for (const int* elem = vec; elem != vec + 5; ++elem) {
    std::cout << *elem << std::endl;
  }
}

int main() {
  int x[5] = {1,2,3,4,5};
  print_vector(x);
}

Which looks like an eclectic mix of C and C++. Although C++ allows you to create references to C-style arrays, those don't have member functions because that was not really a thing in C. So when you try to call one, the C-style array does what it does best and implicitly converts into a pointer, which is still not a class type and fails the compilation.