Announcement

Collapse
No announcement yet.

C++20 Being Wrapped Up, C++23 In Planning

Collapse
X
 
  • Filter
  • Time
  • Show
Clear All
new posts

  • C++20 Being Wrapped Up, C++23 In Planning

    Phoronix: C++20 Being Wrapped Up, C++23 In Planning

    An ISO C++ Committee meeting just wrapped up in Prague and it was voted to send the draft international standard for C++ out for final approval and publication...

    http://www.phoronix.com/scan.php?pag...ue-Wrapping-Up

  • #2
    If it isn't already fixed, any chance they will add better overflow handling for signed numeric variables?
    I read something about unsigned (something numeric, can't remember if it's int or float) having wrap-around overflow specified but not the signed variant of that.
    And while they mentioned it wasn't clear how to do this due to the representation (1-complement, 2-complement, etc).
    Didn't they already specify the complement system and other details of signed int/float/other numeric in other operations or parts of the standard?
    Including, if I'm not mistaken, 2-complement? Which would allow specifying how the value of the signed variable should be calculated.

    Any chance that could be fixed for the C++23 standard if not already fixed in C++20?

    And is there also an initiative to make C++ and C's grammar, context-free?
    Would be nice to have in C++ and C.

    Will there be ideas from other programming languages put forth in the standardization process for C++23?
    Languages such as Rustlang, Dlang, Swift (Apple) and others.

    Comment


    • #3
      Wonder how much more unbearably slower this makes compilers now. And it's all for the sake of desperately trying to play catchup with every other popular language on the market.

      Comment


      • #4
        We will be able to import header files now instead of including them; nice! This will decrease compile time. I am waiting for when C++ can create a GUI.

        Comment


        • #5
          Originally posted by Ironmask View Post
          Wonder how much more unbearably slower this makes compilers now. And it's all for the sake of desperately trying to play catchup with every other popular language on the market.
          TIOBE Index for February 2020
          1. Java 17.358%
          2. C 16.766%
          3. Python 9.345%
          4. C++ 6.164%

          It seems not everyone is good at telling the difference between popular and fanboism.

          Comment


          • #6
            Originally posted by plonoma View Post
            If it isn't already fixed, any chance they will add better overflow handling for signed numeric variables?
            I read something about unsigned (something numeric, can't remember if it's int or float) having wrap-around overflow specified but not the signed variant of that.
            And while they mentioned it wasn't clear how to do this due to the representation (1-complement, 2-complement, etc).
            Didn't they already specify the complement system and other details of signed int/float/other numeric in other operations or parts of the standard?
            Including, if I'm not mistaken, 2-complement? Which would allow specifying how the value of the signed variable should be calculated.
            It's by design because it enables several performance optimizations. More details here:

            https://kristerw.blogspot.com/2016/0...w-enables.html

            Comment


            • #7
              Originally posted by plonoma View Post
              If it isn't already fixed, any chance they will add better overflow handling for signed numeric variables?
              I read something about unsigned (something numeric, can't remember if it's int or float) having wrap-around overflow specified but not the signed variant of that.
              And while they mentioned it wasn't clear how to do this due to the representation (1-complement, 2-complement, etc).
              Didn't they already specify the complement system and other details of signed int/float/other numeric in other operations or parts of the standard?
              Including, if I'm not mistaken, 2-complement? Which would allow specifying how the value of the signed variable should be calculated.

              Any chance that could be fixed for the C++23 standard if not already fixed in C++20?
              Yes. In C++20 it is guaranteed for signed integers to be 2's complement. However, overflowing or underflowing is still undefined behavior. Some platforms will trap on overflow and sanitizers also trap.

              Comment


              • #8
                is it just garbage collector that needs to be added to c++ before it can be called 'a modern programming language' ? Does Bjarne still recognizes his language?

                Comment


                • #9
                  Originally posted by plonoma View Post
                  Any chance that could be fixed for the C++23 standard
                  Since you seem to have quite a set of ideas about how to improve C++ I would suggest you join the C++ standardization process and participate to make sure your issues/ideas receive the appropriate consideration. More details on participation can be found at: https://isocpp.org/std

                  Comment


                  • #10
                    IDK where the committee thinks it is going, but as long as the langauge has pointers it will be possible to shoot oneself in the head. Are they going to remove pointers? Perhaps in the same revision that adds the DWIM operator?

                    Seriously, the person above who looks foward to when C++ can create GUIs ought to be a warning.
                    Last edited by hoohoo; 02-16-2020, 03:40 AM.

                    Comment

                    Working...
                    X