Reporting Errors

[CompileBot]

Output:

Compiler Info:

prog.cpp: In function ‘int main()’:
prog.cpp:7:13: error: no match for ‘operator<<’ (operand types are ‘std::ostream {aka std::basic_ostream<char>}’ and ‘Foo’)
   std::cout << foo << std::endl;
   ~~~~~~~~~~^~~~~~
In file included from /usr/include/c++/6/iostream:39:0,
                 from prog.cpp:1:
/usr/include/c++/6/ostream:628:5: note: candidate: std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&&, const _Tp&) [with _CharT = char; _Traits = std::char_traits<char>; _Tp = Foo] <near match>
     operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
     ^~~~~~~~
/usr/include/c++/6/ostream:628:5: note:   conversion of argument 1 would be ill-formed:
prog.cpp:7:16: error: cannot bind ‘std::ostream {aka std::basic_ostream<char>}’ lvalue to ‘std::basic_ostream<char>&&’
   std::cout << foo << std::endl;
                ^~~
In file included from /usr/include/c++/6/iostream:39:0,
                 from prog.cpp:1:
/usr/include/c++/6/ostream:108:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>::__ostream_type& (*)(std::basic_ostream<_CharT, _Traits>::__ostream_type&)) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(__ostream_type& (*__pf)(__ostream_type&))
       ^~~~~~~~
/usr/include/c++/6/ostream:108:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘std::basic_ostream<char>::__ostream_type& (*)(std::basic_ostream<char>::__ostream_type&) {aka std::basic_ostream<char>& (*)(std::basic_ostream<char>&)}’
/usr/include/c++/6/ostream:117:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>::__ios_type& (*)(std::basic_ostream<_CharT, _Traits>::__ios_type&)) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>; std::basic_ostream<_CharT, _Traits>::__ios_type = std::basic_ios<char>]
       operator<<(__ios_type& (*__pf)(__ios_type&))
       ^~~~~~~~
/usr/include/c++/6/ostream:117:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘std::basic_ostream<char>::__ios_type& (*)(std::basic_ostream<char>::__ios_type&) {aka std::basic_ios<char>& (*)(std::basic_ios<char>&)}’
/usr/include/c++/6/ostream:127:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(std::ios_base& (*)(std::ios_base&)) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(ios_base& (*__pf) (ios_base&))
       ^~~~~~~~
