Templates and overloadering operator << [duplicate]

Answer 1

You don't need to make your friend a template:

friend std::ostream& operator<<(std::ostream& os, const Derived<T>& dt);

This needs to be changed to:

friend std::ostream& operator<< <>(std::ostream& os, const Derived<T>& dt);

The operator<< function will need to be visible before the friend declaration for this form to work.

You should prefer this form to making the friend a template because you don't need all of the operator's instantiations to be friends, just one of them.

Answer 2

replace

friend std::ostream& operator<<(std::ostream& os, const Derived<T>& dt);

with

template<typename D>
friend std::ostream& operator<<(std::ostream& os, const Derived<D>& dt);

Answer 3

friend std::ostream& operator<<(std::ostream& os, const Derived<T>& dt);

declares a non template version friend, so you would have to implement

std::ostream& operator<<(std::ostream& os, const Derived<T>& dt);

for every T you use:

std::ostream& operator<<(std::ostream& os, const Derived<int>& dt) {
    return os << dt.data_;
}

And so on. A way to do it without duplicate code is with definition inside the class:

template <typename T>
class Derived : public IBase
{
public:
    explicit Derived(T data);
    friend std::ostream& operator<<(std::ostream& os, const Derived<T>& dt)
    {
        return os << dt.data_;
    }
private:
    T data_;
};

Demo

An other alternative is to make the function template.

// Forward declarations
template <typename T> class Derived;
template <typename T> std::ostream& operator<<(std::ostream& os, const Derived<T>& dt);

And then in Derived, you have 2 choices:

• Declare each the template method friend:

  template <typename T2>
  friend std::ostream& operator<<(std::ostream& os, const Derived<T2>& dt);
  

  So std::ostream& operator<<(std::ostream& os, const Derived<int>& dt) has access to private members of Derived<int>, but also to the ones of Derived<char>

  Demo

• Declare only the template which matches the argument:

  friend std::ostream& operator<< <>(std::ostream& os, const Derived& dt);
  

  and so std::ostream& operator<<(std::ostream& os, const Derived<int>& dt) doesn't have access to private members of Derived<char>.

  Demo

Answer 4

You need to declarate friend operator as a template too

template<typename T1>
friend std::ostream& operator<<(std::ostream& os, const Derived<T1>& dt);

Answer 5

Your immediate problem is that the operator needs to be templated.

However, your ultimate goal can't be attained through templates alone as dereferencing a IBase* gets you a IBase& - template instantiation occurs at compile time and the compiler has no access to the runtime type.

So your templated operator will never be used if you pass a dereferenced IBase* to operator <<.

Instead, add a virtual output function to the base and override it:

class IBase
{
public:
    IBase() {};
    virtual ~IBase() {};
    virtual std::ostream& output(std::ostream&) const = 0;
};

template <typename T>
class Derived
    : public IBase
{
public:
    Derived(T data);
    virtual std::ostream& output(std::ostream& os) const
    {
        os << data;
        return os;
    }
private:
    T data_;
};

std::ostream& operator<<(std::ostream& os, const IBase& dt)
{
    return dt.output(os);
}