C++23: The Next C++ Standard

[enriquto]

    #include <print>

    int main()
    {
            std::print("hello, world!\n");
            return 0;
    }

So, it has come to this. Much better than overloading bit-shift operators for input/output.

[JackSlateur]

So:

  int main() {
      printf("hello, world!\n");
      return 0;
    }

C knew it all along :)

[coldpie]

Operator overloading is an anti-feature and every language with it, would be better without it. Fight me.

[bippingchip]

If you just need a nice print: fmtlib is a really nice c++23 style implementation without needing c++23 compiler support. Highly recommend it. It’s simple. It’s fast.

[tialaramex]

Barry Revzin's comparison to what Rust chose here is interesting

https://brevzin.github.io/c++/2023/01/02/rust-cpp-format/

I think Barry under-estimates how long it will be before C++ programmers actually get the equivalent of #[derive(Debug)] and as a result the impact on ergonomics. But of course I might be wrong.

[kazinator]

How long before they get it down to:

  main()
  {
    puts("Hello, world");
  }

[xxpor]

puts on the most annoying code reviewer you've ever met hat

acktually, you should use println.

[nuancebydefault]

Are there now in c++, after all these years, f-strings like python has, or at least something coming close? If not, I keep being at my disappointed state about c++.

[fractalb]

Time to rewrite helloworld programs. IIRC, Java is also making it simpler to a helloworld program.

[mhh__]

Admittedly I grew up after their introduction but I've always viewed the whining about overloading the shift operators quite pointless.

Of all the things C++ annoys me with, I don't care that much about syntax.

[turndown]

Is the include correct? Wouldn't it just be import std; ?

[Google234]

Don’t need the return 0?

[thibran]

Where is the std:: part coming from / why is it not just print(...)?

[CoastalCoder]

I'm glad for this article.

C++ has been my main language for a very long time, but I've been a grumpy skeptic of C++ since around C++14 due to the language spec's total complexity. So I've mostly stuck with C++11.

But now that C++ has modules, concepts, etc., I'm starting to wonder if C++23 is worthwhile for new projects. I.e., the language-spec complexity is still there, but the new features might tip the balance.

I'd been thinking to walk away from C++ in favor of Rust for new projects. But now I might give C++23 a chance to prove itself.

[afavour]

I've always been aware of C++ (obviously!) but it seemed impenetrable to me coming from my experience with C# and JavaScript. So I was really pleasantly surprised when I tried it out a while ago using the C++20 standard: it felt entirely usable! But then I tried Rust, which felt like that plus a pile of even better stuff. It's been difficult to find a reason to go back since but I'm glad to see even more progress is being made.

[fassssst]

The reason is not the language itself but what it lets you do. E.g., if you want to use Unreal Engine or write an audio plugin, learn C++ for that.

If you want to mess around with machine learning, learn enough Python for it.

Id you want to make a mobile app, learn Swift or Kotlin.

[TillE]

There are a zillion reasons that C++ is still widely used (existing software, brand new software that relies heavily on existing libraries / game engines), so it's really nice to have lots of helpful features being added to the language and the standard library.

I'm ambivalent about Rust, but its best feature compared to C++ is a universal package manager and build system. I like vcpkg well enough, but it's not Cargo, it can't be.

[Conscat]

The tradeoff is C++ is an amazing language for building a type system and zero overhead abstractions, where Rust is extremely limiting in that area (orphan rule, constant evaluating const-generics, no implicit pedagogically equivalent type conversions, users don't define what move semantics mean, terrible variadic programming, macros can't interact with CTFE or generics, functions/lambdas cannot be const-generics). Some of that will probably improve over time, though, although metaprogramming in Rust advances slower than C++ since 2014 and it has to play catch up already.

[snitty]

I learned C++ in the late 90s and didn't touch it until recently and all the new stuff basically melted my brain. It feels like a different language now.

[synergy20]

Hopefully clang++ can catch up to the new standard faster as clangd the LSP is used in so many intellisense tools that depends on clang++ implementation. Even though c++23 will be compiling fine with newest g++, clangd will still complain all those new syntax probably for a few years ahead, at the moment quite a few c++20 features are still unsupported by clangd(which depends on clang++).

or, gcc can have its own c/c++ LSP, which is not the case.

[IAmLiterallyAB]

Hoping compilers will get their C++20 modules implementation working well enough that we'll get C++23 standard library modules soon. As an outside observer, it seems like progress is happening in spurts, but it feels kinda slow.

[pjmlp]

