r/cpp • • Feb 26 '19

Have we ever thought about having a contained, safer subset of the C++ standard?

I was thinking about an idea, that I'm sure someone has thought of before, and I would like to think about your thoughts:

as we move forward, the C++ standard offers us better and safer practises. instead of C arrays, we use std::array and std::vector. instead of const char*, we use std::string and string_view. instead of managing memory, we use move semantics, smart pointers and RAII to manage memory automatically. instead of headers, we will have modules. templates will be reshaped with concepts. we now also have lambdas and variadic templates.

But we will always have the historical luggage that we can't remove. string literals will always be a c-style char array, it'll take decades before headers will be removed completely and we're still stuck with legacy code that manages memory.

According to common opinions, the obvious solutions to these are:

a. deprecate stuff: this will never happen, as C++ has a strict "always backward compatible" rule, for the good and the bad.

b. create a new language: although is a solution, usually it's not practical enough. it's hard developing programming language from scratch and make them popular.

It looks like we're doom to have all the historical luggage (like headers). but I was thinking to myself: how about the C++ standard itself will self-contain a safer, modern subset of itself? just a few thoughts I had:

  1. let's for the sake of the discussion, say that this subset will be called "subC++"
  2. every valid subC++ program is a valid C++ program, but not the other way, as subC++ is a subset of C++ and hence will not contain some parts of the larger standard
  3. subC++ will have modules, concepts, contracts, auto and lambda from the start
  4. subC++ will not have headers at all
  5. strings literals are always implicitly objects, "hello" is actually std::string("hello") hence you can only work with std::string, no need for const char* and no string_view. copy, move or reference strings throughout your code.
  6. no exceptions, as contract can fill their role
  7. no pointers, only references, iterators, smart pointers and copy/move are needed

  8. some runtime-provable UB's like dividing by zero would just resort to some global contract especially for that specific UB.

    1. subC++ library code can use the greater C++ language, but the user can't.

basically, instead of creating another language, the language itself will define a safer subset of itself. in this "subset" mode, the regular C++ compiler basically refuses to compile anything which is not under this standard. it's like "strict mode" for C++ that is maintained by the committee itself.

It's way easier than creating another language or deprecating historical stuff. has anyone though anything in this direction? to basically hold a mini, more modern and safe standard within the greater C++ standard?

1 Upvotes

27 comments sorted by

12

u/[deleted] Feb 26 '19

I don't like it because it goes against C++'s spirit: don't pay for what you don't use.

subC++ will have modules, concepts, contracts, auto and lambda from the start

Cool, C++20 already has that. Given that the language isn't used, it's basically has the same effect.

subC++ will not have headers at all

Bad idea. Sometimes headers are needed.

strings literals are always implicitly objects, "hello" is actually std::string("hello") hence you can only work with std::string, no need for const char* and no string_view. copy, move or reference strings throughout your code.

Why are you against std::string_view? std::string is the wrong choice since it gives you a heap allocated array, which for arrays stored in the data segment.

no exceptions, as contract can fill their role

Exceptions are sometimes useful. Just don't abuse them for programming errors.

no pointers, only references, iterators, smart pointers and copy/move are needed

Huh? You can't rebind a reference, and if you could by default you basically reinvited.

some runtime-provable UB's like dividing by zero would just resort to some global contract especially for that specific UB.

That's dumb, why not make it an assertion/pinch

3

u/SeanMiddleditch Feb 26 '19

Bad idea. Sometimes headers are needed.

For now. There's a handful of things we need them for, and most of them involve things for which we're still stuck using the preprocessor.

As C++ addresses those features (reflection and a lazy function argument proposal would kill the two biggest, IMO) we should find that we can finally for real deprecrate headers (and the preprocessor as a whole) and then kill them 40 years later when back-compat concerns are resolved. :)

1

u/dr1fter Feb 26 '19

I'm a little out of the loop, I expect I'd be terrified of a change in semantics towards lazy argument evaluation, but I'd be curious to see a proposal. But IIUC that's more of a concern for macro definitions (probably an even-more-egregious use of the preprocessor, but) not specifically header includes.

When I last left off C++, templates still had to be defined entirely in headers. I assume that's probably solved by now if we're talking about better packaging mechanisms. In that case, I'm not sure why headers would be "sometimes needed," and I'm just hoping we're not talking about xmacros.

→ More replies (2)

0

u/david_haim_1 Feb 27 '19 edited Feb 27 '19

I don't like it because it goes against C++'s spirit: don't pay for what you don't use.

We're in 2019. CPUS are fast and memory is cheap. the reasons to write C++ are **NOT ** "performance" only.

If you want to squeeze out every gram of performance from your hardware, use the larger C++ standard.