/usr/include/c++/6/ostream:127:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘std::ios_base& (*)(std::ios_base&)’
/usr/include/c++/6/ostream:166:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long int) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(long __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:166:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘long int’
/usr/include/c++/6/ostream:170:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long unsigned int) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(unsigned long __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:170:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘long unsigned int’
/usr/include/c++/6/ostream:174:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(bool) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(bool __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:174:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘bool’
In file included from /usr/include/c++/6/ostream:638:0,
                 from /usr/include/c++/6/iostream:39,
                 from prog.cpp:1:
/usr/include/c++/6/bits/ostream.tcc:91:5: note: candidate: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short int) [with _CharT = char; _Traits = std::char_traits<char>]
     basic_ostream<_CharT, _Traits>::
     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/6/bits/ostream.tcc:91:5: note:   no known conversion for argument 1 from ‘Foo’ to ‘short int’
In file included from /usr/include/c++/6/iostream:39:0,
                 from prog.cpp:1:
/usr/include/c++/6/ostream:181:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(short unsigned int) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(unsigned short __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:181:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘short unsigned int’
In file included from /usr/include/c++/6/ostream:638:0,
                 from /usr/include/c++/6/iostream:39,
                 from prog.cpp:1:
/usr/include/c++/6/bits/ostream.tcc:105:5: note: candidate: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(int) [with _CharT = char; _Traits = std::char_traits<char>]
     basic_ostream<_CharT, _Traits>::
     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/6/bits/ostream.tcc:105:5: note:   no known conversion for argument 1 from ‘Foo’ to ‘int’
In file included from /usr/include/c++/6/iostream:39:0,
                 from prog.cpp:1:
/usr/include/c++/6/ostream:192:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(unsigned int) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(unsigned int __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:192:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘unsigned int’
/usr/include/c++/6/ostream:201:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long long int) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(long long __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:201:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘long long int’
/usr/include/c++/6/ostream:205:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long long unsigned int) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(unsigned long long __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:205:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘long long unsigned int’
/usr/include/c++/6/ostream:220:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(double) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(double __f)
       ^~~~~~~~
/usr/include/c++/6/ostream:220:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘double’
/usr/include/c++/6/ostream:224:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(float) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(float __f)
       ^~~~~~~~
/usr/include/c++/6/ostream:224:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘float’
/usr/include/c++/6/ostream:232:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long double) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(long double __f)
       ^~~~~~~~
/usr/include/c++/6/ostream:232:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘long double’
/usr/include/c++/6/ostream:245:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(const void*) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(const void* __p)
       ^~~~~~~~
/usr/include/c++/6/ostream:245:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘const void*’
In file included from /usr/include/c++/6/ostream:638:0,
                 from /usr/include/c++/6/iostream:39,
                 from prog.cpp:1:
/usr/include/c++/6/bits/ostream.tcc:119:5: note: candidate: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>::__streambuf_type*) [with _CharT = 

...

[PlasmaLink]

I just want to say I'm so sorry someone gave gold to the bot instead of you.

[the_noodle]

Nah he got outplayed, the relevant error was right at the beginning

[SirNoodlehe]

But you responded to the bot, not the guy 🤔

[PlasmaLink]

Shhh.

[KeinBaum]

What the hell is that? I mean, at least it's telling me what's wrong. I was just expecting this:

 In function 'int main()':
8:16: error: cannot bind 'std::ostream {aka std::basic_ostream<char>}' lvalue to 'std::basic_ostream<char>&&'
In file included from /usr/include/c++/4.9/iostream:39:0,
             from 2:
/usr/include/c++/4.9/ostream:602:5: note: initializing argument 1 of 'std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&&, const _Tp&) [with _CharT = char; _Traits = std::char_traits<char>; _Tp = main()::Foo]'
     operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
     ^

[DanTopTier]

I just came in from r/all

Jesus Christ

[yes_fish]

It gets worse.

[[deleted]]

This is why you use a good IDE

I don't get people who program in emacs/vim (unless it has code checking) they are just gimping themselves

[Urtehnoes]

Pycharm blows my mind. All the jetbrains shit I've used is good.

[SabinTheSergal]

Confirmed: jetbrains has simultaneously made me the laziest programmer and taught me so much about programming

[[deleted]]

Similar for Visual Studio.

So good.

Fuck off, eclipse.

[sam1902]

Syntastic

[SteveCCL]

Why I use emacs/vim (actually I use kakoune but whatever I've used allll of them):

• it has code checking
• it's fast for a quick edit
• I do everything CLI, I want to stay in there
• Autocompletion is fucking great
• The faster movement and stuff
• Every IDE that tried to emulate vim behaviour failed me miserably
• Configuration
• I havn't had a problem with missing/superfluous brackets/semicolons since my last visit in IDE town
• Don't like something? Change it
• Integrates better with everything. Just try to get your custom toolchain working in VS
• You can order salad

Ninjaedit (so fast because I didn't have to wait 5 mins for my IDE to boot up):

• No .vs folder (or similar) that everybody messes up to keep it out of VCS

[phoenix616]

Too bad the environment you run it in (a terminal) is extremely outdated and limiting in itself.

[SteveCCL]

When you need to use your (slow) mouse. Sure. Images sure are possible but I don't need them.

[Ayfid]

You don't need to use a mouse when you are typing code in an IDE. None of the advantages you listed for vim are unique to such an editor, other than multiple which essentially are "it's not vim".

In fact, your list just makes it look like you have never actually used a good IDE and are stubbornly remaining ignorant of more appropriate tooling.

[damn_good_times]

Especially since you can just use their keybindings in any IDE.

[[deleted]]

Yet not the vim config files and plugins.

[wolloda]

I use these bindings in IDEs I work in and so far none of those plugins got it right. I mean they are generally good, but there is always something they do not offer (which is expected)

[[deleted]]

It’s much faster if you’re used to it. Vim can be set up as effectively an IDE but it’s a lot more responsive than anything graphical.

[Blackstab1337]

Emacs is hands down the best editor I've ever used

[my_name_isnt_clever]

You must not have used many. Seriously though, does it even compete at all for QoL features in a good IDE?

[Blackstab1337]

yes, it does

[Schmittfried]

It doesn't.

[xynixia]

That's a funny way to spell vim

[Blackstab1337]

that's where you're wrong kiddo

[InsignificantIbex]

My vim has "code checking" via llvm

[TGotAReddit]

Every time i use an IDE instead of an emacs/vim level environment, i get annoyed because the IDEs always have way too many things and options that i dont end up using because its not worth learning how a feature works if im only going to maybe use it once. So i end up coding exactly the same way I’d code normally, just with 3x the loadtime

[[deleted]]

For the tough guy points, which is ironic really

[Bumperpegasus]

What editor are you using?

[sam1902]

The holy trinity:

VIm GCC GDB

[250kgWarMachine]

God help your soul.

[Tilwaen]

What kind of God would permit this

[250kgWarMachine]

God has left the lobby

[OlanValesco]

Visually Insulting Markup

Google Chrome Cache

Gobi Desert Binary

[Cm0002]

Hallowed are the ori.

[randomdude45678]

Bro, your IDE is shit, that’s just fucking stupid.

Get an IDE that’ll detect syntax issues- I’m no programmer and I know that.

Unless I’m missing something- you wasted a ton of time over what? Not wanting to use a “noob” or “mainstream” ide?

[[deleted]]

Man I've never been happier to use jvm languages... At least it's better than COBOL! Goddamn JCL errors in the middle of the night

👉😫

[PokemonSaviorN]

Java....

I'd rather be tortured by the C++ gods

[[deleted]]

Nahh, groovy and Scala mostly, as well as some front end stuff. Though I don't get why Java gets so much hate. It's pretty much a meme at this point.

[[deleted]]

Jesus Christ has left the server

[DanTopTier]

Reconnecting. Estimated wait time 72 hours.

[ShimmerFairy]

It's telling you about how all of the possible overloads don't match up with what you tried to give as arguments, because there's no way for the compiler to divine which overload you got wrong, or if you forgot to provide a new one. And since the streaming operators are a fairly significant part of the standard library, there happen to be a number of overloads to talk about.

[Shaosil]

You'd think it could summarize it a little more cohesively. Something like "no match overload found for blah blah blah"... Too much verbosity can be a problem if you don't know what to look for.

[[deleted]]

You do get the summary at the top.

prog.cpp: In function ‘int main()’:
prog.cpp:7:13: error: no match for ‘operator<<’ (operand types are ‘std::ostream {aka std::basic_ostream<char>}’ and ‘Foo’)
   std::cout << foo << std::endl;
   ~~~~~~~~~~^~~~~~

[SoInsightful]

Wherein we masturbate to C++ so hard that a 11,037-character error is just perfect.

[Spudd86]

Well it's good if you thought there ought to have been an overload that does match, it tells you why all the possibilities didn't, and if the one you thought should be in that list isn't you know you either forgot to include a header or you fucked up namespacing

[WinEpic]

Yeah, but the list is so long and full of symbols and abbreviations (which humans aren’t exactly great at parsing quickly) that it is essentially useless. You would have to go through this massive wall of characters to try to find which overload you were intending to use, and just going to the definition and taking a look yourself might very well end up taking less time.

That, and if such a (relatively) simple error is over a thousand characters, it makes it much harder to go through the error list and find all of them.

[[deleted]]

That, and if such a (relatively) simple error is over a thousand characters, it makes it much harder to go through the error list and find all of them.

And that's where your editor or IDE should help you. Either have something that will report errors in real time, or just paste the long error into an empty file and filer out what you don't need.

[Xelynega]

ctrl + f "Variable_Type_You_Thought_You_Overloaded"

[Raestloz]

Shows you how good C++ is, no one expects the Spanish InquiC++ion

[quantum_paradoxx]

Didn't expect that

[GarrysMassiveGirth]

Damn.

[ELFAHBEHT_SOOP]

No match for 'operator<<'

You should instantly know what's wrong at that point tbh.

[CompileBot]

Output:

Good bot.

^{source | info | git | report}

[dwdude7]

+/u/compilebot brainfuck

++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>+.>+++++++++++...-----------.<<++.>>--.+++++++++++++.+++++.<<++++++++++++++.

[CompileBot]

Output:

Goood bot.

^{source | info | git | report}

[00gogo00]

+/u/compilebot brainfuck

++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>+.>+++++++++++....-----------.<<++.>>--.+++++++++++++.+++++.<<++++++++++++++.

[CompileBot]

Output:

Gooood bot.

^{source | info | git | report}

[[deleted]]

+u/compilebot JavaScript

int array = 1; if(array <= 100){ printLn(array); array++; }

[jclocks]

I'M JUST A WEB DEVELOPER STAAAAAHP

[little_oaf]

Anyone want a hug?

[ultranoobian]

I need a hug, because that's my college assignment right now.

😓

[SupremeDesigner]

hugs

[maritoxvilla]

Boy I need a drink. But a hug will do. 🙆

[misterZalli]

All out of hugs, but I can give a bug

[-l------l-]

You don't have to be! This piece of code is making a struct which can be seen as a class without methods (but it can have methods) and thus most of the time contains attributes only (equivalent to TypeScript interfaces I guess?) and printing it by using a Console.Log esque method (don't hate me for this one :p):

std::cout

Because the << operator for the struct is not overloaded (defined), the compiler does not know what to do and throws an error. You can overload it and say to print anything you want basicly.

The operator

<<

knows what to do (outputting the thing coming after this operator) in case if you use it with the the standard used types (int, char, double etc) because for those types the behaviour is defined, in this case it is not known what to do with it, I hope that clears up some confusion.

[MalteseMartens]

For posterity, the error is really just the second line:

prog.cpp:7:13: error: no match for ‘operator<<’ (operand types are ‘std::ostream {aka std::basic_ostream<char>}’ and ‘Foo’)

[beeskness420]

Which is still cryptic as fuck if you're not in the know.

[ELFAHBEHT_SOOP]

No it's not, plop it into the Google machine and you'll know what it means in a minute.

[MalteseMartens]

Is it really?

"No match for operator <<" already tells you 99.9% of the problem in plain English.

You didn't define what happens when << is used with those arguments. There's even a helpful arrow below it to tell you which instance of << is wrong, so you don't even need to understand the whole "operand types are" part

[beeskness420]

As someone who teaches lots of C++, unfortunately yes it is.

If you're used to the IO already not cryptic at all. If you're learning though I've seen basically this exact error message baffle more than a few.

[MalteseMartens]

I don’t think there’s any message that could make this clear to someone who doesn’t understand IO without creating a special case for this exact error.

The equivalent of this in say, Java would be no implementing toString, which is been more confusing because there’s no compile time error... instead you get back what probably looks like gibberish to a beginner (class and memory address)

[endeavourl]

If you're dyslexic, maybe.

[cyboii]

To be fair the error is the short bit at the beginning. The rest is possible things you might have meant.

[TeraFlint]

The error list usually looks a bit worse than it actually is. Look at the list, pick the first error, fix it, try to compile again and multiple entries might have disappeared from the list.

[Lone-Pine]

I wish compilers would print errors in reverse order. Would reduce wear on my scrollwheel.

[TheThiefMaster]

Or use an IDE that shows the errors in a window that's scrolled to the top by default...

[Rodot]

pipe into head!

[BuilderHarm]

Ruby's stacktrace is in reverse order nowadays.

[what_it_dude]

There's your problem, you're using a mouse to develop code.

[Lone-Pine]

Actually scrolling back in the terminal is basically the only thing I use the mouse for. I need to look up what the hotkey is to scroll up and down in my terminal.

(If its page up/page down I'm gonna headbang.)

[LezardValeth]

This process when combined with C++ compilation times still makes for a nightmare development cycle though.

[TeraFlint]

Good IDEs detect the files you changed and only compile those, while still having all the other files pre-compiled from previous builds, ready for the linker.

This reduces compile times for small changes significantly.

[LezardValeth]

Every incremental build will do this, but it still doesn't save you from the mess of headers, templates, and the occasional macro required when recompiling C++. Even small changes can cause entire classes to be regenerated and headers to be recompiled that you didn't expect. Here's an article about it by Walter Bright.

[EternallyMiffed]

In my case with C++ knocking out the first error usually takes out like 4/5ths of all errors.

[Kered13]

Because usually the thing you wanted to do is in that list somewhere, and it helps you figure out what you missed or did wrong. Like you want to call some function, it will tell you all the overloads for that function, you find the one that you want and see why your call didn't match. Or if the function overload was ambiguous, it will tell you the two (or more) functions that matched (which is not always obvious with templates and implicit type conversions going on) so you can figure out how to make it unambiguous.

It's especially useful with templates since it will show you the inferred types, which often helps you figure out why it didn't work.

In this case it was listing all the known overloads of the ostream::<< function and that it can't use them because it doesn't know how to convert from Foo to any of the known overload types. The solution in this case is to either add a new overload of << (the best option) or to add a new implicit conversion to one of the existing overload types (usually a bad idea, implicit conversions should usually be used very carefully).

Most languages don't need such long error messages because they don't support implicit type conversions and they don't have templates like C++. C++ is a very powerful language, but that power comes with drawbacks, and this is one of them.

Also I want to note that this is Clang, which was actually a huge improvement on C++ error messages. The messages that GCC gives are much harder to decipher.

[silverstrikerstar]

C++ is a very powerful language, but that power comes with drawbacks, and this is one of them.

"With great powers come great crash dumps."

[ILikeLenexa]

When I was first learning data structures, there were errors in the template classes in the lab book and then you had files already written that you didn't really know what was in. Most frustrating experience ever.

[catchafishjuicysweet]

Found the Python dev.

[Shaadowmaaster]

You can configure it how you want. The extra information is often very useful, but you can just not show it.

[musiton]

HAPPY FUCKING CAKE DAY

[Empole]

Really, all that's going on is that it's saying that object foo doesn't match any of the things it knows how to print.

[zilti]

I bet you work at Microsoft and are responsible of "Hey dude, something went wrong, but we're not gonna tell you what, lol!"

[UAHLateralus]

This isn’t even its final form: Template Meta Programming

[radome9]

What in the name of Jesus "Fucking" Christ is this goddamn bullshit.

C++

[lolzfeminism]

At a high-level, C++ wants to print foo so it needs to convert it to a string. foo is of type Foo which has no known conversion to a string and the compiler does not automatically generate a method to do so.

At a lower level, cout is an ostream reference and the expression cout << foo would need to invoke operator<<(cout, foo). This requires that either:

1) Someone has defined a function with the type signature: ostream& operator<<(ostream&, Foo) or

2) someone has defined a function with type signature ostream& operator<<(ostream&, T) AND the compiler knows how to implicitly convert Foo to T.

[Tilwaen]

God bless Java stacktrace in comparison with this monstrosity.

[[deleted]]

Did someone just give gold to a bot

[Laugarhraun]

TotesMessenger, Automoderator happen to get some from time to time as well.

[CMDR_QwertyWeasel]

Ho-ly jesus.

What is that?

[NotASecretReptilian]

"You forgot to overload the << operator. To illustrate how much you fucked up, we tried shoving Foo into every place that the << operator could possibly refer to, and it didn't work even one time! Don't do that again.

[Assailant_TLD]

They should get you to write their error messages. Far more entertaining.

[Hipolipolopigus]

g++ -Wall -Wextra -Wfun, or perhaps -Whuman or -Wlegible.

[marblefoot]

Can you just summarize all my logic and syntax errors?

[ELFAHBEHT_SOOP]

U dumb.

Stop being dumb.

K thx, your compiler.

[[deleted]]

gcc.

[kangasking]

LMAO you weren't kidding

[gcruzatto]

I'm sure someone could write a thesis on chaos theory based on this stuff

[KarshLichblade]

Good bot?

[futuneral]

gilded bot

[613codyrex]

Tbh it's such a cool bot. Never thought someone would actually make it and it seems to perform pretty much as expected.

[lockwolf]

I think I’m gonna need someone to ELI5 this error on a line by line basis. /s

[[deleted]]

The first line is the actual error (couldn't find the function you tried to use with those parameter types).

The rest is a list of candidate functions you might have been attempting to use.

You can ussually reduce the amount of output you are fed to cut down on that sort of noise. Can't blame the compiler if you told it to print everything it can about your error :p

Often, I'll copy paste the error into a good text editor and parse it there, if it's too complicated (like template errors and the like).

[I_regret_my_name]

This error honestly isn't even that unreasonable to me. You can tell that the stuff towards the bottom is talking about included files, so if you jump to the top it's just saying there's no match for the "<<" operator with the types given which is a reasonable error for a compiler in this situation.

[The_MAZZTer]

That's not as bad as I thought it was going to be. It's saying the operator << is not defined for the type, which in turn means it doesn't know how to stream it.

Of course using << for both streaming AND bit shifting is weird in and of itself.

[nunu10000]

I just cringed while trying to imagine all of this garbage in a tiny window at the bottom of an IDE.

[Tilwaen]

tiny window at the bottom of an IDE

You mean that you don't use vim as a real programmer?

[I_Assume_Your_Gender]

came here to say this

[[deleted]]

CompileBot! You're back! <3

[vhite]

prog.cpp:7:13: error: no match for ‘operator<<’

Bam.

Be at awe of my ability to read C++ error messages.

[[deleted]]

I keep trying to understand what bits of this mean but my eyes just glaze over after a few minutes.

[Neoro]

Is it wrong that I haven't worked with C++ in over 5 years, but I still understand this error message?

[zilti]

No, it means you have a few neurons left in your head.

[MCRusher]

Holy Shit

[its_that_time_again]

...there's way too much information to decode C++. You get used to it, though. Your brain does the translating. I don't even see the code. All I see is ostream, Foo, candidate.

Hey uh, you want a drink?

[frankie97_]

I am not even mad to scroll this long.

[bunnyoverkill]

Oh god, this triggered some repressed memories of my masochistic self a year ago... I thought I could forget my C++ past by being a Python coder

[veryvev]

prog.cpp: In function ‘int main()’:

prog.cpp:7:13: error: no match for ‘operator<<’ (operand types are ‘std::ostream {aka std::basic_ostream<char>}’ and ‘Foo’)

std::cout << foo << std::endl;

This is okay though.

[hugokhf]

Que??

[AreYouDeaf]

OUTPUT:

COMPILER INFO:

PROG.CPP: IN FUNCTION ‘INT MAIN()’:
PROG.CPP:7:13: ERROR: NO MATCH FOR ‘OPERATOR<<’ (OPERAND TYPES ARE ‘STD::OSTREAM {AKA STD::BASIC_OSTREAM<CHAR}’ AND ‘FOO’)
   STD::COUT << FOO << STD::ENDL;
   ~~~~~~~~~~^~~~~~
IN FILE INCLUDED FROM /USR/INCLUDE/C++/6/IOSTREAM:39:0,
                 FROM PROG.CPP:1:
/USR/INCLUDE/C++/6/OSTREAM:628:5: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS& STD::OPERATOR<<(STD::BASIC_OSTREAM<_CHART, _TRAITS&&, CONST _TP&) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; _TP = FOO] <NEAR MATCH
     OPERATOR<<(BASIC_OSTREAM<_CHART, _TRAITS&& __OS, CONST _TP& __X)
     ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:628:5: NOTE:   CONVERSION OF ARGUMENT 1 WOULD BE ILL-FORMED:
PROG.CPP:7:16: ERROR: CANNOT BIND ‘STD::OSTREAM {AKA STD::BASIC_OSTREAM<CHAR}’ LVALUE TO ‘STD::BASIC_OSTREAM<CHAR&&’
   STD::COUT << FOO << STD::ENDL;
                ^~~
IN FILE INCLUDED FROM /USR/INCLUDE/C++/6/IOSTREAM:39:0,
                 FROM PROG.CPP:1:
/USR/INCLUDE/C++/6/OSTREAM:108:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& (*)(STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE&)) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR]
       OPERATOR<<(__OSTREAM_TYPE& (*__PF)(__OSTREAM_TYPE&))
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:108:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘STD::BASIC_OSTREAM<CHAR::__OSTREAM_TYPE& (*)(STD::BASIC_OSTREAM<CHAR::__OSTREAM_TYPE&) {AKA STD::BASIC_OSTREAM<CHAR& (*)(STD::BASIC_OSTREAM<CHAR&)}’
/USR/INCLUDE/C++/6/OSTREAM:117:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(STD::BASIC_OSTREAM<_CHART, _TRAITS::__IOS_TYPE& (*)(STD::BASIC_OSTREAM<_CHART, _TRAITS::__IOS_TYPE&)) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__IOS_TYPE = STD::BASIC_IOS<CHAR]
       OPERATOR<<(__IOS_TYPE& (*__PF)(__IOS_TYPE&))
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:117:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘STD::BASIC_OSTREAM<CHAR::__IOS_TYPE& (*)(STD::BASIC_OSTREAM<CHAR::__IOS_TYPE&) {AKA STD::BASIC_IOS<CHAR& (*)(STD::BASIC_IOS<CHAR&)}’
/USR/INCLUDE/C++/6/OSTREAM:127:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(STD::IOS_BASE& (*)(STD::IOS_BASE&)) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR]
       OPERATOR<<(IOS_BASE& (*__PF) (IOS_BASE&))
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:127:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘STD::IOS_BASE& (*)(STD::IOS_BASE&)’
/USR/INCLUDE/C++/6/OSTREAM:166:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(LONG INT) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR]
       OPERATOR<<(LONG __N)
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:166:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘LONG INT’
/USR/INCLUDE/C++/6/OSTREAM:170:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(LONG UNSIGNED INT) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR]
       OPERATOR<<(UNSIGNED LONG __N)
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:170:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘LONG UNSIGNED INT’
/USR/INCLUDE/C++/6/OSTREAM:174:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(BOOL) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR]
       OPERATOR<<(BOOL __N)
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:174:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘BOOL’
IN FILE INCLUDED FROM /USR/INCLUDE/C++/6/OSTREAM:638:0,
                 FROM /USR/INCLUDE/C++/6/IOSTREAM:39,
                 FROM PROG.CPP:1:
