Wierd stuff happens when overloading operator<< with a class template

Question

Here's the functionality I am expecting to achieve:

darray<int> a;
a.push_back(1);
a.push_back(2);
a.push_back(3);
std::cout << a << std::endl; // displays: {1, 2, 3}

My implementation:

template <typename T>
class darray
{
private:
    long m_capacity;
    long m_size;
    T* m_data;
    void resize();

public:
    // constructors & destructors
    darray();

    // operations
    void push_back(T);
    std::ostream& print(std::ostream&) const;
    template<typename U> friend std::ostream& operator<<(std::ostream& os, U const& ar);
};

template<typename T>
std::ostream& darray<T>::print(std::ostream& os) const
{
    os << "{ ";
        for (size_t i = 0; i < m_size; i++)
        {
            os << m_data[i] << ", ";
            if ( i == m_size - 1 )
                os << m_data[i];
        }
        os << " }\n";
        return arr;
}

template<typename U>
std::ostream& operator<<(std::ostream& os, U const& obj)
{
    return obj.print(os);
}

produces an error:

error: ambiguous overload for ‘operator<<’ (operand types are ‘std::ostream’ {aka ‘std::basic_ostream<char>’} and ‘const char [66]’)

But, when I change the parameter of operator<< to accept a darray<U> instead , it works fine:

template<typename U>
std::ostream& operator<<(std::ostream& os, darray<U> const& obj)
{
    return obj.print(os);
}

What am I missing here?

Update:

I also tried doing this, changing the parameter to darray<U> type in the definition and the implementation, but it still produces the same error:

template <typename T>
class darray
{
private:
    long m_capacity;
    long m_size;
    T* m_data;
    void resize();

public:
    // constructors & destructors
    darray();

    // operations
    void push_back(T);
    std::ostream& print(std::ostream&) const;
    template<typename U> friend std::ostream& operator<<(std::ostream& os, darray<U> const& ar);
};

template<typename T>
std::ostream& darray<T>::print(std::ostream& os) const
{
    os << "{ ";
        for (size_t i = 0; i < m_size; i++)
        {
            os << m_data[i] << ", ";
            if ( i == m_size - 1 )
                os << m_data[i];
        }
        os << " }\n";
        return os;
}

template<typename U>
std::ostream& operator<<(std::ostream& os, darray<U> const& obj)
{
    return obj.print(os);
}

Your defined template for `<<` takes a `U` parameter that is a potential match for a `const char*` or `const char[]` argument, thus conflicting with the one provided by the standard library. — Adrian Mole, Nov 14 '22 at 11:59
`std::ostream& arr` is a misleading name. You should use this parameter in the `print` function, instead of `std::cout`. — mch, Nov 14 '22 at 12:00
@AdrianMole It doesn't work as well if I defined << in the class definition like this: `template friend std::ostream& operator<<(std::ostream& os, darr const& ar);` — Zaki, Nov 14 '22 at 12:14
@Zaki yes, it was a comment about something odd looking in your code, not an answer for your problem. — mch, Nov 14 '22 at 12:19
@mch I updated the code in the question, replaced `std::cout` with `os` still produces same error — Zaki, Nov 14 '22 at 12:20
@ÖöTiib It points to the line where i implemented the function, this: `std::ostream& operator<<(std::ostream& os, U const& obj)` — Zaki, Nov 14 '22 at 12:24
@Zaki I can't reproduce it your posted example does not have the issue. — Öö Tiib, Nov 14 '22 at 12:38
I can't reproduce your error problem with the code you've posted. Can you provide a [mcve] that actually reproduces the problem, rather than a code snippet? I suspect you have a bug in the code not provided. — Eljay, Nov 14 '22 at 13:05

score 1 · Answer 1 · answered Nov 14 '22 at 13:27

1

In your darray<T>::print function, if you change

os << m_data[i] << ", ";

to

os << m_data[i];
os << ", ";

then the compiler doesn't complain and it works fine. I don't know why.

answered Nov 14 '22 at 13:27

Charles Z

51
4

score 1 · Accepted Answer · answered Nov 14 '22 at 14:59

1

Friend functions in template classes have to be defined inside the class declaration. This is the only way I have found to have the friend function to correctly accept an instance of the templated class with the expected template.

So here I would write:

...
friend std::ostream& operator<<(std::ostream& os, darray<T> const& ar) {
    ar.print(os);
    return os;
}
...

But beware: your class contains a raw pointer to allocated memory which is probably deleted in the class destructor. Per the rule of five, you must explicitely declare (or delete) the copy/move constructors and assignment operators.

answered Nov 14 '22 at 14:59

Serge Ballesta

143,923
11
122
252

No, nothing to do with the friend class. As mentioned in the question, it also works fine if you just define the `operator <<` function as a non-friend and non-member function outside the class. There's actually no need for a friend class, since the `operator <<` function doesn't try to access any non-public members of the class. – Charles Z Nov 16 '22 at 02:17
@ZiggyZhang: I assumed that OP declared the operator as friend because in a later version of their code, it could use non public members... – Serge Ballesta Nov 16 '22 at 07:15
You're right. But I still have two questions: 1. If the function `template friend std::ostream& operator<<(std::ostream& os, U const& ar)` defines in the class, it does work fine. But why? 2. Since operator<< is a friend function, independent of the class, sometimes I want to use it for other classes, but the problem comes again, what should I do? – Charles Z Nov 17 '22 at 03:49

Wierd stuff happens when overloading operator<< with a class template

2 Answers2