sameProblemSameSolution
70 comments · 98% upvoted · source · other discussions
comments
LoveOfSpreadsheets
mguid65
Basically what I told someone a couple days ago.
John Businessman in his business formal wear at Legacy Inc. will never switch away from C++98 anyway.
No-Adeptness5810
Dude i migrated a massive project from c++17 to c++26 in like 15 minutes i dont get the drama
JVApen
As someone responsible for these upgrades on a large project: - MSVC just announced they fully support C++23 in the . 52 compiler - It isn't just switching the version, it's also switching the compiler version - This comes with upgrade of related tooling (upgrade clang and clang-format and clang-tidy and clangd ...) - It also comes with upgrading the used OS (Ubuntu 22.04 -> 26.04) - Sometimes you see ICE (internal compiler error) popping up - Some breaking changes require work to resolve (like operator== in C++20) - Even if you no technical issues, you need to find the time while features have priority - You need material to 'teach' all employees
My experience: switching the version flag is the easy part
Juff-Ma
Thank you, I've never had an internal compiler error and now will have nightmares about that for weeks.
17HappyWombats
We have a file logging library (zlog) with thousands of calls. We're not switching to std::format. Even after they fix it so it can do all the printf stuff. Just checking an LLM translation would break whoever got that job.
We're slowly moving to std::ranges::for_each/all_of/etc but that's not a migration so much as a progression when we change code that uses older versions.
There's a whole bunch of similar stuff, we mostly try to avoid having too much clang-tidy whining.
anonymous4036
For 17 specifically, autoptrs
No-Con-2790
And there is me who is just glad that C++98 is over.
Excession638
Antervis
C++03 -> 11 migration was a pain in the ass because of std::string changes, but after that it was basically just changing compiler flags, no?
Bemteb
There are some minor things, if you are unlucky something might break going to 20. But it's mostly special cases, not something so big as string.
The main reason companies don't switch is "it's working, why invest time and money into switching?"
SeriousPlankton2000
Undefined / implementation defined behavior or regular stuff?
Antervis
Depends on the companies. Tech giants would be losing potential employees if they stuck with outdated standards, and that loss outweighs costs of upgrades.
cpayne22
Airlines and finance both employ a lot more than “tech giants”.
The real cost is the testing and compliance.
Any change needs to be documented and tested.
At the end of the day it’s a financial decision.
LutimoDancer3459
Security updates, more and potentially better frameworks, more efficiency,... dont know about c++ but the things the java team added since 8... boy, the reduced server costs will pay for themselves pretty fast
ResponsibleWin1765
I thought the entire reason why C++ is so convoluted is because it keeps everything around for backwards compatibility.
dont-respond
Some things do get deprecated and removed like std::auto_ptr. The ABI compatibility was broken for std::string between 03 and 11.
17HappyWombats
And turning on all the new warnings and hints and clang-tidy updates and cpp-check checks and other fun stuff. Wherein you learn that sometimes passing a std::string to printf "works" because of SSO, and it's worked in prod for ages.
meneldal2
For Microsoft they dropped support for some stuff with newer versions. Which was outside of the standard so fair enough but can break projects.
Like references in unions.
megayippie
The <=> operator was a big pain point. Many of our tests started failing with weird bugs
Antervis
How? Pre-c++20 codebase won't even have them.
megayippie
I honestly don't remember the details or the compiler version. I think the error was because some of our types only partly conformed to ideas of sorting, and that caused some weird interaction where some types in a vector didn't want to test for just ">=" but some other things as well, which we didn't need so didn't implement. Neither "==" nor ">" were there for our types.
The solution was to use more spaceship operators. The error message was clean but we didn't really know how <=> worked yet, so it delayed us a week or so.
Antervis
Ehm... Standard algorithms and data structures use operator < though, even for equivalence.
SeriousPlankton2000
If neither == nor > are there, how did your types end in a test that expects ordered-like behavior for your types?
megayippie
Oh, the exposed type did, not the inner type
echtma
DIS = Draft International Standard
Just in case anyone else was wondering.
Luna_Wolfxvi
Honestly some of the newer shit doesn't even look like C++ to me anymore. IE:
constexpr auto my_meta_type = int; // Reflected metadata of 'int' [:my_meta_type:] my_variable = 42; // Splicing it back into code; compiles as: int my_variable = 42;
fuj1n
The code generation / reflection stuff is amazing.
Historically, when you'd need type information (without manually defining it), you'd have to add an extra compilation step where a custom tool either manually searches the codebase or interrogates a compiler API, now, you can just write compile-time code in your codebase that automagically populates a data structure for you with any type information you could desire.
It'll be really useful for my (hobby) game engine, where I was previously considering traversing the Clang AST
meneldal2
If you look at what engines currently use for reflection (ugly macros mostly), this can be a huge improvement if the engine can be rewritten with this in mind.
But the sad part is I can only see maybe UE going with it with the next major release because they can force this kind of change, but open source stuff is never getting it most likely, way too much inertia.
17HappyWombats
if(auto foo = call_some_function([parameters](const auto &thing){
return test_the_thing(thing)
}; foo == enum_type::operation_success) {
there's code here;
}
That's perfectly valid and readable C++ and I won't hear otherwise.
(I am using std::optional a lot now that it kinda works. It's not a Rust Result but it's near enough for Australia)
Hohenheim_of_Shadow
I love C++ because it's an un-opinionated, multi paradigm language where you can do whatever you want but that shit is horrendous. Freedom was a mistake.
I am glad you can code how you like, but corona virus social distancing protocols are in effect
17HappyWombats
You get used to it, and if you expand the above back into C-style code it turns into an utter abomination. Especially with code where you need to write "if any of these, find a matching one of those" type sequences, and {hopefully soon... serialise it to JSON and send it}
Fundamentally C++ is limited by its roots, which is why Rust people are so unbearable {changes hats} about the utter perfection of the language.
Hohenheim_of_Shadow
Hard disagree.
True C is readable, but kinda annoying it has to bring in pointers.
Edit, realized I bungled the test_the_thing. Fuck it IDK, coding on mobile sucks
``` Int test_the_thing (*blah blah, args){ Return blah; } Void func(){ Blah result; If(test_the_thing(&result, args) ){ Do stuff; }
}
```
Cpp pass by reference makes it pretty sweet and simple for ez cases.
``` Int test_the_thing (&blah blah, args){ Return blah; } Void func(){ Blah result; If(test_the_thing(result, args) ){ Do stuff; }
}
```
The return result by argument pattern is a little eeeh, but it makes sense considering that's often how it has to work under the hood anyway. Optionals are syntactic sugar alternative for the same semantics.
``` Std::optional<blah> test_the_thing ( args){ Return args.blah; } Void func(){ Blah result=(test_the_thing( args); If(result ){ Do stuff; }
}
```
I can see why each incremental change is made and how it leads to what you like. E.g. yeah the two part of statement is kinda nice for this simple case. But the end result is pretty bad imo.
To me, it's like those overly clever nested ternary statements, but worse. Super fun to write, echnically a couple characters more concise, but so tangled together that reading it is miserable.
Defining and constructing an anonymous class in an if statements conditional is just way too much going on there for simple shit, and way way too much going on for complex shit!
But the beauty of c++ is that's just like my opinion sis and you can do you <3
SeriousPlankton2000
In Australia everything wants to kill you, even C++ code?
17HappyWombats
if(errno){🔥}
Sarmq
I just hate that you can't have an optional reference, and it breaks my templates occasionally and I have to go look up how to actually do template metaprogramming.
Excited for 26 though, I believe they've filled that gap.
ValesQQ
It seems valid but would the first “if”not always be true due to the single “=“ ?
Moist_Heat9523
No, it’s an assignment, and this code tests the value that was assigned. So basically “foo = …; if (foo)”
17HappyWombats
Yep, the shiny new if-two-statements, upgraded from the old if-statement. It's surprisingly convenient, partly because I used to get frustrated at not being able to explicitly test "if(auto foo=some_random_shit))" and I loathe implicit "nullptr is 0 and also false"
I eagerly std::await the even more improved if-three-statements-and-a-loop "operator" 🔥
SeriousPlankton2000
Can't you do if ((auto foo = bar()) == baz) {barf()}; //?
17HappyWombats
Nope, that's not allowed. The previous standard let you say "if(auto foo = something)" and if foo could be interpreted as a boolean you had a valid if() statement. The new one lets you have two statements, the auto assign and the test.
The win here is the scoped auto variable, FWIW. If avoids the abominable pattern where you either alternate declaration/conditional, or a pile of declarations then a string of tests, mixing assignments in whatever way is least horrible. So you get a chain of declare-assign-test statements in a nice vertical line rather than a >
the_horse_gamer
the compile time reflection is incredible. only zig and jai have something that can really match it in power, and they're significantly simpler languages.
WoodsGold
Legal-Software
Far too aggressive of a standardization schedule for a supposedly stable language. The signal-to-noise ratio is also getting worse between versions.
7DBBA101
I felt very fancy when I upgraded to C99 from ANSI C a couple of years ago
Ascendo_Aquila
We've migrated to c++20 and thinking of 23, but it was insane 2.5 year act. Build system rewrite(and ~12 merged prs in cmake) was required to make it cleaner but now it works for ios, win, mac, linux, android.
mas-mas-itu
During 2012-2016, I was so excited and ambitious to learn and use C++ profesionally. Later on when its' standardization becoming more and more ridiculous, it does more damage to me rather on making things easier.
Anxious_Marsupial_59
C++ 20 (and the following streamlining of C++ 23) was a monumental upgrade in making it easier to use and avoiding foot guns without having to always write your own standard library, what are you even talking about?
Kinexity
when its' standardization becoming more and more ridiculous
Literally all that was added over the years following C++11 are optional features. No one holds a gun to your head forcing you to use them.
helanhalvan
If those optional features where implementing sensible things, sure. For example, can you, using the standard library, print vector<vector<int>> to stdout easily? As far as I can tell, no, you need to write loops or recursion yourself.
tim_pipperton
Is that really such a pressing issue? Regardless, reflection makes that way easier on the library side.
Kinexity
Almost like as if there is no one single correct way to print out such structure. If you always want to print it out the same way then no one stops you from writing your own mini library to do it in your every project. Go back to Python if you want the language to hold your hand and decide stuff for you.
QuaternionsRoll
Eh, debug printing is definitely an overlooked feature in C++. It’s possible that reflection will improve things somewhat, but hard to say
palapapa0201
I believe std::format can already do that?
helanhalvan
This is why I find it so frustrating. Yes, std::format is the exact kind of construct you would expect to solve this problem. However it does not work with any collection out of the box.
We tried to make it work but ended up making a recursive templated function instead. Now, I guess everyone can make their own recursive templating function, but then why do we even gave std::format
*cries in Java8\*
worthlessDreamer 109 points · 1d ago
At least we got lambdas right 🥹
laplongejr 40 points · 1d ago
10 years ago, I was writing their first Java8 software.
Now I'm working on updating it to Java 17 servers... oh wait they are speaking of maaaaaybe going for Java 21
Sarmq 1 points · 16m ago
We'll end up in Valhalla before we get to Valhalla
RussianMadMan 41 points · 1d ago
c++11 still gets a lot of usage, its like the c++ version of java 8.
OppositeFun2493 7 points · 1d ago
Reminds me of something I was watching that had captions that said "[yawns in Spanish]"
how do you yawn in Spanish
just_looking_aroun 20 points · 1d ago · :cs:
Maybe “yawñ”?