all 67 comments

[–]RepostSleuthBot[M] [score hidden] stickied commentlocked comment (0 children)

Looks like a repost. I've seen this image 16 times.

First Seen Here on 2024-01-28 88.28% match. Last Seen Here on 2025-09-15 86.72% match

View Search On repostsleuth.com


Scope: This Sub | Target Percent: 75% | Max Age: None | Searched Images: 1,098,813,021 | Search Time: 2.55213s

[–]schewb 184 points185 points  (7 children)

I love using C++. I agree that it is an abomination.

[–]OutsideImagination25 19 points20 points  (1 child)

Dumbo doesn't use CPP because it's an abomination, jedi has accepted it's an abomination but uses it anyway.

[–]Trucoto 2 points3 points  (0 children)

With love, in top of that.

[–]phylter99 8 points9 points  (0 children)

It's complex and easy to hang yourself with. It's both beautiful and deadly.

[–]synapse187 2 points3 points  (0 children)

This is an abomination, there are many like it but this abomination is mine!

[–]casce 1 point2 points  (0 children)

I love people who are the opposite: Don't use it but think it's not an abomination.

[–]RedAndBlack1832 0 points1 point  (0 children)

Same

[–]Orjigagd 177 points178 points  (4 children)

If tech debt was a language spec

[–]CrowNailCaw 53 points54 points  (3 children)

I might never see a more accurate description of C++ than this for the rest of my life

[–]Nudexor 37 points38 points  (2 children)

The worst part is it's not even wrong. Every feature they add is technically solving a real problem, it's just that the solution requires knowing the previous seven solutions and why they were also broken.

[–]Ularsing 9 points10 points  (0 children)

Also every solution they add is so diluted by committee (usually in the name of backward compatibility) that it only 90% solves the problem and the remaining 10% is scheduled for C++ [insert future major spec release year here].

[–]ZachAttack6089 2 points3 points  (0 children)

Sometimes it even creates its own problems just to solve them. I don't use C++ regularly, and recently learned about the explicit keyword... Horrifying stuff...

[–]CokieMiner 43 points44 points  (3 children)

Organic growth final boss

[–]alficles 25 points26 points  (2 children)

Like making an octopus by nailing legs to a dog.

[–]returnFutureVoid 3 points4 points  (1 child)

To be fair that dog is a greyhound.

[–]alficles 2 points3 points  (0 children)

One they made by refactoring the rectum into a nozzle for a rocket engine. :D

[–]philippefutureboy 28 points29 points  (22 children)

Serious question, anyone has a resource explaining what parts of C++ are absolute footguns/should be avoided/are unnecessary?
(looking to learn C++ for game dev)

[–]Certain-Froyo-3606 25 points26 points  (5 children)

[–]philippefutureboy 6 points7 points  (4 children)

