C++ Core Guidelines: Non-Rules and Myths

Of course, you already know many non-rules and myths to C++. Non-rules and myths which we have to argument against when we use modern C++. The supporting section of the C++ core guidelines addresses the most resistant once but also provides alternatives.

dragons head 310697 1280

Here are the rules for today.

Many programmers apply the first rules.

NR.1: Don’t: All declarations should be at the top of a function

This rule is a relict of old programming languages that don't allow initialisation of variables and constants after a statement. The result of a significant distance of the variable declaration and their usage is often, that you forget to initialise the variable. Exactly this happens in the example of the C++ core guidelines:

int use(int x)
{  
    int i;
    char c;
    double d;
    // ... some stuff ...
    if (x < i) {
        // ...
       i = f(x, d);
    }
    if (i < x) {
        // ...
        i = g(x, c);
    }
    return ;
}

 

I assume you already found the issue in this codesnippet. The variable i (the same holds for c and d) is not initialised because it is a built-in variable used in a local scope and, therefore, the program has undefined behaviour. If i would be a user-defined type such as std::string, all would be fine. So, what should you do:

  • Place the declaration of i directly before its first usage.
  • Always initialise a variable such as int i{}, or better, use auto. The compiler can not guess from a declaration such as auto i; the type of i and will, therefore, reject the program. To put it the other way around auto forces you to initialise your variables.

I also know the next rule from discussions.

NR.2: Don’t: Have only a single return-statement in a function

When you follow this rule, you implicitly apply the first non-rule.

template<class T>
std::string sign(T x)    // bad
{
    std::string res;   
    if (x < 0)
        res = "negative";
    else if (x > 0)
        res = "positive";
    else
        res = "zero";
    return res;
}

 

Using more return statements make the code easier to read and also faster.

template<class T>
std::string sign(T x)
{
    if (x < 0)
        return "negative";
    else if (x > 0)
        return "positive";
    return "zero";
}

 

Okay. What happens if I use automatic return type deduction return different types?

// differentReturnTypes.cpp

template <typename T>
auto getValue(T x){
  if (x < 0)          // int
    return -1;
  else if (x > 0)
    return 1.0;       // double
  else return 0.0f;   // float
}

int main(){

    getValue(5.5);
 
}  

 

As expected, just an error:

differentReturnTypes

Probably, the next non-rule is the most controversial one.

NR.3: Don’t: Don’t use exceptions

First, the guideline states the main reasons against exceptions:

  1. exceptions are inefficient
  2. exceptions lead to leaks and errors
  3. exception performance is not predictable

The guidelines have profound answers to these statements.

1. Often the efficiency of exception handling is compared to a program that just terminated, or displays the error code. Often the exception handling implementation is poor. Of course, a comparison makes in such cases no sense. I want to explicitly mention the paper Technical Report on C++ Performance (TR18015.pdf), which presents two typical ways to implement exceptions:

  1. The code approach, where code is associated with each try-block
  2. The "table" approach, which uses compiler-generated static tables

Roughly said, the "code" approach has the downside that even when no exceptions are thrown, the bookkeeping of the exception handling stack must be performed and, therefore, code unrelated to error handling slows down. This downside does not hold for the "table" approach, because it introduces not stack or runtime costs when no exception is thrown. In contrast, the "table" approach seems more complicated to implement, and the static table can get quite big.

2. I have nothing to add to point 2. Exceptions can not be blamed for a missing resource management strategy.

3. If you have hard-realtime guarantees to fulfil so that a too late answer is a wrong answer, an exception implementation based on the "table" approach will not  - as we saw  - affect the run-time of the program in the good case. Honestly, even if you have a hard-realtime system, this hard-realtime restriction typically only hold for small part of your system. 

Instead of arguing against the non-rules, here are the reasons for using exceptions:

Exceptions

  • clearly differentiate between erroneous return and ordinary return.
  • cannot be forgotten or ignored.
  • can be used systematically.

Let me add an anecdote I once faced in legacy code. The system used error codes to signal the success or failure of a function. Okay, they checked the error codes. This was fine. But due to the error codes, the functions didn't use return values. The consequence was, that the functions operated on global variables and, consequently had no parameters because they used the global variables anyway. The end of the story was that the system was not maintainable or testable, and my job was it to refactor it. 

The typical wrong usage of exceptions handling I see is the following one. You catch every exception in every function. In the end, you get unmaintainable code with a spaghetti-like structure. Exceptions are not a tool to make a fast fix but should be part of the overall system architecture. Imagine, you design an input sub-system. You must also document and test the exceptions that can occur. Exceptions are an essential part of the non-functional channel and, therefore, part of the contract that you provide to the user of your sub-system. You need a clear boundary between the application and the sub-system. The result may be that the sub-system translates the obscure exceptions into simpler once so that the application can react. Translating an exception means that you catch obscure exceptions in the sub-system and re-throw an easy do digest exception:

try{
     // code, that may throw an obscure exception
  }   
  catch (ObscureException18& ob){
      throw InputSubsystemError("File has wrong permissions!");
}

 

The result of such a system architecture including the non-functional channel (exceptions) is, that you can test the sub-system in isolation, that you can test the integration of the sub-system into the application, and that you can test the system (application). 

The last myth for today is quite easy to spot.

NR.4: Don’t: Place each class declaration in its own source file

The correct way to structure your code is not to use files; the correct way is it to use namespaces. Using a file for each class declarations result in many files and can make your program, therefore, harder to manage and slower to compile.

What's next?

You can be sure. The C++ core guidelines and I'm not done with the non-rules and myths to C++. I will continue in my next post. Afterwards, when you encounter the non-rules and myths you should know how to demystify them.

Thanks a lot to my Patreon Supporters: Paul Baxter,  Meeting C++, Matt Braun, Avi Lachmish, 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, and Broeserl.

 

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 5384

All 2998137

Currently are 106 guests and no members online

Kubik-Rubik Joomla! Extensions

Latest comments