Yes, VC++ is still the only usable one.

[nvy]

For people who are proficient in other languages but haven't touched C++ since CS036 in undergrad, some 15+ years ago, what would be the best way to learn what "modern C++", both the code and the dev stack, looks like?

Asking for a friend.

[nanidin]

I'm a little 10 years out from writing C++ professionally and I found this cheat sheet[0] useful. Basically if you have an inkling of the concept you're looking for, just search on that cheat sheet to find the relevant new C++ thing. Specifically for me, we used Boost for smart pointers which are now part of the stdlib, and threads are now part of the stdlib as well.

[0] https://github.com/AnthonyCalandra/modern-cpp-features

[htfy96]

A Tour of C++ for syntax, https://www.cpp-lang.net/tools/ for dev tools

[mauvia]

I don't really learn stuff in a structured way so this might not be helpful at all, but a youtube walk got me into watching CPPCon talks (https://www.youtube.com/@CppCon) and I found them generally useful for getting an idea of what's going on in C++ and what all the magic words to research are. When a bunch of people talk about weird gibberish like SFINAE it becomes easy to figure out it's something you should search for on wikipedia (https://en.wikipedia.org/wiki/SFINAE). note: SFINAE is simply a way to make overloading work better by failing gracefully if an overload fails to compile.

There's a series of talks called Back to Basics that seems to have quite a few talks every year where they discuss C++ features in general like move semantics or how testing works, etc. There have also been talks from the creators of CMake or the guys working on the recently added ranges proposal, so it does cover tooling as well.

I also quite enjoy following Jason Turner's C++ weekly series (https://www.youtube.com/@cppweekly) which also has quite a few episodes that are dedicated to new C++ features or new ways of handling old problems made available by the new features. They're generally quite short, each episode on average is 12 minutes.

Just looking down the list of videos I see this is also kind of a direct response to your question, from only 8 months ago. https://youtu.be/VpqwCDSfgz0 [ C++ Weekly - Ep 348 - A Modern C++ Quick Start Tutorial - 90 Topics in 20 Minutes ]

For experimenting:

https://gcc.godbolt.org/ is a tool called compiler explorer, which is a really good place to experiment with toy code.

It's a site where you can write some code and let it execute, to see the results, as well as see what ASM it compiles down to for various compilers.

