класс c++ шаблон; функция с произвольным типом контейнера, как его определить?
хорошо, простой вопрос шаблона. Скажем, я определяю свой класс шаблона примерно так:
template<typename T>
class foo {
public:
foo(T const& first, T const& second) : first(first), second(second) {}
template<typename C>
void bar(C& container, T const& baz) {
//...
}
private:
T first;
T second;
}
вопрос о моей функции bar... Мне нужно, чтобы он мог использовать стандартный контейнер, поэтому я включил часть template/typename C, чтобы определить этот тип контейнера. Но, по-видимому, это не правильный способ сделать это, так как мой тестовый класс жалуется, что:
ошибка:' bar ' не был объявлен в этой области
Так как бы я пошел о правильной реализации моей функции бара? То есть, как функция моего класса шаблона, с произвольным типом контейнера... остальная часть моего класса шаблонов работает нормально (имеет другие функции, которые не приводят к ошибке), это просто одна функция, которая проблематична.
изменить: Итак, конкретная функция (bar) является функцией eraseInRange, которая стирает все элементы в указанном диапазоне:
void eraseInRange(C& container, T const& firstElement, T const& secondElement) {...}
и пример того, как он будет использоваться будет быть:
eraseInRange(v, 7, 19);
где v-вектор в этом случае.
редактирование 2: Глупый я! Я должен объявить функцию вне класса, а не в нем... довольно неприятная ошибка. В любом случае, спасибо всем за помощь, хотя проблема была немного другой, информация помогла мне построить функцию, так как после поиска моей первоначальной проблемы я получил некоторые другие приятные ошибки. Так что спасибо!
3 ответов
решение черты характера.
обобщать не больше, чем нужно, и не меньше.
в некоторых случаях этого решения может быть недостаточно, поскольку оно будет соответствовать любому шаблону с такой подписью (например,shared_ptr), в этом случае вы можете использовать type_traits, очень нравится утка-типирование (шаблоны-это утка, набранная в общем).
#include <type_traits>
// Helper to determine whether there's a const_iterator for T.
template<typename T>
struct has_const_iterator
{
private:
template<typename C> static char test(typename C::const_iterator*);
template<typename C> static int test(...);
public:
enum { value = sizeof(test<T>(0)) == sizeof(char) };
};
// bar() is defined for Containers that define const_iterator as well
// as value_type.
template <typename Container>
typename std::enable_if<has_const_iterator<Container>::value,
void>::type
bar(const Container &c, typename Container::value_type const & t)
{
// Note: no extra check needed for value_type, the check comes for
// free in the function signature already.
}
template <typename T>
class DoesNotHaveConstIterator {};
#include <vector>
int main () {
std::vector<float> c;
bar (c, 1.2f);
DoesNotHaveConstIterator<float> b;
bar (b, 1.2f); // correctly fails to compile
}
хороший шаблон обычно делает не искусственно ограничьте тип типов, для которых они действительны (почему они должны?). Но представьте, что в приведенном выше примере вам нужно иметь доступ к объектам const_iterator, затем вы можете использовать SFINAE и type_traits, чтобы поставить эти ограничения на свою функцию.
или просто, как это делает стандартная библиотека
обобщать не больше, чем нужно, и не меньше.
template <typename Iter>
void bar (Iter it, Iter end) {
for (; it!=end; ++it) { /*...*/ }
}
#include <vector>
int main () {
std::vector<float> c;
bar (c.begin(), c.end());
}
больше таких примеров, посмотрите в <algorithm>.
сила этого подхода заключается в его простоте и основана на таких понятиях, как ForwardIterator. Он даже будет работать для массивов. Если вы хотите сообщить об ошибках прямо в подписи, вы можете объединить его с признаками.
std контейнеры с подписью типа std::vector (не рекомендуется)
самое простое решение уже аппроксимировано Kerrek SB, хотя оно является недопустимым C++. Этот исправленный вариант выглядит так:
#include <memory> // for std::allocator
template <template <typename, typename> class Container,
typename Value,
typename Allocator=std::allocator<Value> >
void bar(const Container<Value, Allocator> & c, const Value & t)
{
//
}
: это будет работать только для контейнеров, которые имеют ровно два аргумента типа шаблона, поэтому будет неудачно для std::map (спасибо Люк Дантон).
любые вторичные аргументы шаблона (не рекомендуется)
исправленная версия для любого подсчета вторичных параметров выглядит следующим образом:
#include <memory> // for std::allocator<>
template <template <typename, typename...> class Container,
typename Value,
typename... AddParams >
void bar(const Container<Value, AddParams...> & c, const Value & t)
{
//
}
template <typename T>
class OneParameterVector {};
#include <vector>
int main () {
OneParameterVector<float> b;
bar (b, 1.2f);
std::vector<float> c;
bar (c, 1.2f);
}
: это все равно не удастся для контейнеров без шаблонов (спасибо Luc Danton).
сделать шаблон шаблоном на параметре шаблона шаблона:
template <template <typename, typename...> class Container>
void bar(const Container<T> & c, const T & t)
{
//
}
если у вас нет C++11, то вы не можете использовать variadic шаблоны, и вы должны предоставить столько параметров шаблона, сколько занимает ваш контейнер. Например, для контейнера последовательности может потребоваться два:
template <template <typename, typename> class Container, typename Alloc>
void bar(const Container<T, Alloc> & c, const T & t);
или, если вы хотите разрешить только распределители, которые сами являются экземплярами шаблона:
template <template <typename, typename> class Container, template <typename> class Alloc>
void bar(const Container<T, Alloc<T> > & c, const T & t);
как я предложил в комментариях, я бы лично предпочитаю сделать весь контейнер шаблонным тип и используйте черты, чтобы проверить, действительно ли это. Что-то вроде этого:--6-->
template <typename Container>
typename std::enable_if<std::is_same<typename Container::value_type, T>::value, void>::type
bar(const Container & c, const T & t);
Это более гибко, так как контейнер теперь может быть все, что подвергает value_type тип члена. Можно представить более сложные черты для проверки функций-членов и итераторов; например,довольно принтера реализует несколько из них.
вот последняя и расширенная версия ответ и значительное улучшение за ответ Сабастиане.
идея состоит в том, чтобы определить все черты контейнеров STL. К сожалению, это становится сложным очень быстро, и, к счастью, многие люди работали над настройкой этого кода. Эти черты являются многоразовыми, поэтому просто скопируйте и пройдите ниже кода в файле под названием type_utils.ГЭС (не стесняйтесь менять эти названия):
//put this in type_utils.hpp
#ifndef commn_utils_type_utils_hpp
#define commn_utils_type_utils_hpp
#include <type_traits>
#include <valarray>
namespace common_utils { namespace type_utils {
//from: https://raw.githubusercontent.com/louisdx/cxx-prettyprint/master/prettyprint.hpp
//also see https://gist.github.com/louisdx/1076849
namespace detail
{
// SFINAE type trait to detect whether T::const_iterator exists.
struct sfinae_base
{
using yes = char;
using no = yes[2];
};
template <typename T>
struct has_const_iterator : private sfinae_base
{
private:
template <typename C> static yes & test(typename C::const_iterator*);
template <typename C> static no & test(...);
public:
static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
using type = T;
void dummy(); //for GCC to supress -Wctor-dtor-privacy
};
template <typename T>
struct has_begin_end : private sfinae_base
{
private:
template <typename C>
static yes & f(typename std::enable_if<
std::is_same<decltype(static_cast<typename C::const_iterator(C::*)() const>(&C::begin)),
typename C::const_iterator(C::*)() const>::value>::type *);
template <typename C> static no & f(...);
template <typename C>
static yes & g(typename std::enable_if<
std::is_same<decltype(static_cast<typename C::const_iterator(C::*)() const>(&C::end)),
typename C::const_iterator(C::*)() const>::value, void>::type*);
template <typename C> static no & g(...);
public:
static bool const beg_value = sizeof(f<T>(nullptr)) == sizeof(yes);
static bool const end_value = sizeof(g<T>(nullptr)) == sizeof(yes);
void dummy(); //for GCC to supress -Wctor-dtor-privacy
};
} // namespace detail
// Basic is_container template; specialize to derive from std::true_type for all desired container types
template <typename T>
struct is_container : public std::integral_constant<bool,
detail::has_const_iterator<T>::value &&
detail::has_begin_end<T>::beg_value &&
detail::has_begin_end<T>::end_value> { };
template <typename T, std::size_t N>
struct is_container<T[N]> : std::true_type { };
template <std::size_t N>
struct is_container<char[N]> : std::false_type { };
template <typename T>
struct is_container<std::valarray<T>> : std::true_type { };
template <typename T1, typename T2>
struct is_container<std::pair<T1, T2>> : std::true_type { };
template <typename ...Args>
struct is_container<std::tuple<Args...>> : std::true_type { };
}} //namespace
#endif
теперь вы можете использовать эти черты, чтобы сделать конечно, наш код принимает только типы контейнеров. Например, вы можете реализовать функцию добавления, которая добавляет один вектор к другому следующим образом:
#include "type_utils.hpp"
template<typename Container>
static typename std::enable_if<type_utils::is_container<Container>::value, void>::type
append(Container& to, const Container& from)
{
using std::begin;
using std::end;
to.insert(end(to), begin(from), end(from));
}
обратите внимание, что я использую begin() и end() из пространства имен std, чтобы убедиться, что у нас есть поведение итератора. Дополнительные сведения см. В разделе мой блог.