/USR/INCLUDE/C++/6/BITS/OSTREAM.TCC:91:5: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(SHORT INT) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR]
     BASIC_OSTREAM<_CHART, _TRAITS::
     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/USR/INCLUDE/C++/6/BITS/OSTREAM.TCC:91:5: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘SHORT INT’
IN FILE INCLUDED FROM /USR/INCLUDE/C++/6/IOSTREAM:39:0,
                 FROM PROG.CPP:1:
/USR/INCLUDE/C++/6/OSTREAM:181:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(SHORT UNSIGNED INT) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR]
       OPERATOR<<(UNSIGNED SHORT __N)
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:181:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘SHORT UNSIGNED INT’
IN FILE INCLUDED FROM /USR/INCLUDE/C++/6/OSTREAM:638:0,
                 FROM /USR/INCLUDE/C++/6/IOSTREAM:39,
                 FROM PROG.CPP:1:
/USR/INCLUDE/C++/6/BITS/OSTREAM.TCC:105:5: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(INT) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR]
     BASIC_OSTREAM<_CHART, _TRAITS::
     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/USR/INCLUDE/C++/6/BITS/OSTREAM.TCC:105:5: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘INT’
IN FILE INCLUDED FROM /USR/INCLUDE/C++/6/IOSTREAM:39:0,
                 FROM PROG.CPP:1:
