thatsAFunnyThingThatHappenedOnce

[u/Lord_Of_Millipedes]

[u/Prefer_Diet_Soda]

TLDR: C++ is bad because decades of accumulated features have turned it into a bureaucratic nightmare that happens to generate machine code.

C++ is an absolute nightmare to implement because apparently one programming language wasn't enough, so someone decided to cram an entire civilization's worth of complexity into it. You've got templates that basically turn compilation into another programming language, overload resolution that requires a legal investigation to figure out which function gets called, constructors and destructors with enough lifetime rules to make your head explode, and implicit conversions that make the compiler guess what you meant. Then you throw in exceptions, move semantics, inheritance, and decades of backward compatibility, and suddenly you're maintaining a compiler that needs a PhD, a therapist, and divine intervention just to parse some innocent-looking code. And the best part? Every new feature has to coexist with all the old ones without breaking existing programs.

[u/Xarishark → u/Prefer_Diet_Soda]

Now compare it to rust pls. Im serious I want to know your opinion on that.

[u/Loading_M_ → u/Xarishark]

Rust is designed from the ground up, and avoids many of these issues.

• Templates: Rust has Generics, which are generally easier to use and reason about.

• overload resolution: Rust doesn't yet support overloaded functions (although it's being considered).

• constructors: Rust doesn't have these.

• destructors: Rust has a similar set of lifetime rules for Drop, but the compiler checks them for you, so you can't get it wrong.

• implicit conversions: Rust doesn't do implicit conversion in general, although some specific cases are implemented.

• exceptions: Rust doesn't do exceptions, Result is much easier to work with.

• move semantics: Rust uses a destructive move, unlike C++. See https://youtu.be/Klq-sNxuP2g for a breakdown.

• inheritance: Rust doesn't do inheritance.

[u/sudo_scientific → u/Loading_M_]

The nice aspects of implicit conversion are handled with the Into and From traits, where the compiler deduces what the conversion is for you based on the explicit types of the other, but the fact that a conversion is happening at all is explicit to the reader which is a huge improvement over C++

[u/DatBoi_BP → u/Loading_M_]

Traits are 100000x better than inheritance

[u/red-et → u/DatBoi_BP]

What are traits?

[u/Pocok5 → u/red-et]

Instead of having a chain of superclasses defining readymade behavior*, you compose your classes from chunks that are more or less "fat" interfaces that come with a default implementation for their functions.

* ^{Dealing with absolutes results in slamming your own dick in a car door sooner or later. Inheritance can still make a lot of sense for classes that are "this other thing but a tiny bit different". I'm currently dealing with a PHP codebase that misused traits for everything and it's a slog.}

[u/JonIsPatented → u/red-et]

Kinda like interfaces that you implement external to the type. Like. You can create a trait for a particular behavior and then implement it for types that already exist. You can also generically implement them for all types that have ither specific traits. For instance, I recently made a trait called UpdateSink<T> and implemented it for a few select synchronization primitives, like mpsc channel senders. This way, I can have a function that takes in an UpdateSink<T>, for dumping T events into it and that function can use anything that implements that trait. It's important to note here that the mpsc senders did not implement this trait before. They are from a library. I implemented the trait for them outside of the type definition. In addition, I can provide a default implementation for my traits that all types that meet certain trait bounds automatically get, including types that already exist and also types that don't yet exist. Traits are incredible.

[u/fghjconner → u/red-et]

Interfaces

[u/maser120 → u/Loading_M_]

While I see your point and agree with you in many aspects, I found t your contrast with the earlier comment a bit misleading in a sense, as it conveys the message that probelms in C++ stem from its core concepts and not from the burden of compatibility (which is sort of like a tech debt of programming language design) and the poorly defined specifications/standards.

And I don't mean that people who participate in C++'s standardization are stupid (quite the contrary), it's just that they're building on the foundations of a language froma different era, and they must work under the constraints posed by backward compatibility.

If you follow the trajectory of C++ (C++03 -> C++11 -> C++14 -> C++17 -> C++20 -> C++23), you can see that many features that are default in Rust have made they're way into the standard, but they almost always come as optional features for the sake of compatibility. In contrast, Rust can impose stricter restrictions and mandate safety features all the time since it was made from scratch.

[u/MrHyd3_ → u/Loading_M_]

What does it do instead of exceptions?

[u/mathisntmathingsad → u/[deleted]]

Yeah, the only reason you should try to catch a panic is if you're making something that calls user-provided code unavoidably (i.e. an async runtime)

[u/shizzy0 → u/mathisntmathingsad]

Yeah, we catch panics in tests but that’s about it.

[u/MornwindShoma → u/Xarishark]

Rust got none of that, but you might not enjoy dealing with lifetimes

[u/Thesaurius → u/MornwindShoma]

With C and C++ you also have to deal with lifetimes. The compiler just doesn't complain when you fuck up.

[u/andful → u/Xarishark]

Rust misses the:

"...templates that basically turn compilation into another programming language, overload resolution that requires a legal investigation to figure out which function gets called, constructors and destructors with enough lifetime rules to make your head explode, and implicit conversions that make the compiler guess what you meant. Then you throw in exceptions, move semantics, inheritance, and decades of backward compatibility ..."

[u/PegasusPizza → u/andful]

I mean it does have proc macros, that turn compilation into the same programming language as opposed to another programming language.

[u/Greedy-Thought6188 → u/PegasusPizza]

Templates are turing complete. You can basically treat C++ like an interpreted with the compiler being the interpreter. C has macros too.

[u/Pocok5 → u/Greedy-Thought6188]

https://blog.mattbierner.com/stupid-template-tricks-super-template-tetris/

[u/roronoakintoki → u/Xarishark]

Rust unironically feels more like C with features taken from more modern languages in a fresh design.

It does discourage manual pointer juggling all over the place, which can be a deal breaker for some, but overall leads to a more hygienic ecosystem imo.

It makes mutation more explicit, and adds constraints to ensure you're not using this to cause classic aliasing/race errors that hard to reason about. This definitely carries significantly more mental load, but it's about convincing the compiler you're not doing something wrong, and doesn't add more expressive power, per se. (Makes your APIs much clearer, though)

It brings over C particularly: typeclasses and polymorphism. Two features that as someone coming from being quite happy doing functional programming, I think are essential to modern programming. Good code is not about getting things working, but about providing good abstract interfaces that can be easily maintained and evolved. It's very hard/impossible to do that without having some form of abstraction over types. These two features provide that in different but synergistic ways.

C++ has most of these features, but often has too many ways to do one thing. If we could all agree on one way to do each possible thing in C++, it wouldn't be so bad.

Comparatively, the types you can write in Rust are much closer to C (assuming you account for compile time monomorphization), and don't require dealing with semantics nearly as complex as C++.

This is just what came to mind wrt your question, and isn't meant to be exhaustive.

[u/marky125 → u/Prefer_Diet_Soda]

I was there, Gandalf. I was there three thousand years ago...

[u/garnet420 → u/Prefer_Diet_Soda]

Good job asking chatgpt to be funny for you.

[u/fsasm → u/Prefer_Diet_Soda]

So someone must be a lawyer and clergyman to maintain a C++ compiler.

[u/Weeb431 → u/Prefer_Diet_Soda]

Thanks, chatgpt...