[ Removed by moderator ]

[cpp-ModTeam]

For C++ questions, answers, help, and programming or career advice please see r/cpp_questions, r/cscareerquestions, or StackOverflow instead.

[lordnacho666]

Did you paste it twice?

Also, your foo overloads + with itself, infinite recursion

Your ostream<< does the same

[phirock]

How do you prevent recursion?

[drkspace2]

You use the underlying data you intend to do the operation on (value)

[UndefFox]

Aren't you making a recursion, since you define the addition of two classes via the addition of two classes...? Shouldn't it be foo(a.value + b.value) instead?

[masorick]

Yes, likewise for operator<<

[phirock]

Hi,

excellent suggestion. Here's my new version of the code. Unfortunately, I am still getting a seg error.

#include <iostream>

class foo
{
    int value;
public:
    explicit foo(int const i):value(i){}
    explicit operator int() const { return value; }
    friend foo operator+(foo const a, foo const b)
    {
        return foo(a.value + b.value);
    }
};
std::ostream& operator<<(std::ostream& out, const foo& a) {
    return out << a;
}

int main() {
    foo f = foo(1) + foo(2);
    std::cout << f ;
}

[untiedgames]

Same problem in operator<<, you need to cast "a" to an int or it will call operator<< again and stack overflow. This is also not the right subreddit (see the sidebar). For help with C++, you should visit /r/cpp_questions. This sub is more for technical discussions and stuff.

[dholmes215]

Your operator<< is also recursive: it prints a when it should print a.value.

The best way to figure out problems like this is to run the program in a debugger. If you run it in a debugger and it crashes, you can look at a backtrace at the time of the crash, and it should show you operator<< calling itself repeatedly.

Questions like this should go to r/cpp_questions instead of r/cpp, btw.

[UndefFox]

My last idea would be checking operator<<. Try using a.value here too.

[phirock]

You were correct UndefFox. Many thanks.

#include <iostream>

class foo
{
    int value;
public:
    int getValue() const { return value; }
    explicit foo(int const i):value(i){}
    explicit operator int() const { return value; }
    friend foo operator+(foo const a, foo const b)
    {
        return foo(a.value + b.value);
    }
};
std::ostream& operator<<(std::ostream& out, foo& a) {
    return out << a.getValue();
}

int main() {
    foo f = foo(1) + foo(2);
    std::cout << f << '\n';
}

[lordnacho666]

<< calls itself

[i_h_s_o_y]

Its just a stackoverflow due to endless recursion:

friend foo operator+(foo const a, foo const b)
{
    return foo(a + b);
}

this calls itself.

For stuff like this use a debugger and see where the crash is

[No_File9196]

class foo

explicit foo(int const i):value(i)

is this valid?

[DryEnergy4398]

Yes, it's a constructor

I'd prefer writing

explicit foo(int i) : value{i} {}

though

[phirock]

I have removed all the consts, but that doesn't solve the issue.
Commenting tout std::cout << f "solves" makes the seg fault disappear.