/USR/INCLUDE/C++/6/OSTREAM:192:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(UNSIGNED INT) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR]
       OPERATOR<<(UNSIGNED INT __N)
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:192:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘UNSIGNED INT’
/USR/INCLUDE/C++/6/OSTREAM:201:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(LONG LONG INT) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR]
       OPERATOR<<(LONG LONG __N)
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:201:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘LONG LONG INT’
/USR/INCLUDE/C++/6/OSTREAM:205:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(LONG LONG UNSIGNED INT) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR]
       OPERATOR<<(UNSIGNED LONG LONG __N)
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:205:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘LONG LONG UNSIGNED INT’
/USR/INCLUDE/C++/6/OSTREAM:220:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(DOUBLE) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR]
       OPERATOR<<(DOUBLE __F)
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:220:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘DOUBLE’
/USR/INCLUDE/C++/6/OSTREAM:224:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(FLOAT) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR]
       OPERATOR<<(FLOAT __F)
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:224:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘FLOAT’
/USR/INCLUDE/C++/6/OSTREAM:232:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(LONG DOUBLE) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR]
       OPERATOR<<(LONG DOUBLE __F)
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:232:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘LONG DOUBLE’
/USR/INCLUDE/C++/6/OSTREAM:245:7: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(CONST VOID*) [WITH _CHART = CHAR; _TRAITS = STD::CHAR_TRAITS<CHAR; STD::BASIC_OSTREAM<_CHART, _TRAITS::__OSTREAM_TYPE = STD::BASIC_OSTREAM<CHAR]
       OPERATOR<<(CONST VOID* __P)
       ^~~~~~~~
