Как объявить специализацию функции друга шаблона
Наличие шаблона:
template <typename T, template <typename ELEM, typename ALLOC=std::allocator<ELEM> > class Cont=std::vector>
class VehiclesContainer {
public:
VehiclesContainer(std::initializer_list<T> l):container(l){};
virtual ~VehiclesContainer(){};
virtual void addVehicle(T elem);
virtual T getFirst() const;
template
<typename U, template <typename ELEM2, typename ALLOC=std::allocator<ELEM2> > class Cont2>
friend std::ostream& operator<<(std::ostream& out, const VehiclesContainer<U,Cont2>& obj);
private:
Cont<T> container;
};
У меня есть оператор<< как друг класс:
template
<typename T,template <typename ELEM,typename ALOC=std::allocator<ELEM> > class Cont>
std::ostream& operator<<(std::ostream& out,const VehiclesContainer<T,Cont>& obj){
typename Cont<T>::const_iterator it;
for(it=obj.container.begin(); it!=obj.container.end(); ++it)
out << *it << " ";
return out;
}
Я хочу иметь специализацию для этой функции для целых чисел, в которой вместо пробела будет - между элементами на выходе. Я старался
template
<int,template <typename ELEM,typename ALOC=std::allocator<ELEM> > class Cont>
std::ostream& operator<<(std::ostream& out,const VehiclesContainer<int,Cont>& obj){
typename Cont<int>::const_iterator it;
for(it=obj.container.begin(); it!=obj.container.end(); ++it)
out << *it << "-";
return out;
}
Но когда я собираю, имея в основном
VehiclesContainer<int,std::vector > aStack1({10,20,30});
std::cout << aStack1;
Общая форма оператора<< называется вместо моей специализации. Я предполагаю, что я действительно не специализировался на этом. Любая помощь, как специализация для класса друга может быть объявлена?
Решение основано на ответе WhozCraig
Форвардная декларация:
template <typename T, template <typename ELEM, typename ALLOC=std::allocator<ELEM> > class Cont=std::vector>
class VehiclesContainer;
template <typename T, template <typename ELEM, typename ALLOC=std::allocator<ELEM> > class Cont>
std::ostream& operator<< (std::ostream& out, const VehiclesContainer<T,Cont>& obj);
template <template <typename ELEM, typename ALLOC=std::allocator<ELEM> > class Cont>
std::ostream& operator<< (std::ostream& out, const VehiclesContainer<int,Cont>& obj);
Объявление внутри класса:
friend std::ostream& operator << <T,Cont>(std::ostream&,
const VehiclesContainer<T,Cont>&);
friend std::ostream& operator << <Cont>(std::ostream&,
const VehiclesContainer<int,Cont>&);
Определение функций друга:
template <typename T, template <typename ELEM, typename ALLOC=std::allocator<ELEM> > class Cont>
std::ostream& operator <<(std::ostream& os, const VehiclesContainer<T,Cont>& obj)
{
if (obj.container.size() > 0)
{
os << obj.container.front();
for (auto it = std::next(obj.container.begin()); it != obj.container.end(); ++it)
os << ' ' << *it;
}
return os;
}
template <template <typename ELEM, typename ALLOC=std::allocator<ELEM> > class Cont>
std::ostream& operator << (std::ostream& os, const VehiclesContainer<int,Cont>& obj)
{
if (obj.container.size() > 0)
{
os << obj.container.front();
for (auto it = std::next(obj.container.begin()); it != obj.container.end(); ++it)
os << '-' << *it;
}
return os;
}
Решение
Это один из способов сделать то, что вы хотите. Я взял на себя смелость использовать вариадику в параметрах шаблона, чтобы сэкономить время при наборе текста, но в конечном итоге предпосылка должна быть, надо надеяться, очевидной:
#include <iostream>
#include <vector>
#include <cstdlib>
// forward declaration of template class
template <class T, template<class, class...> class Cont = std::vector, class... Args>
class VehiclesContainer;
// generic template for all T and all container types
template<class T, template<class, class...> class Cont = std::vector, class... Args>
std::ostream& operator <<(std::ostream&, const VehiclesContainer<T,Cont,Args...>&);
// specific template for only int and all container types
template<template<class, class...> class Cont = std::vector, class... Args>
std::ostream& operator << (std::ostream& os, const VehiclesContainer<int,Cont,Args...>& obj);template <class T, template<class, class...> class Cont, class... Args>
class VehiclesContainer
{
public:
VehiclesContainer(std::initializer_list<T> l)
: container(l)
{};
// friend overloaded to `int` type
friend std::ostream& operator << <T,Cont,Args...>(std::ostream&,
const VehiclesContainer<T,Cont,Args...>&);
friend std::ostream& operator << <Cont, Args...>(std::ostream&,
const VehiclesContainer<int,Cont,Args...>&);
private:
Cont<T,Args...> container;
};
template<class T, template<class, class...> class Cont, class... Args>
std::ostream& operator <<(std::ostream& os, const VehiclesContainer<T,Cont,Args...>& obj)
{
if (obj.container.size() > 0)
{
os << obj.container.front();
for (auto it = std::next(obj.container.begin()); it != obj.container.end(); ++it)
os << ' ' << *it;
}
return os;
}
template<template<class, class...> class Cont, class... Args>
std::ostream& operator << (std::ostream& os, const VehiclesContainer<int,Cont,Args...>& obj)
{
if (obj.container.size() > 0)
{
os << obj.container.front();
for (auto it = std::next(obj.container.begin()); it != obj.container.end(); ++it)
os << '-' << *it;
}
return os;
}int main()
{
VehiclesContainer<std::string> vcString { "Camero", "Corvette" };
VehiclesContainer<int> vcInt { 1,2,3 };
std::cout << vcString << '\n';
std::cout << vcInt << '\n';
return 0;
}
Выход
Camero Corvette
1-2-3
Другие решения
Я думаю, что правильный способ сделать это так:
template
<template <typename ELEM2, typename ALLOC=std::allocator<ELEM2> > class Cont2>
friend std::ostream& operator<<(std::ostream& out, const VehiclesContainer<int,Cont2>& obj);
Вы должны сделать это до объявления друга, иначе это будет, конечно, приватно.
template
<template <typename ELEM,typename ALOC=std::allocator<ELEM> > class Cont>
std::ostream& operator<<(std::ostream& out,const VehiclesContainer<int,Cont>& obj){
typename Cont<int>::const_iterator it;
for(it=obj.container.begin(); it!=obj.container.end(); ++it)
out << *it << "-";
return out;
}