Myths of My Blog Readers

I was very curious about your C++ myths. In particular, my German readers were quite active. I got a few E-Mails and observed a vivid discussion on Heise Developer.

 

dragon 1512457 1280

Let me first conclude the myths of the C++ core guidelines before I write about your myths. Here is the last myth.

NR.7: Don’t: Make all data members protected

Protected data makes your program complex and error-prone. If you put protected data into a base class, you can not reason about derived classes in isolation and, therefore, you break encapsulation. You always have to reason about the entire class hierarchy.

This means you have to answer at least these three questions.

  1. Do I have to implement a constructor in a derived class to initialise the protected data?
  2. What is the actual value of the protected data if I use them?
  3. Who will be affected if I modify the protected data?

Answering these questions becomes more and more complicated, the deeper you class hierarchy becomes.

If you think about it: protected data is a kind of global data in the scope of the class hierarchy. And you know, mutable shared state is terrible. It makes, for example, testing and concurrency quite tricky.

Now, I switch to your myths. I write about them in the order I received them.

In C++ written programs need more memory and CPU as in C written programs (Gunter Königsmann)

First of all: thanks to Gunter Königsmann for the classical myth.

Honestly, arguing against this myth is quite difficult and in general not possible for the C++ standard library. This is the reason, I make only a few observations add the end of this chapter. First of all, here are the hard facts. The "Technical Report on C++ Performance" helps me a lot.

Technical report on C++ performance

The Working Group WG 21 published in the year 2006 the paper ISO/IEC TR 18015. The title sounds not very interesting but that document is the ultimate source if you want to get the performance numbers to the C++ features. The document expresses its concerns directly to the point.  

  • to give the reader a model of time and space overheads implied by use of various C++ language and library features,
  • to debunk widespread myths about performance problems,
  • to present techniques for use of C++ in applications where performance matters, and
  • to present techniques for implementing C++ Standard language and library facilities to yield efficient code.

Authors of the paper with more than 200 pages are well known C++ experts like Dave Abrahams, Howard Hinnand, Dietmar Kühl, Dan Saks, Bill Seymour, Bjarne Stroustrup, and Detlef Vollmann.

The scope of the document are C++ features, their overhead and usage, the creation of efficient libraries in C++, the usage of C++ in embedded system, and the interfaces in C++ to communicate with the hardware.

C++ features, Overhead, and Usage

The authors use for their analysis three computer architectures with five different compilers. They use the compilers with different optimisation level. I will give you only an idea of the results that are quite remarkable.

  • Namespaces
    • Have no significant overhead in size and performance
  • Type converting operator
    • The C++ casts const_cast, static_cast, and reinterpret_cast differ neither in size nor in performance from their C pedant.
    • The at runtime executed dynamic_cast has some overhead. (Remark: The conversion has no C pedant.).
  • Inheritance
    • Class
      • A class without virtual functions is as big as a struct.
      • A class with virtual functions has the overhead of a pointer and a virtual function table. These are about 2 to 4 bytes. 
    • Function calls
      • The call of a non-virtual, non-static, and non-inline function is as expensive as the call of a free function.
      • The call of a virtual function is as expensive as the call of a free function with the help of a pointer that is stored in a table. 
      • Virtual functions of a class template can cause overhead in size.
      • The inlining of a function causes significant performance benefits and is close to the performance of a C macro.
    • Multiple inheritances
      • Can cause time and/or space overhead.
      • Virtual base classes have overhead compared to non-virtual base classes.
  • Run-time type information (RTTI)
    • There are about 40 additional bytes for each class necessary.
    • The typeid call is quite slow. That seems due to the quality of the implementation.
    • The conversion during runtime with dynamic_cast is slow. According to the reports that should also be due to the quality of the implementation.
  • Exception handling
    • There are two strategies for dealing with exceptions. These are the code and the table strategy. The code strategy has to move and manage additional data structures for dealing with exceptions. The table strategy has the execution context in a table. 
      • The code strategy has a size overhead for the stack and the runtime. The runtime overhead is about 6%. This overhead exists even without the throwing of an exception.
      • The table strategy has neither overhand in program size nor in runtime. (Remarks: That statements hold only if no exceptions was thrown.). The table strategy is more difficult to implement. 
  • Templates
    • You get for each template instantiation a new class template or function template. Therefore, the naive use of temples can cause code bloat. Modern C++ compilers can massively reduce the number of template instantiations. The usage of partial or full specialisation helps to reduce the template instantiations.

