Override output operator << inside class c++ to print std::vector

Let's say I have a class as follows:

#include <iostream>
#include <cmath>
#include <vector>
#include <complex>

class RootFinder {
    public:
        RootFinder() = default;
        ~RootFinder() = default;

        friend std::ostream&  operator<<(std::ostream& os, const std::vector<std::complex<double>>& v) 
        { 
            os << "[";
            for (int i = 0; i < v.size(); ++i) { 
                os <<"( "<< v[i].real() << "," << v[i].imag() << "), "; 
            }
            os << "]\n";
            return os; 
        }

        inline std::vector<std::complex<double>> calculateEigenValuesOfMatrix(){
            std::vector<std::complex<double>> eigen_values;
            //  Do some operation
            std::cout<< eigen_values << std::endl;
            return eigen_values;
        };
    
    private:
        
};

int main (){
    RootFinder root_finder;
    root_finder.calculateEigenValuesOfMatrix();
    return 0;
}

Question:
I want to print eigen_values inside the class itself.

I was trying to override the std::ostream&, but it does not solve the problem. What is the proper way to solve this?

Error:

error: no match for ‘operator<<’ (operand types are ‘std::ostream {aka std::basic_ostream<char>}’ and ‘std::vector<std::complex<double> >’)
             std::cout<< eigen_values << std::endl;
             ~~~~~~~~~^~~~~~~~~~~~~~~
In file included from /usr/include/c++/7/istream:39:0,
                 from /usr/include/c++/7/sstream:38,
                 from /usr/include/c++/7/complex:45,
                 from /usr/include/eigen3/Eigen/Core:80,
                 from /root/tmp/cmake_tittorials/include/root_finder.h:4,
                 from /root/tmp/cmake_tittorials/src/main.cpp:1:

The problem is that even though you have defined the overloaded friend operator<< inside the class, it is not visible through normal lookup until either it is also declared in the enclosing scope or it has a parameter of the class type(so that ADL finds the friend function declaration).

<h4>Method 1</h4>

Here we provide a forward declaration for the friend function in the enclosing scope.

#include <iostream>
#include <cmath>
#include <vector>
#include <complex>

//add this declaration in the enclosing scope
std::ostream&  operator<<(std::ostream& os, const std::vector<std::complex<double>>& v);

class RootFinder {
    //exact same code as before
        
};
int main (){
    RootFinder root_finder;
    root_finder.calculateEigenValuesOfMatrix();
    return 0;
}

working demo

Other option is to define the friend function outside the class as shown here

If you wish to only print eigen values, better to create a standalone function (global free function or local private function) for printing the values:

class RootFinder
{
private:
    void print_eigen_values(const std::vector<std::complex<double>>& v) const
    {
        // TODO: add logic for printing to std::cout
    }
};

If you wish to print eigen values to any std::ostream, then you can create a function like:

class RootFinder
{
private:
    std::ostream& print_eigen_values(std::ostream& os, const std::vector<std::complex<double>>& v) const
    {
        // TODO: add logic for printing to os
        return os;
    }
};

then use it like: print_eigen_values(std::cout, eigen_values) << std::endl;.

If you want to retain eigen values for future operations, better to keep them as member of RootFinder and then you can overload std::ostream like below:

class RootFinder
{
private:
    friend std::ostream& operator<<(std::ostream& os, const RootFinder& v) const
    {
        // TODO: add logic for printing v.m_eigen_values to os
        return os;
    }

    std::vector<std::complex<double>> m_eigen_values;
};

which you can use anywhere like:

RootFinder r;
...
std::cout << r << std::endl;