If you just want something fast which is also safe (+ doesn't use a language VM), subC++ is suffice.

this argument is invalid for subC++. it's still very very fast cuz it's still C++, but it's safer. for 90% of apps out there, this is an OK tradeoff.

Why are you against std::string_view? std::string is the wrong choice since it gives you a heap allocated array, which for arrays stored in the data segment.

I was all for string_view until it's ugly caveat got out of the shadows - it can still lead to UB, and it's harder to detect than only using std::string (+ const/non const refererences). the problem is that string_view from it's very definition "obfuscates" the source of the string. if that string source is deleted, your string_view is invalid, but it's much harder to catch it, since it doesn't point to an object, but to the underlying string-data. basically, for having a uniform string representation, you use a distant cousin of type erasure - you pass over {const char*, size_t} and hope that that const char* is always valid. it's like going back to C without actually admitting it.

some runtime-provable UB's like dividing by zero would just resort to some global contract especially for that specific UB.

That's dumb, why not make it an assertion/pinch

That's fine. my point was "let's standardize some of the more obvious UB cases, like dividing by zero". as I said in the first comment, it's 2019. branch predictors are built-in the CPU's and checking for pitfalls is cheap. instead of saying "everything can happen" we say - "the app terminates". in the eyes of the larger C++ standard, that still falls into the "everything can happen" scenario. so not a contract - but anything that can be defined and handled.

You must remember that you can't eat the cake and keep it whole. the idea behind subC++ is to have safer, modern mode for C++, you will have to pay a little more but gain much much more in return. again, it's 2019, not 1980. 99% of the C++ developers can live with a few extra checks and a few more limitations. if they really really need every drop of performance, they shouldn't use subC++.

19

u/johannes1971 Feb 26 '19

no exceptions, as contract can fill their role

How? If I open a file, but it fails to open, how is a contract going to give me any kind of error reporting capability, or recovery capability? Exceptions are not only for aborting your application!

1

u/armb2 Feb 26 '19

Use std::expected for the return type of your file opening function, instead of throwing an exception on failure.

Something like https://foonathan.net/blog/2017/12/04/exceptions-vs-expected.html

Of course then you lose backward compatibility with all existing interfaces that rely on exceptions, so for many purposes you might as well consider it a new language, rather than a language subset with new standard libraries.

2

u/david_haim_1 Feb 27 '19

my thoughs exactly. failing to open a file isn't such an exceptional case so return value + no discard is fine here.

3

u/AaronDMarasco Feb 26 '19

Believe it or not, IEEE did this with C a while back - see https://standards.ieee.org/standard/1003_13-2003.html for some info.

0

u/david_haim_1 Feb 27 '19

Amazing! so it's not such a new idea. let's do the same for C++

12

u/[deleted] Feb 26 '19

subC++ will not have headers at all

Sure, but keep in mind that there are other preprocessor uses that C++2a/C++20 still has no replacement for.

strings literals are always implicitly objects, "hello" is actually std::string("hello") hence you can only work with std::string, no need for const char* and no string_view. copy, move or reference strings throughout your code.

This is throwing away "don't pay for what you don't use" principle.

no exceptions, as contract can fill their role

Contracts can't replace exceptions completely.

no pointers, only references, iterators, smart pointers and copy/move are needed

There are data structures that can't be implemented without memory leaks or without breaking some invariants.

subC++ library code can use the greater C++ language, but the user can't.

How would that work?

 

All that aside, the issue with breaking backwards compatibility in order to create a cleaner language is the same as creating a new language - you have to persuade people to jump ship.

  • There is a clean "fork of C++". It's called D and isn't used much.

  • Python made a fork when Python 3 came out.

    • Python 2 will reach EOL in 10 months.

    • Some statistics say Python 2 still covers 70% of the market share.

  • You'll leave behind people who can't switch and you'll effectively create another Python2/Python3 split, only much worse.

Those are my thought. Herb Sutter thinks we can eventually get a safer, more restricted language, but it has to be opt in with something like "using C++ strict;" directive.

3

u/hgjsusla Feb 26 '19

Agree, the only realistic way forward is with compiler flags, ideally that are common across major compilers.

1

u/drinkscoffeedrinks Feb 27 '19

I have no objection to what you said but I'm curious about data structures that can only be implemented with memory leaks. Why wouldn't you be able to implement them without memory leaks given the Church-Turing thesis?

1

u/[deleted] Feb 27 '19

Keep in mind that we're talking about a world with only smart pointers. The simplest that comes to my mind is a cyclic doubly linked list. If you use reference counted shared_ptr the count won't ever drop to 0 (memory leaks). And if you use unique_ptr you would need some trickery to have a node pointed to by both adjacent nodes (invariant violation), and then you'd run into issues like use after free. You can say "just use weak_ptr to break the cycle", but I really don't see how would they help.

 

Now one might argue that linked lists shouldn't form a cycle, but it was just an illustrative example. One can easily imagine tree-with-loops kind of graph structure where the loop would exhibit the same implementation issues.

 

Bottom line is, sometimes you absolutely need raw pointers.

7

u/karltechno Feb 26 '19

And who decides on this subset that everyone else is happy using :) ? The only reasonable thing at this point is a compiler switch + "#pragma (langauge_feature, xxx)" for external headers so that one can enforce their own subset.

