Group Actions
Engagement
  • Author Author: Jan Cumps
  • Date Created: Date Created
  • Views 3437 views
  • Likes 6 likes
  • Comments 20 comments
Related
Recommended

Sorting in the C++20 release

Jan Cumps

I don't get over-excited about programming languages and their evolution easily.

But it happened this time. C++ is introducing a new dialect. The 2020 standard.

 

There are a number of things that are useful but I wouldn't consider them groundbreaking (watch cppcon videos for people that get excited but do not sound like they are excited).

 

Then there is the new sorting functionality.

In C++, you can overload the sort algorithm.

This is very handy. Developers can create sorting algorithms that can teach their objects to sort themselves.

In the past you had to generate equal, not equal, greater than, smaller than, greater or equal, smaller or equal.

Many times, you implemented two of those, and derived the other ones based on that.

 

There's a new comparator now: "<=>".

This one covers all situations. If it fits your scenario (I think it does in many cases), you get all the comparators implemented in one class member.

That means that it 'll be easer to write objects that plug in to the sorting algorithms of C++.

We all dream to write code that says if (thisObject < thatObject). Or use standard algorithms that can sort or compare our home-written objects.

I think that the <=> operator helps with this, by reducing the work for the class designer.

 

For the record: this does not cause any run-time or code-size cost. It's resolved at compilation.

I take the critique of developers that do not like abstraction: things are happening under the hood.

But no cost for memory, code size or performance. And a gain in understanding what you want to achieve in the code.

I'll post examples later.

 

If you want to start playing with the new options: Try out C++20 Preview: set up a development environment

  • I now have a Eclipse Windows setup that supports C++ 20 extensions.

    I downloaded and unpacked Eclipse 2020-12 release C/C++ edition.

    I have Cygwin 64 bit installed, and upgraded GCC from 7.4 to 10.

    image

     

    I created a new "C++ Managed Build" project and selected Cygwin GCC.

     

    image

     

    Checked the Cygwin settings in the project properties:

     

    image

    Then set the dialect to C++2a, the preview of the not yet established standard:

     

    image

     

    Success. Here's a sorting example being debugged:

    image

    The code in the debug window is using the new <==> operator. It works.

  • in reply to Andrew J

      wrote:

     

    You're right, a specific toolchain isn't applicable to the source code, I digressed into the wider C/C++ ecosystem which wasn't the point of your original post.  I do need to get a much better grip on the language as it does seem to be the default go-to for MCUs and I'd like to experience a wider set than just Arduino.

    All of the below is not C / C++ relevant. It's about housing code and data in memory.

    Not an issue for most computer developers. A key item for embedded development.

     

    I've been investigating linker scripts for several reasons lately. It's never an extremely happy story. Because it's a difficult subject that isn't language related. It's architecture and hardware stuff.

    Renesas tried to simplify it with a GUI. I see what they are getting at but it's not intuitive.

    plain GNU toolchain (I deliberately did not say GCC because the linker is language agnostic) has a linker script language that's closer to most other toolchains.

    Also not an easy thing, but Eclipse has a graphical view on it  (not an editor yet) that is excellent.

    In particular for microcontrollers that have scattered memory areas that are RAM, Flash, ROM, memory mapped chip sets, … that aren't managed by an OS.

    You can see there what goes where, or does not fit there. In this case a graph does wonders because you do not have to interpret and analyse logs to see what is too big to fit in an area.

     

    I'm often working with the Hercules controller family that has memory that can correct itself in case a sun flare hits a bit.

    Great functionality, but you have to train the linker how to  generate memory checksums, so that the microcontroller recognises an illegal bit flip in deep space.

    That's when you learn the deep deep trenches of linker files and memory assignment.

     

    But that ain't C / C++ image

  • in reply to Jan Cumps

    You're right, a specific toolchain isn't applicable to the source code, I digressed into the wider C/C++ ecosystem which wasn't the point of your original post.  I do need to get a much better grip on the language as it does seem to be the default go-to for MCUs and I'd like to experience a wider set than just Arduino.

  • in reply to Fred27

    No, that's a really helpful point of view as I hadn't thought about it along those lines. Thanks. In fact that was the very reason I experimented with Go, which was to develop a desktop webapp (didn't get very far mind you). I think I must now give Rust a try.

  • in reply to Andrew J

      wrote:

    ...!  I more or less stumbled across it in the end and IIRC it was something to do with a memory allocation starting address for one of the blocks.  I know you wrote a whole post about setting the allocation up for a more complex/memory intensive build which was useful but wasn’t directly related, or didn’t appear to be.  Their code, in their project worked; their code copied into a new project didn’t and it came down to just one setting in the compiler or linker and the default settings for a new project needed changing.  That then became a new template starting point for examples I created.

     

    ...

    I had that too. The linker of the Renesas chain is not intuitive.

    But for this discussion: that's not a C / C++ thing. At that time the source code is already morphed into binary instructions.