Hacker News Reader

Hacker News

Comment by trzeci | Hacker News Reader

Full thread

trzeci

Title: > a tour through modern C++

Then:

```

#ifndef JSON_H

#define JSON_H

// ...

#endif

```

Still I didn't get how #pragma once didn't end up in a standard, when every major compiler supports that.

View on HN

I feel more and more like Microsoft/Apple/GNU need to do what Apple/Mozilla/Google/Microsoft did when they turned their backs on the w3c and formed WHATWG.

If the standard committee can't even agree on concepts like the existence of a filesystem, we need a different committee.

The standards committee have too broad of a scope and think they can make everyone happy. They want the same C++ to work on embedded and cloud servers while not making anyone update any of their old code and having full backwards compatiblility. This results in tradeoffs that make everyone unhappy.

We all know what happens when backwards compatibility gets broken.

Plus there are several options already when backwards compatibility isn't relevant.

Who do you think calls most shots at ISO meetings?

There is nothing intrinsically wrong with using implementation features. If you are writing code for servers or a desktop app... just use #pragma once. Even in the unlikely scenario that you eventually need to use a compiler which does not support this, transforming #pragma once to a #ifdefs is a bash oneliner.

> do what Apple/Mozilla/Microsoft did when they turned their backs on the w3c and formed WHATWG

You mean when they gave Google the power to add whatever they want to the standards and get the hate of web developers for "being the new IE" whenever they refuse to implement Google's API of the day?

Not sure I'd want that infinitely growing scope for compilers I use for production systems.

I thought modules would be modern C++ now? Am I missing something?

I tried but couldn't get modules working, personally. The various sites online I found differed in how they work in the first place.

I couldn't find what the actual state of modules are in Clang.

Here, https://blog.ecosta.dev/en/tech/cpp-modules-with-clang

That lengthy blog post is a perfect example of everything that is wrong with C++. Using modules should be a trivial part of the language. Instead, we have to take a detour via historical Objective-C (a language already superseded) and there are enough caveats to make a lawyer blush.

Some languages care to keep 30 years of code compiling, regardless of the new shinny features.

It's so modern (C++20), it's not actually implemented fully by all compilers yet.

https://en.cppreference.com/w/cpp/compiler_support#cpp20

It is already good enough on Visual C++.

Such is the price for an ISO language with multiple implementations.

For C, there is a paper (pending publication) about this. No promises, of course, but the committee will at least have a look.

All our code uses #pragma once instead of the old way. Zero issues.

Same here and our games run on every possible device with a screen.

Same can be said about ISO C and several common C extensions.

Reply on news.ycombinator.com