How do I overload the << operator to print a class member?

Question

Here is the class

    class graph {
    public:
        graph() {}; // constructor
        graph(int size);
        friend ostream& operator<< (ostream& out, graph g);
    private:
        int size;
        bool** grph;
    };

This is how I generate the graph:

    graph::graph(int size) {
        grph = new bool*[size];
        for (int i = 0; i < size; ++i)
            grph[i] = new bool[size];
        for (int i = 0; i < size; ++i)
            for (int j = i; j < size; ++j) {
                if (i == j)
                    grph[i][j] = false;
                else {
                    cout << prob() << endl;//marker
                    grph[i][j] = grph[j][i] = (prob() < 0.19);
                    cout << grph[i][j] << endl;//marker
                }
            }
        cout << "Graph created" << endl;//marker
    }

The constructor and the prob() function work just fine. I have tested them using the markers.

This is where I believe the problem exists. This is the code for the overloaded operator <<

    ostream& operator<< (ostream& out, graph g) {
        for (int i = 0; i < g.size; ++i) {
            for (int j = 0; j < g.size; ++j) 
                out << g.grph[i][j] << "\t";
            out << endl;
        }
        return out;
    }

Here is how this is called.

     graph g(5);
 cout << g << endl;

Now, the program compiles just fine. But, while execution, the graph is not being printed. I haven been able to print the graph the same way without overloading the operator, but by having the for loops run inside the main or by using a class member function.

Can anyone help me out? I am using Visual Studio 2015.

This class will also need to overload some functions to accommodate copying. This post should be useful: https://stackoverflow.com/questions/4172722/what-is-the-rule-of-three — Galik, Aug 04 '16 at 19:05

Rakete1111 · Accepted Answer · 2016-08-04T21:12:07.500

2

The loops are never entered, because

i < g.size

is always false, because g.size is 0! You are never actually setting the member variable size to the size entered by the user, so it defaults to 0.

You'll have to set it, i.e.

this->size = size; //Sets member variable 'size' to 'size' from the function arguments

Also, you didn't specify a copy constructor, so the implicit one will be used. But the implicit one just copies the values, and so the pointer grph will point in 2 objects to the same data. You're leaking memory, that's why it doesn't matter (technically), but you should implement a proper destructor and copy/move constructor.

But because operator<< should only be printing, consider passing by const& instead of by value!

edited Aug 04 '16 at 21:12

answered Aug 04 '16 at 18:27

Rakete1111

47,013
16
123
162

While true this is only part of the problem. Look at the signature of the operator and then look at the c'tors the OP has for the class. – NathanOliver Aug 04 '16 at 18:28
@NathanOliver I don't see it. They the same? – Rakete1111 Aug 04 '16 at 18:30
The OP is making a copy. Do they have a copy c'tor? – NathanOliver Aug 04 '16 at 18:31
@Galik Fixing the size problem though does not fix the printing problem and printing is the problem. Now they will be printing the shallow copy which will (hopefully) lead to access violations. – NathanOliver Aug 04 '16 at 18:49
@Galik oops. I was looking at it wrong. This is fine then for a answer to the question. Thanks for putting my head on straight. – NathanOliver Aug 04 '16 at 18:59
Thanks for the help. I missed the initialization. – Apara Aug 04 '16 at 19:50

Ciro Corvino · Answer 2 · 2016-08-04T19:22:54.857

0

The problem depends by the missed initialization of the class attribute size in the costructor method.

Adding to your ctor this.size = size should resolve your problem as already rightly indicated by Rakete1111.

The following method allows you to print false or true, otherwise you may try cout<<std::boolalpha flag

ostream& operator<< (ostream& out, graph g) {
        for (int i = 0; i < g.size; ++i) {
            for (int j = 0; j < g.size; ++j) 
                out << (g.grph[i][j] ? "true" : "false") << "\t";
            out << endl;
        }
        return out;
    }

edited Aug 04 '16 at 19:22

answered Aug 04 '16 at 18:29

Ciro Corvino

2,038
5
20
33

1