That last feature really helped me figure out whether the compiler really does pick up an optimisation I'm trying out. (and it's how I got really impressed by how powerful constexpr is (that's one of the new keywords))

For References:

Generally the https://en.cppreference.com site is a really well maintained wiki that has good explanations of every concept and standard library feature.

It sticks to the standard and has use examples and is heavily interlinked, as well as some concept pages to give an overview of certain topics like overloading, templates, etc. (they also have a SFINAE article https://en.cppreference.com/w/cpp/language/sfinae)

[dataflow]

Deducing this seems like a drastic change to the language, not a minor incremental one. People will be doing CRTP with it without realizing or fully appreciating the consequences now.

[kevstev]

When I was doing C++, one of my interview questions was an open ended one: "std::cout << "Hello world!" << endl;" What exactly is this doing, lets dive in to how it works.

You touch on kind of a lot here, and its pretty esoteric to even devs with 3-5 years experience. functors, operator overloading, namespaces, passing by reference to make the << chaining work, there is a lot you really have to know that is non-obvious. You can even jump into inheritance, templates and such if you really want to dive deep.

I thought this was normal after doing C++ for ~11 years, but when I finally broke out of the Stockholm syndrome and started a job working in other languages, I find it absurd how complex, or maybe a better way to put it is, how much language specific trivia you need to learn before you can even begin to unravel how a basic hello world! program really works.

[quotemstr]

If they do, there's no harm done. The new this inference stuff is just a brevity enhancement, yes?

You have to understand that it's a Sisyphean struggle to get people to use modern C++ features at all. You still see people passing around std::string instances by value and manually calling new and delete. They're ignorant of variants and think "final" is an advanced feature. I'm happy if they get as far as understanding even how to use CRTP.

There's a vast gulf in skill between the expert C++ practitioner who appreciates a blog post like the one linked and one who's been dragooned without training into writing some enterprise C++ thing. The latter relates to C++ as an inscrutable Lovecraftian god who might eat him slightly later if he makes the right cultist noises and does the right syntax dance.

[colatkinson]

std::expected and a monadic interface for std::optional are very welcome changes. I've ended up with funky utility types to accomplish much the same thing in a couple projects, so an official interface is definitely nifty.

I remember reading that clang was finally shipping std as a module, albeit experimentally. So this ought to be an interesting couple of years for C++ -- though I suppose it remains to be seen to what degree the ecosystem will keep up with all these changes vs using headers/exceptions/the traditional ways of doing things.

[jupp0r]

From past experiences, it will take another decade or two for modules to get adapted to most existing code bases.

[bhouston]

Does C++ yet have something similar to async/await?

I have a medium sized JavaScript codebase that uses this (http://github.com/bhouston/behave-graph) and I could really use a port to C++ so that it can be integrated with the USD project, who has expressed interest.

I couldn't find an equivalent to async/await in my searches so I am fearful that porting this across to C++ is non-trivial.

[Brystephor]

What are some personal projects you'd use C++ for? I have a hard time imagining any use cases for myself where it makes sense to use C++ over another language.

As someone who has never used c++, it seems like it's primarily useful when latency and performance really matters and the cost of that is ease of use when it comes to developer quality of life/productivity.

[okanat]

When creating things where such things matter or you need lower level access to the platform since there is a tight connection between the C and C++ compilers and the platform they (were) built.

I'd like to play with many gadgets, small embedded toys. Let's say it is custom a USB mouse. You may want to create a data structre that 1-1 represents whatever data you're pushing to the wire and the exact amount of time it takes you to push it over the wire.

C++ lets me abstract things better than C. There is a level of control in C++ where you get the decide to the minute detail how the compiler builds your software. With a C++ compiler you can say to the compiler to optimize one function, while not the other one in the same source file. Yes, the standard language abstracts the underlying machine and it will suprise you since compilers obey it very well if you not tell them otherwise. But all of the C++ compilers, including the niche ones, also let you pierce through those abstractions by special attributes and linker directives. So you can have an almost assembly code next to very abstracted and crazy optimized code.

C++ doesn't care how you build software, it is up to you to decide which kind of libraries, which libraries, what subarchitecture, what optimization level to use for each library. These sound crazy but current literature and internet is full of detailed documentation how to do these things since somebody at some point needed to do them to debug a particle accelerator or the latest PCIe bus or something and it is somehow useful for your stupid USB mouse.

Rust as the language (syntax, rules) is better. Rust articulates better, it makes a lot of sense. However to appeal the newcomers and people who look different sa(n/f)er ways to do things, Rust generally limits you. You need to codify certain "features", or you need build.rs files. You need to find underdocumented or "nightly" features. Whatever you come up with would be better formally defined. However going against the grain of Rust and Cargo creates abominations.

[lionkor]

It's still, after learning Rust, Go, C#, Pascal, and other languages, the language that "feels" best to me. So I'll use it for hobby/personal projects, because the other languages get in my way in weird ways a little too much.

[pjmlp]

Graphics programming, most of the SDKs are in C++, while for other languages you need to hunt for bindings.

Compiler development, in case you plan to play with GCC or LLVM as infrastructure.

[optimalsolver]

Just happy to have std::format.

Can't believe I used to use a third-party library ({fmt}) to do string interpolation like some kind of caveman.

[gerash]

I'm excited for more usability coming to C++. It's still far from the writability of Python. At the same time the Mojo language is going the other way: creating a system language out of Python.

[jonathankoren]

Genuinely surprised and confused by “print” and “println”

[CoastalCoder]

> Genuinely surprised and confused by “print” and “println”

I was too. Looking at [0], I'm guessing it's meant to bring these benefits over old-school "printf":

- Leverages the type system to avoid mismatches between the format string and the arguments.

- Adds Python- / Rust-style support for position-based substitutions, e.g. "{1}".

- Like Rust (I think; I'm still learning Rust) you can specify per-type formatters.

But I'm still confused about:

- How this relates to the standard library's iostream system. It seems pretty redundant.

- Why "println" exists.

[0] https://en.cppreference.com/w/cpp/io/print

[ksherlock]

Take your pick:

print("{:#04x}\n", 0xbeef);

- or -

cout << std::setw(4) << std::setfill('0') << std::hex << 0xbeef << std::endl;

[dxuh]

What's surprising to you about this? I think they are generally regarded as very welcome additions.

[1024core]

> Genuinely surprised and confused by “print” and “println”

Just like Pascal/Modula-2, except 30 years later :-D

[soulbadguy]

Really excited about the deducing this features. Fun template kung-fu'ing ahead.

[whobre]

Still at c++ 98, but it’s always nice to see what other people have…

[r2vcap]

s/absl::AnyCallable/std::move_only_function/