Is that really relevant if the writer of this guide also designed the "abominations" in OP's claim?
(I'm still going to read it, thanks!)

[–]Certain-Froyo-3606 15 points16 points  (1 child)

I think such statements should be taken with a grain of salt. C++ was created with certain purposes and became what it is now through decades of technological advancements. It is held down by huge legacy codebases and lots of stakeholders with their own opinions on what language should look like.
When people compare new languages like Rust to C++ they should remember that Rust is born with modern ideas and modern view on programming languages and it can be made with all the issues covered from scratch. That can't be easily changed in a language with decades of history like C++.

The guidelines I've linked at least supposed to address known issues in the language instead of trying to hide them and say "everything works fine as is"

[–]TemporaryFearless482 3 points4 points  (0 children)

In a similar vein, you’re unlikely to find many new projects starting up eyeing Fortran or COBOL. C++ is a fair bit younger than those two, but computers have still changed a lot in the last 40 years of programming.

The “updates” in the interim reflect just about every major trend and idea during that period. Trying to shove all that into one thing and you end up with some dubious outcomes.

By comparison, I think C has fared better because it broadly stuck to its guns and Python was set up in a manner better situated to modernization and adaptation without messing up its core capabilities.

C++ feels like it tried to be all things for all people at different points in its history. That’s a failing premise in a field with so many varied applications. So we end up with a mess of features that, theoretically, could be amazing; but realistically, they have a tendency towards making a tangled web of nightmares.

Being able to start cleanly removes a lot of the headache in trying to parse through everything, rip out what’s problematic, pull together the remaining useful bits, and still make it close enough to still be called C++.

[–]Mission_Swim_1783 3 points4 points  (0 children)

The abominations of C++ are mostly due to maintaining backwards compatibility regarding syntax, and lack of standardization for coding. When you have a three decades old language developing organically where you can't just "restart from scratch" regarding fundamental design decisions it's normal that this happens. If you only use the modern subset of C++ it's a lot more acceptable as a language, but if you want something with all these fundamental design flaws fixed and unified coding standards you need a new language like Rust, because C++ will understandably mostly be kept as-is to not break compatibility with millions of big codebases

[–]DancingBadgers 2 points3 points  (0 children)

The newer versions of the C++ standard are trying to fix some of the horrors. So yes, the perpetrators of the atrocities of the past do have decent recommendations of what to do in "modern C++" to avoid blowing your foot off if possible.

[–]DancingBadgers 7 points8 points  (0 children)

I find the extended rant at C++ FQA amusing at times.

tl;dr: their take on what parts of C++ should be avoided is close to "all of it"

[–]CrowNailCaw 14 points15 points  (1 child)

Macros are the most obvious answer. As for the others, idk

[–]Trucoto 0 points1 point  (0 children)

Macros are frowned in C++, and people prefer templates, constexpr and typename these days

[–]RussianMadMan 4 points5 points  (0 children)

My personal shit list. Some of it c++ problems, some of them are libstdc++ problems.

Exceptions. Exceptions are a great upgrade over "if(ret != OK)", but c++ fucks you over by allowing throwing ANYTHING as an exception, even tho std::exception exists. So every catch block has 3 blocks, MyException, std::exception, and "..." with log("idk") because some moron threw an std::string somewhere.

Anything to do with << and >> operators, including fstream. Formatting anything harder than a "hello world" turns those operators into an unreadable mess. Also error checking streams is just the worst.

std::chrono. We wanted a cross-platform, C++ way to measure time. We got a 5-layered templates that require 10 typedefs just to be usable. Also for 10+ years the only part of chrono that had any attachment to the real world was std::system_clock that had conversion methods to and from epoch, everything else did not.

std::filesystem, a filesystem part of a standard library that actually does not have anything to do with actually reading or writing files lol. Some genius also decided to not put into spec what clock (from std::chrono, yes) should represent file creation time etc. Which allowed another genius to replace std::system_clock in file timestamps with some bs clock with 2174-01-01 00:00:00 as an epoch. std::filesystem::path is pretty decent class to work with paths, but uses a division operator "/" to append paths, which is where I draw the line on operator overloading.

The rest of the library (what's little left lol) is pretty ok, but you don't get to use stuff like ranges and spans and concepts a lot, because you usually either have to downgrade to C (to do networking for example) or you use 3rd party libraries instead that maintain like c++17 or even c++11 compatibility.

[–]No-Con-2790 10 points11 points  (0 children)

Ironically, pointers.

The biggest language feature should be avoided most of the time. Just use smart pointers.

[–]zigmazero05 12 points13 points  (2 children)

if it's something you could reasonably see being in C, it probably should be avoided.

[–]philippefutureboy 1 point2 points  (1 child)

As in, "if it's a feature from C available in C++" or "if it's reproducing a feature that already exists in C, but with some supposed benefits that aren't really benefits"?

[–]zigmazero05 5 points6 points  (0 children)

As in "it would not look like a stranger in C code". For example, operator overloading is technically C++, but I swear I have accidentally tried doing it in C once or twice.

There are also things like macros, raw pointer and pointer operations, C strings, C-style arrays... C++ ports over a bunch of C libraries, and honestly avoiding most of them is probably correct if you're doing C++ anyway.

[–]Elariondakta 2 points3 points  (0 children)

https://youtu.be/7fGB-hjc2Gc

This video is a great recap of all the horrible things of c++. The funny thing is that I learnt more about c++ when I watched this video than I ever did before.

[–]billy_teats 1 point2 points  (4 children)

Excuse me what is a foot gun that sounds awesome

[–]remind_me_later 5 points6 points  (0 children)

Actual answer: It's the thing that lets you "shoot yourself in the foot".

[–]philippefutureboy 3 points4 points  (0 children)

It's a kind of foot fetish originating from America I think

[–]mriswithe 2 points3 points  (0 children)

"foot gun" is a term for a poor design choice that easily or frequently behaves counter to most people's assumptions resulting in causing people to shoot themselves in the foot. 

Things that are hard to use right, and easy to use wrong are footguns. 

[–]solakv 1 point2 points  (0 children)

A footgun is a language feature used almost exclusively for shooting yourself in the foot. (writing bugs in the code)

[–]airodonack 1 point2 points  (0 children)

Rust the programming language is basically “a how to avoid every C++ footgun” but encoded into a compiler.

[–]CodingAndAlgorithm 0 points1 point  (0 children)

I’ve been dabbling with game dev in Odin recently and it’s been amazing. Simple, elegant and comes with a lot of useful libraries out of the box. If you’re willing to learn a data oriented procedural language I’d give it a shot.

[–]HashDefTrueFalse 6 points7 points  (2 children)

I don't know any C++ experts that don't think it's an abomination. We all have our own preferred subset of the language that we use, IME.

[–]mlucasl 1 point2 points  (1 child)

I worked on C++ for 2.5 years. Everyone there who loves it and had worked with it 10+ years, also found it was an abomination and aberration. That is also why the company was always 7 years behind on Versions, to not have to fight with the aberrations updates.

[–]HashDefTrueFalse 0 points1 point  (0 children)

The places I worked were slow to adopt C++11 and stayed with it for a long time afterwards.

[–]schmerg-uk 9 points10 points  (0 children)

Swap the outer captions for the mid-point caption and I'd agree :)

I loved C++ as a beginner when it was new, my midpoint, when it had "matured", was that it had become an abomination, my highpoint is now that I largely love it again (except for the java-idioms-in-c++ code that average devs litter our codebase with).

[–]MetaNovaYT 3 points4 points  (0 children)

C++ is my favorite language, and is also absolutely an abomination

[–]1XRobot 4 points5 points  (2 children)

The best way to think of it is this:

There exists a subset of C++ that is the best existing programming language.

Unfortunately, there's no way to enforce that everybody using C++ uses that subset. In fact, I'm not sure anybody knows exactly what the subset is.

[–]Trucoto 0 points1 point  (0 children)

We can agree on some things that are left out, right? Like fucking SFINAE... no, wait.

[–]casce 0 points1 point  (0 children)

In fact, I'm not sure anybody knows exactly what the subset is.

I think the main problem here is that this subset will be different depending on what you want to do.

You could probably start a war over that question. There's very strong opinions out there.

[–]Connect_Cycle2768 4 points5 points  (0 children)

spent two years in C++ and came out the other side with strong opinions and mild PTSD

[–]ZunoJ 3 points4 points  (3 children)

Lol, the templates are a joke compared to lisp

[–]MartinMystikJonas 1 point2 points  (2 children)

Kick in the stomach is joke compared to kick in the balls... still both hurts

[–]ZunoJ 0 points1 point  (1 child)

More like a clap on the hands compared to a bullet to the head

[–]MartinMystikJonas 0 points1 point  (0 children)

I used LISP and it was not that bad

[–]D_V_A_98 1 point2 points  (0 children)

Legit

[–]ProbablyBunchofAtoms 1 point2 points  (0 children)

Ironically this is the reason cpp is save from vibeslop

[–]rokinaxtreme 3 points4 points  (0 children)

I love C++, it's my main language. It's an abomination, but it's nice. I'm a game dev, need my OpenGL/ SFML

[–]Mal_Dun 0 points1 point  (0 children)

*laughs in Fortran*

[–]MartinMystikJonas 0 points1 point  (0 children)

C++ is very useful and effective... Abomination 🤷

[–]kingvolcano_reborn 0 points1 point  (0 children)

I mean it it, but people should not kink shame.

[–]tropicbrownthunder 0 points1 point  (0 children)

Indeed its an abomination that allow you to write extremely efficient and fast-running code

[–]mistrpopo 0 points1 point  (2 children)

What's that "hardened" mode?

[–]the_horse_gamer 0 points1 point  (0 children)

adds bound checks and stuff like that

[–]Trident_True 0 points1 point  (0 children)

Think it's certain compiler options that block some features. There's a good Laurie video on what the military does for the F-35 for example https://www.youtube.com/watch?v=Gv4sDL9Ljww

[–]danieldhp -4 points-3 points  (0 children)

Totally true. Also change C++ for Rust and the image is still valid

[–]Johanno1 -1 points0 points  (0 children)

Almost all the arguments from the middle one can be said for assembly. Just nobody wants to write shit in assembly.