คอนเทนเนอร์ STL ที่มีประเภทเฉพาะเป็นอาร์กิวเมนต์ทั่วไป

มีวิธีที่ฉันสามารถสร้างฟังก์ชั่นที่ใช้ภาชนะที่มีประเภทเฉพาะ (ขอพูดstd::string) เป็นพารามิเตอร์

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

และเรียกมันว่า stl container ทุกชนิดเป็น input หรือไม่? ชอบข้างบน?

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

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

คุณสามารถสร้างfooฟังก์ชั่นเทมเพลตโดยใช้พารามิเตอร์เทมเพลตสำหรับประเภทคอนเทนเนอร์

เช่น

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

มีชีวิต

ขึ้นอยู่กับว่าคุณต้องการโอเวอร์โหลดfooสำหรับเคสอื่นหรือไม่

// 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;
   }
}

คุณอาจใช้แบบทดสอบอื่น std::is_sameอื่นเช่นstd::is_convertibleเพื่ออนุญาต

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

คุณอาจต้องการลองใช้ตัววนซ้ำแทน ผลลัพธ์ระดับกลางอาจดูเหมือน

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';
  }
}

ตอนนี้ใช้เทมเพลต callable:

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

เราเพิ่งเรียนรู้ที่จะใช้สิ่งที่ STL มีอยู่แล้ว

เมื่อเพิ่มคำตอบของ @ songyuanyao ฉันคิดว่าเราสามารถพูดคุยทั่วไปเพิ่มเติมได้ที่:

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