如何从模板化的流操作符中调用标准流操作符

Question

我有一些向量类，我想实现一个像这样的通用流操作符:

template <typename T>
std::ostream& operator<<(std::ostream& os, const T& v)
{
    for (int i = 0; i < T::num_elems; ++i)
    {
        os << " " << v.a[i];
    }
    return os;
}

这几乎工作，除了我得到一个错误的os << " " << ...，当然，因为它是模糊的。我如何消除这一点的歧义，并强制std::的<<操作符在这里使用?

或者，我如何将这个模板化流操作符的使用限制在我的向量类中?我已经把向量类和流操作符放在一个单独的命名空间中，但这似乎还不够。

实际错误消息的开头:

foo.cpp:73: error: ambiguous overload for 'operator<<' in 'os << " "'
/usr/include/c++/4.2.1/ostream:169:0 /usr/include/c++/4.2.1/ostream:169: note: candidates are: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long int) [with _CharT = char, _Traits = std::char_traits<char>] <near match>
/usr/include/c++/4.2.1/ostream:177:0 /usr/include/c++/4.2.1/ostream:177: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long unsigned int) [with _CharT = char, _Traits = std::char_traits<char>] <near match>
/usr/include/c++/4.2.1/ostream:185:0 /usr/include/c++/4.2.1/ostream:185: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(bool) [with _CharT = char, _Traits = std::char_traits<char>]
...

进一步澄清:流操作符只在测试工具(unittest++)中使用，它不是公共API的一部分。此外，vector类是小的自定义固定大小的vector(实际上只是简单的数组)，而不是c++中的vector。

我需要使用的一个向量类的简化示例:

struct VectorClass {
    enum { num_elems = 16 };
    int32_t a[num_elems];
};

Answer 1

有大约20个类似的类，具有不同的POD类型和数组大小，但其他方面是相同的。

创建一个命名函数来完成泛化工作。

template <typename T>
std::ostream& SendVectorToOstream(std::ostream& os, const T& v)
{
    for (int i = 0; i < T::num_elems; ++i)
    {
        os << " " << v.a[i];
    }
    return os;
}

现在您可以将operator<<函数转发到它。

std::ostream& operator<<(std::ostream& os, const VectorClassA & v)
{
    return SendVectorToOstream( os, v );
}
std::ostream& operator<<(std::ostream& os, const VectorClassB & v)
{
    return SendVectorToOstream( os, v );
}
std::ostream& operator<<(std::ostream& os, const VectorClassC & v)
{
    return SendVectorToOstream( os, v );
}

Answer 2

在IIRC中，您可以使用SFINAE(如Drew Dormann的回答)或使用名称空间进行依赖参数的名称查找:

namespace all_my_vectors
{
    struct myVector1 { int a; };
    struct myVector2 { int a; };
    template < typename Vector >
    std::ostream& operator<< (std::ostream& o, Vector const& v)
    {
        o << v.a; // look up name in std::ostream, namespace std, global namespace, namespace of v.a
        return o;
    }
}
int main()            
{
    all_my_vectors::myVector1 v1;
    all_my_vectors::myVector2 v2;
    std::cout << v1 << v2; // look up name in std::ostream, namespace std, global namespace, namespace all_my_vectors
    return 0;
}

编辑:如果它们共享一个公共基类，您应该使用stardust_的方法。

Answer 3

我想你看错方向了。模板不是解决方案。你想要的是继承。像这样

template< typename T>
struct VectorClass {

    enum { num_elems = 4 };
    T* a;
};

template< typename T>
std::ostream& operator<<(std::ostream& os, const VectorClass<T>& v)
    {
        for (int i = 0; i < VectorClass<T>::num_elems; ++i)
        {
            os << " " << v.a[i];
        }
        return os;
    }

template< typename T>
class DerivedClass : public VectorClass<T> {
};


int main(){
    DerivedClass<int> v;
    int* tmp = new int[VectorClass<int>::num_elems];
    for (int i = 0; i < VectorClass<int>::num_elems; ++i) {
        tmp[i] = i;
    }
    v.a = tmp;
    cout << v;
}

Answer 4

如果你所有的向量类都有一个共同的属性，比如num_elems，你可以使用SFINAE来实现它。

template <typename T,          size_t SFINAE = T::num_elems >
// The only difference is here ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
std::ostream& operator<<(std::ostream &os, const T& v)
{
    for (int i = 0; i < T::num_elems; ++i)
    {
        os << " " << v.a[i];
    }
    return os;
}

这个改变强制ostream <<只应用于类型T，这些类型定义了一个可以转换为size_t的T::num_elems，就像你的enum。

此解决方案假设使用c++ 11编译器