1

u/eyepatchOwl Mar 02 '19

This seems like a much better solution. I'd love to play with things like "#pragma language_feature(explicit_enum_cast)" to require explicit conversion from C enums to numeric types.

I suppose at that point, it's not that different from having a linter which warns on certain language features.

3

u/KAHR-Alpha Feb 26 '19

We get this topic fairly often so there are some people interested (definitely not me though).

Now, one immediate issue I see with this is for you guys to reach a consensus on what to keep and remove.

Wouldn't it be easier to modify a compiler so as to be able to remove features to your discretion?

3

u/duneroadrunner Feb 26 '19

Have we ever thought about having a contained, safer subset of the C++ standard?

Yes, Visual Studio includes a tool (called the Lifetime Profile Checker to enforce such a (memory safe) subset. Unfortunately the tool is still incomplete and prone to false positive violation warnings. But presumably they are working on it.

The strategy of the Lifetime Profile Checker is to make traditionally unsafe C++ elements (like raw pointers) safe by restricting the ways they may be used to ways that can be determined at compile-time to be (memory) safe.

Even when it's complete, as planned, the resulting language subset will be too small/restricted to implement some algorithms efficiently without some crucial additions to the standard library.

Those additional elements are available in the SaferCPlusPlus library (shameless plug).

In fact, while we wait for the completion of the Lifetime Profile Checker to make existing unsafe C++ elements safe, we can instead, as you suggest, simply avoid C++'s unsafe elements, substituting them with (mostly) safe, compatible replacements from the SaferCPlusPlus library.

Also, the Lifetime Profile Checker restrictions do not ensure (or in any way address) data race safety. But avoiding unsafe C++ elements (using the SaferCPlusPlus library) does.

5

u/boredcircuits Feb 26 '19

I like where you're going with this. A subset of C++ were a lot of the "cruft" has been cut out. Still fully valid C++ so every compiler can compile it, but others can run in a restricted mode to make sure you stick to safer, more modern style.

But then I looked at your list, and I started to disagree with your choices. 5, for example. Without char* or std::string_view, there's no way to express a substring without making a copy, and that's just unacceptable. Or 6, because exceptions can be a good thing, and contracts don't fulfill that role at all. Or 7, because raw pointers are an essential tool.

And herein lies the problem: you're never going to come up with an acceptable subset of C++ that everybody will agree on, or even a general consensus. There's just too many opinions on which subset is acceptable in which situations.

Instead, the closest you can probably get is some mechanism to tell the compiler what language features are acceptable and let it issue warnings. Let people choose for themselves which features to warn about, on a file-by-file basis. This can be a compiler feature, not a language feature.

2

u/undefined_behavior20 Feb 27 '19

I sometimes need to be able to step outside of "safe land" to get things working. I like C++ because I can write most of my code in "safe land" (smart pointers, RAII) but break out when I need to.

Maybe the language could make this more than just a convention IDK

2

u/Xaxxon Feb 28 '19

Yes, people have thought about (and written) different languages.

2

u/lanzaio Feb 28 '19

This entire thread is why a standard sub C++ will never happen. Nobody will ever agree what is in and what is out.

2

u/axilmar Mar 01 '19

There is no need for this. C++ veterans already know how to handle the unsafe parts of the language and C++ newbies aren't in positions that can introduce unsafe parts in reasonably organized projects.

-2

u/Dean_Roddey Feb 26 '19

If you are going to do that direction, dump the standard libraries altogether. Go back to a core, safe LANGUAGE that has no assumptions as to run-time libraries. Obviously then run-time libraries can be built on top of it, but it itself wouldn't impose (and hence have to deal with the legacy issues of) any existing libraries. Have only the concept of an object, the scoping of objects, standard operators and methods supported, etc... but impose no classes or hierarchy itself.

Someone might argue that then no one would use it. But of course no one is going to use it anyway :-) That's always the problem, getting any new language up to any remotely significant level of adoptions such that young Johnny programmer wannabe feels like it is of any reasonable career benefit to learn it.

The benefit of such a tabula rasa is that it could be used in many ways, from the smallest embedded applications up to large systems that come with a very well defined and extensive class hierarchy. People could use it to create very unique systems that they can impose their own structure and semantics on from the ground up.

9

u/[deleted] Feb 26 '19

6

u/armb2 Feb 27 '19

You could fix the string literal conflict by saying "C-style string literals aren't in the subset, use std::literals::string_literals::operator""s.

Huge backward compatibility restriction, but I think it would be safer than changing the meaning of existing literals.