Container STL với một loại cụ thể làm đối số chung

Có cách nào để tôi có thể tạo một hàm lấy một thùng chứa với một loại cụ thể (giả sử std::string) làm tham số không

void foo(const std::container<std::string> &cont)
{
   for(std::string val: cont) {
      std::cout << val << std::endl;
   }
}

và gọi nó cho mọi loại container stl làm đầu vào? như trên?

std::set<std::string> strset;
std::vector<std::string> strvec;
std::list<std::string> strlist;

foo(strset);
foo(strvec);
foo(strlist);

Bạn có thể tạo foomẫu hàm lấy tham số mẫu mẫu cho loại vùng chứa.

ví dụ

template<template<typename...> typename C>
void foo(const C<std::string> &cont)
{
   for(std::string val: cont) {
      std::cout << val << std::endl;
   }
}

TRỰC TIẾP

Tùy thuộc vào việc bạn có muốn quá tải foocho các trường hợp khác hay không

// Doesn't participate in overload resolution when not applicable
template<typename Container, typename = std::enable_if_t<std::is_same_v<typename Container::value_type, std::string>>>
void foo(const Container &cont) {
   for(std::string val: cont) {
      std::cout << val << std::endl;
   }
}

// simpler
template<typename Container>
void foo(const Container &cont) {
   static_assert(std::is_same_v<typename Container::value_type, std::string>, "Container must contain std::string")
   for(std::string val: cont) {
      std::cout << val << std::endl;
   }
}

Bạn có thể sử dụng một thử nghiệm khác để std::is_same, chẳng hạn như std::is_convertiblecho phép

std::vector<char *> c_strings;
foo(c_strings);

Bạn có thể muốn xem xét sử dụng các vòng lặp thay thế. Một kết quả trung gian có thể trông giống như

template<typename Iter>
void foo(Iter begin, Iter end) {
  using T = decltype(*begin);
  std::for_each(begin, end, [] (cons T & t) {
    std::out << t << '\n';
  }
}

Hiện đang sử dụng một mẫu có thể gọi được:

template<typename Iter, typename Callable>
void foo(Iter begin, Iter end, Callable & c) {
  std::for_each(begin, end, c);
}

Chúng tôi chỉ học cách sử dụng những gì STL đã cung cấp.

Thêm vào câu trả lời của @ songyuanyao, tôi nghĩ chúng ta có thể khái quát nó hơn nữa để:

template<template<typename...> typename C, typename ... D>
void foo(const C<D...> &cont)
{
   for(const auto& val: cont) {
      std::cout << val << std::endl;
   }
}