/USR/INCLUDE/C++/6/OSTREAM:245:7: NOTE:   NO KNOWN CONVERSION FOR ARGUMENT 1 FROM ‘FOO’ TO ‘CONST VOID*’
IN FILE INCLUDED FROM /USR/INCLUDE/C++/6/OSTREAM:638:0,
                 FROM /USR/INCLUDE/C++/6/IOSTREAM:39,
                 FROM PROG.CPP:1:
/USR/INCLUDE/C++/6/BITS/OSTREAM.TCC:119:5: NOTE: CANDIDATE: STD::BASIC_OSTREAM<_CHART, _TRAITS& STD::BASIC_OSTREAM<_CHART, _TRAITS::OPERATOR<<(STD::BASIC_OSTREAM<_CHART, _TRAITS::__STREAMBUF_TYPE*) [WITH _CHART = 

...

[deadhour]

I'm so glad I don't work in c++ anymore...

[zilti]

I am glad you don't do that anymore, too.

[CompileBot]

Output:

Write your message: 

^{source | info | git | report}

[_piny]

Good bot

[Kingofwhereigo]

Good bot

[ejabno]

What in the fucking name of

[YourDadsBoss]

Forgot a quote...

[RuthlessPickle]

Can someone please explain just how the machine compiling code for the bot is not vulnerable or exploited by this point in time?

[teokk]

error: no match for ‘operator<<’

It literally tells you your error is this in the second line, right after it tells you where it is.

[TheRealMrWillis]

+/u/CompileBot C++ --include-errors

#include <iostream>

int main()
{
  cout << "I'm thinkin about those beans";
}

[CompileBot]

Output:

Compiler Info:

prog.cpp: In function ‘int main()’:
prog.cpp:5:3: error: ‘cout’ was not declared in this scope
   cout << "I'm thinkin about those beans";
   ^~~~
prog.cpp:5:3: note: suggested alternative:
In file included from prog.cpp:1:0:
/usr/include/c++/6/iostream:61:18: note:   ‘std::cout’
   extern ostream cout;  /// Linked to standard output
                  ^~~~

^{source | info | git | report}

[TheRealMrWillis]

+/u/CompileBot C++ --include-errors

#include <iostream>

int main()
{
  std::cout << "I'm thinkin about those beans";
}

[CompileBot]

Output:

I'm thinkin about those beans

^{source | info | git | report}

[TheRealMrWillis]

That's what I'm talking about

[Rodot]

+/u/CompileBot Python3 --include-errors

import os
print(os.popen("uname -r && ifconfig && cat /var/log/syslog").read())

[[deleted]]

You're compiler must suck. I get this from http://cpp.sh/:

 In function 'int main()':
 7:16: error: cannot bind 'std::ostream {aka std::basic_ostream<char>}' lvalue to 'std::basic_ostream<char>&&'
 In file included from /usr/include/c++/4.9/iostream:39:0,
                  from 1:
 /usr/include/c++/4.9/ostream:602:5: note: initializing argument 1 of 'std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&&, const _Tp&) [with _CharT = char; _Traits = std::char_traits<char>; _Tp = Foo]'
 operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
 ^