Home »

DR20 - The Equality Operator You Are Looking For -- Sandor Dargo

By Blog Staff | Feb 13, 2024 05:34 PM | Tags: None

SANDOR_DARGO_ROUND.JPGWe delve into how C++20 introduced changes to object comparisons, leading to unexpected behavior and the need for matching operator!= declarations.

DR20 - The Equality Operator You Are Looking For

by Sandor Dargo

From the article:

When I see DR, I immediately think about Disaster Recovery. That’s due to my first corporate job where I worked as a Database Administrator and we had regular exercises to simulate events when datacenters would be unavailable.

When you see DR in the title of a C++ proposal, it’s not about a disaster, it’s more about a bug. DR stands for defect report. But the paper itself is usually not about reporting that there is a problem - that has been already done -, but more about proposing a solution.

What’s more important is that defect reports are not becoming part of the latest standard, they retrospectively change the one that introduced the defect.

A defect of C++20’s equality operator

P2468R2 is addressing a problem that was introduced by C++20. C++20 brought us the spaceship operator (operator<=>), but it further changed the logic of object comparisons. It changed the meaning of == and != and how overload resolution applies to them.

PVS-Studio 7.29: Boost smart pointers, plugin for Qt Creator on macOS

By Andrey Karpov | Feb 13, 2024 06:49 AM | Tags: qt creator pvs-studio misra boost

PVS-Studio 7.29 has been released. Now you can analyze Java projects in a plugin for VS Code, check Boost smart pointers, use the PVS-Studio plugin for Qt Creator 12 on macOS, and that's not all.

PVS-Studio 7.29: Java code check in VS Code, Boost smart pointers, and plugin for Qt Creator on macOS

by Gleb Aslamov

From the article:

The C++ analyzer now supports smart pointers from the Boost library: boost::unique_ptr and boost::shared_ptr. Now the PVS-Studio analyzer is able to detect errors such as null pointer dereferences when these classes are used.

Aggregates: C++17 vs. C++20 -- Andreas Fertig

By Blog Staff | Feb 9, 2024 01:05 PM | Tags: None

Sometimes the small changes between two C++ standards really bite you. Today's post is about when I got bitten by a change to aggregates in C++20.

Aggregates: C++17 vs. C++20

by Andreas Fertig

From the article:

Attendees of my training classes usually assume that I know everything. I can say sorry, but that's not the case. One day in the past, I showed the following example during a class:

struct Point {
  int x;
  int y;
};

Point pt{2, 3};

The class did cover C++17 and C++20. The code of Point is a reduced version for this post. We were talking about C++17's structured bindings. I use Point to show the decomposition using C++ Insights.

I showed the behavior and certain variations while answering questions from the attendees. One question was about move and copy. The question leads me changing the initial code to the following one:


	

		
			

				
					

						
2
3
4
5
6
7
8

					

						
				
					

						
struct Point {
  int x;
  int y;

  Point(Point&&) = delete;  A 

};

Point pt{2, 3};

					

						
			

		
	




	

		
			

				
					

						
2
3
4
5
6
7
8

					

						
				
					

						
struct Point {
  int x;
  int y;

  Point(Point&&) = delete;  A 
};

Point pt{2, 3};

					

						
			

		
	




	As you can see, in A, I deleted the move constructor. As far as I remember, this topic was more or less the last one for this day. Everything went well and as expected.



	

		The next morning one of the attendees approached me with the question of why the code didn't compile on his machine. My usual answer here is that if C++ were be easy, I wouldn't have the job I have. Somehow this never shuts down such questions. I like curious attendees.

	

		He shared his code via Compiler Explorer. Guess what? His code looked exactly like mine but didn't compile. Here is the error message from the compiler:



      


      
      
    
    
      

        
Machine Code Explained -- Matt Godbolt

        
By Blog Staff | 
        Feb 8, 2024 05:34 PM 
         | 
        Tags: None  

        

	machinecode.pngExplaining machine code from the ground up! 



	

		Machine Code Explained

	

		by Matt Godbolt





	From the video:



	

		In this video, Matt Godbolt appears on Computerphile to discuss their fascination with how computers work and their mental model developed in the 1980s, which still helps them understand modern computer systems. They use a simple analogy involving a robot with an abacus and pigeonholes to explain fundamental computer operations and how programs are executed. Matt then demonstrates how machine code, the computer's language, can be represented as a sequence of numbers and stored in memory to instruct the computer in performing tasks, illustrating the basic concept of programming.



      


      
      
    
    
      

      
      
    
    
      

        
What are senders good for, anyway? -- Eric Niebler

        
By Eric Niebler | 
        Feb 6, 2024 12:46 PM 
         | 
        Tags: 
                    c++26

        

	In a recent blog post, Eric Niebler gets inside the soon-to-be-standard async programming model and shows why you should care.



	



	

		What are senders good for, anyway?





	

		

			by Eric Niebler

	





	From the article:



	

		At the heart of P2300 is a simple, elegant (IMHO) core that brings many benefits, but it’s hard to see that forest for all the trees.

	

		So let’s make this concrete. In this post, I’ll show how to bring a crusty old C-style async API into the world of senders, and why you might want to do that.



      


      
      
    
    
      

        
mp-units 2.1.0 released -- Mateusz Pusz

        
By Mateusz Pusz | 
        Feb 6, 2024 12:40 PM 
         | 
        Tags: None  

        

	We are happy to announce that mp-units 2.1.0 has been released and is available for download in Conan.



	

		mp-units 2.1.0 released!

	

		by Mateusz Pusz





	About the release



	

		Please check our blog post to read more about the improvements and some, unfortunately, breaking changes.





	

		 

	

		 



      


      
      
    
    
      

        
How I Learned to Stop Worrying and Love Juggling C++ Atomics -- brilliantsugar

        
By Felix Petriconi | 
        Feb 4, 2024 07:07 AM 
         | 
        Tags: None  

        

	In his recent blog post brilliantsugar talks about technics to find race conditions in multithreading code by using different tools.



	

		How I Learned to Stop Worrying and Love Juggling C++ Atomics

	

		by brilliantsugar





	From the blog post



	

		As most C++ programmers are aware, courtesy of Herb Sutter, programming lock-free data structures is akin to juggling razor blades. Reasoning about concurrent programs is already complex enough but modern CPU memory models are so complicated that they manage to make it even harder. The prevailing suggestion you often come across is to steer clear of lock-free programming entirely.

	

		In this article, I share the adventures of exploring methods for formally verifying lock-free C++ code. To showcase three different approaches, I delve into the implementation of a lock-free triple buffer data structure.





	 



	 

      


      
      
    
    
      

        
Class Invariants --  Andrzej Krzemieński

        
By Andrzej Krzemienski | 
        Feb 4, 2024 06:05 AM 
         | 
        Tags: None  

        

	Andrzej talks in his recent blog post about class invariants.



	

		Class Invariants





	

		by Andrzej Krzemieński





	About the blog post:



	

		The primary motivation for defining a class in C++ is to reflect and maintain a class invariant. In this post we will see what class invariants are and how you deal with them. Class invariants are important part of C++, even though there is no “invariant” keyword in C++.