You can read the details, the exact number and few additionals topics directly in the report: TR18015.pdf.

Still not convinced? Here is a cite from MISRA C++:

MISRA C++

MISRA C++ (Motor Industry Software Reliability Association) formulates guidelines software in safety-critical systems.  It was originally designed for the automotive industry and became the de facto standard in the aviation, military and medical sector. The question is, what MISRA says about C++?

MISRA emphasises why the importance of C++ in critical systems becomes more important. (1.1 The use of C++ in critical systems):

  • C++ gives good support for high-speed, low-level, input/output operations, which are essential to many embedded systems.
  • The increased complexity of applications make the use of a high-level language more appropriate than assembly language.
  • C++ compilers generate code with similar size and RAM requirements to those of C.

But one small downer remains. MISRA C++ is based on classical C++. This is simply speaking C++98. Modern C++ has a lot more to offer for embedded systems. This remark does not only hold for MISRA C++ but also holds on the previous mentioned Technical report on C++ performance.

I can not conclude my post without a few observations to modern C++.  Modern C++ is a term which is mostly used for the three C++ standards  C++11, C++14, and C++17.

My Observations

The difficulty in the comparison of the C++ standard library to its C pendants is, in particular, that you have to compare equivalent data structures or programs. This means, you can not compare a C-string and a C++-string, because the later supports automatic memory management. The same holds for a C-array in contrast to the C++ containers. Without further ado, here are my points. If you are more curious, read the mentioned post.

What's next?

Wow? It took me almost an entire post to argue against the memory and performance myth. You can imagine that I have to demystify additional myths, which I got. If you have a myth, now it's time to send them to me: This email address is being protected from spambots. You need JavaScript enabled to view it..

 

Thanks a lot to my Patreon Supporters: Paul Baxter,  Meeting C++, Matt Braun, Roman Postanciuc, Venkata Ramesh Gudpati, Tobias Zindl, Marko, Ramesh Jangama, G Prvulovic, Reiner Eiteljörge, Benjamin Huth, Reinhold Dröge, Timo, Abernitzke, Richard Ohnemus , Frank Grimm, Sakib, Broeserl, and António Pina.

 

Thanks in particular to:
 TakeUpCode 450 60
crp4

 

   

Get your e-book at Leanpub:

The C++ Standard Library

 

Concurrency With Modern C++

 

Get Both as one Bundle

cover   ConcurrencyCoverFrame   bundle
With C++11, C++14, and C++17 we got a lot of new C++ libraries. In addition, the existing ones are greatly improved. The key idea of my book is to give you the necessary information to the current C++ libraries in about 200 pages.  

C++11 is the first C++ standard that deals with concurrency. The story goes on with C++17 and will continue with C++20.

I'll give you a detailed insight in the current and the upcoming concurrency in C++. This insight includes the theory and a lot of practice with more the 100 source files.

 

Get my books "The C++ Standard Library" (including C++17) and "Concurrency with Modern C++" in a bundle.

In sum, you get more than 600 pages full of modern C++ and more than 100 source files presenting concurrency in practice.

 

Get your interactive course

 

Modern C++ Concurrency in Practice

C++ Standard Library including C++14 & C++17

educative CLibrary

Based on my book "Concurrency with Modern C++" educative.io created an interactive course.

What's Inside?

  • 140 lessons
  • 110 code playgrounds => Runs in the browser
  • 78 code snippets
  • 55 illustrations

Based on my book "The C++ Standard Library" educative.io created an interactive course.

What's Inside?

  • 149 lessons
  • 111 code playgrounds => Runs in the browser
  • 164 code snippets
  • 25 illustrations

Add comment


My Newest E-Books

Course: Modern C++ Concurrency in Practice

Course: C++ Standard Library including C++14 & C++17

Course: Embedded Programming with Modern C++

Course: Generic Programming (Templates)

Subscribe to the newsletter (+ pdf bundle)

Blog archive

Source Code

Visitors

Today 914

All 2910087

Currently are 182 guests and no members online

Kubik-Rubik Joomla! Extensions

Latest comments