While this code snippet may solve the question, [including an explanation](http://meta.stackexchange.com/questions/114762/explaining-entirely-‌code-based-answers) really helps to improve the quality of your post. Remember that you are answering the question for readers in the future, and those people might not know the reasons for your code suggestion. – NathanOliver Aug 04 '16 at 18:31
I saw better your costructor and in effect the cause is the missed initialization of the "size" attribute... – Ciro Corvino Aug 04 '16 at 19:11

score 0 · Answer 3 · answered Aug 04 '16 at 20:58

In addition to what others have said (you are not initializing the size member), your operator<< is accepting the graph object by value. When the operator is called, a copy of the input graph object is made, but your graph class is not properly written to support copying. Your operator<< should accept the graph object by const reference instead so a copy is not needed:

ostream& operator<< (ostream& out, const graph &g)

Your graph class does not support copying because you are completely violating the Rule of Three:

Your default constructor is not initializing the graph data at all.
You are missing a destructor that frees the graph data.
You are missing a copy constructor and copy assignment operator to make a copy of the graph data from one graph object to another.

Even if you pass the graph object to operator<< by reference, you still need to implement the Rule of Three correctly to avoid problems in your code in general.

You need to either:

implement proper constructors and operators:

class graph {
public:
    graph(int size = 0);
    graph(const graph &src);
    ~graph();

    graph& operator=(const graph &rhs);

    friend std::ostream& operator<< (std::ostream& out, const graph &g);
private:
    int size;
    bool** grph;
};

std::ostream& operator<< (std::ostream& out, const graph &g);

graph::graph(int size)
    : grph(NULL), size(size)
{
    grph = new bool*[size];
    for (int i = 0; i < size; ++i) {
        grph[i] = new bool[size];
    }
    for (int i = 0; i < size; ++i) {
        for (int j = i; j < size; ++j) {
            if (i == j) {
                grph[i][j] = false;
            } else {
                grph[i][j] = grph[j][i] = (prob() < 0.19);
            }
        }
    }
}

graph::graph(const graph &src)
    : grph(NULL), size(src.size)
{
    grph = new bool*[size];
    for (int i = 0; i < size; ++i) {
        grph[i] = new bool[size];
        for (int j = i; j < size; ++j) {
            grph[i][j] = src.grph[i][j];
    }
}

graph::~graph() {
    for (int i = 0; i < size; ++i) {
        delete[] grph[i];
    }
    delete[] grph;
}

graph& graph::operator=(const graph &rhs)
{
    if (this != &rhs)
    {
        graph tmp(rhs);
        std::swap(grph, tmp.grph);
        std::swap(size, tmp.size);
    }
    return *this;
}

std::ostream& operator<< (std::ostream& out, const graph &g) {
    for (int i = 0; i < g.size; ++i) {
        for (int j = 0; j < g.size; ++j) {
            out << g.grph[i][j] << "\t";
        }
        out << endl;
    }
    return out;
}

change graph to use std::vector instead of allocating the arrays manually. Let the compiler handle all of the memory management and copying for you:

class graph {
public:
    graph(int size = 0);
    friend ostream& operator<< (ostream& out, const graph &g);
private:
    std::vector<std::vector<bool> > grph;
};

std::ostream& operator<< (std::ostream& out, const graph &g);

graph::graph(int size)
{
    grph.resize(size);
    for (int i = 0; i < size; ++i) {
        grph[i].resize(size);
    }
    for (int i = 0; i < size; ++i) {
        for (int j = i; j < size; ++j) {
            if (i == j) {
                grph[i][j] = false;
            } else {
                grph[i][j] = grph[j][i] = (prob() < 0.19);
            }
        }
    }
}

ostream& operator<< (ostream& out, const graph &g) {
    for (int i = 0; i < g.grph.size(); ++i) {
        std:::vector<bool> &row = g.grph[i];
        for (int j = 0; j < row.size(); ++j) {
            out << row[j] << "\t";
        }
        out << endl;
    }
    return out;
}

How do I overload the << operator to print a class member?

3 Answers3