Here are 24 C++ pitfalls to avoid.

[[396092]]

This article is reprinted from the WeChat public account "Program Cat Adult", the author is Program Cat Adult. Please contact Program Cat Adult's public account to reprint this article.

The following is the table of contents of this article:

First, what is the difference between C++ and C? Let me share an answer I saw on Zhihu:

• C++ ≈ C with classes, C with STL
• C: Machine-Oriented Programming
• C++: Compiler-Oriented Programming

C++ has a very important feature called RAII. I think it can be used a lot and is quite convenient. For more information about the clever use of RAII, you can read my two articles "The Magic of RAII: ScopeExit" and "The Magic of RAII: Calculating Function Time Consumption".

Now, let me list the common pitfalls in using C++ one by one:

Incorrect use of unsigned integers

 for (unsigned int i = 10; i >= 0; --i) { ... }  

What will happen in the above code? It will go into an infinite loop. Pay attention to the use of unsigned integers here.

The size() return type of a container is an unsigned integer

 std::vector< int > vec;
 vec.push_back(1);
 for (auto idx = vec. size (); idx >= 0; idx --) {  
 cout << "===== \n" ;
 }

This code will still have an infinite loop, refer to the previous one for the reason.

memcpy and memset are only applicable to POD structures

As for what a POD type is, it is actually quite difficult to explain. If you are interested, you can directly look at cppreference https://en.cppreference.com/w/cpp/named_req/PODType

Pay attention to iterator invalidation when traversing and deleting STL

 void erase(std::vector< int > &vec, int a) {
 for (auto iter = vec.begin (); iter != vec.end ( ) ; ) { // This is correct
 if (*iter == a) {
            iter = vec.erase(iter);
 } else {
 ++iter;
 }
 } 
 
 for (auto iter = vec. begin (); iter != vec. end (); ++iter) { // error
 if (*iter == a) {
            vec.erase(iter); // error
 }
 }
 }

std::list sorting using own member methods

General container sorting uses std::sort(), but list is special.

 int main() {
    std::list< int > list{1, 2, 3, 2};
 list.sort();
    // std::sort(list. begin (), list. end ());
 for (auto i : list) {
        std::cout << i << " " ;
 }
 std::cout << "\n" ;
 return 0;
 }

Strict pairing of new/delete, new[]/delete[], malloc/free

These must be used in pairs. For the reason, you can read my previous article "Why should new[] and delete[] be used in pairs?"

The base class destructor must be a virtual function

If it is not a virtual function, there may be a memory leak problem

Comments are written with /**/ instead of //

Using /**/ for comments may cause problems. Reason: After the encoding of utf-8 and ANSC (GB2312) is confused, Chinese comments are garbled. The garbled characters contain */, which is mismatched. As a result, the actual commented part of the IDE is not visible to the naked eye, making it extremely difficult to locate. This is common in Windows.

Member variable initialization

Member variables have no default initialization behavior and need to be initialized manually.

Do not return pointers or references to local variables

 char * func() {
 char a[3] = { 'a' , 'b' , 'c' };
 return a;
 }

Stack memory is easily polluted.

Floating point number equality problem

 float f;
 if (f == 0.2) {} // Incorrect usage
 if ( abs (f - 0.2) < 0.00001) {} // Correct usage

Vector clear and swap issues

To clear a vector, you can use swap instead of its clear method, which can release the internal memory of the vector earlier.

 vector< int > vec;
 vector< int >().swap(vec);
 vec.clear();

Vector Problem

Try not to store bool types in vectors. For optimization purposes, vectors don’t actually store bools inside.

Condition variables

There are two major problems with the use of conditional variables: signal loss and false wakeup, which are quite important. For details, please refer to my article "Do you know the pitfalls of using conditional variables?"

Type conversion

In C++, try to use the four C++ style type conversions instead of C language style forced type conversions.

Use of async in asynchronous operations

 std::async(std::launch::async, []{ f(); }); // The destructor of the temporary waits for f()
 std::async(std::launch::async, []{ g(); }); // does not start until f() completes

The future returned by std::async behaves differently from the future obtained through promise. The future object returned by async will block and wait for the thread in async to complete execution when it is destroyed. This means that in most scenarios, async cannot achieve the purpose you intuitively think it can achieve.

Smart Pointers

Do not wrap a raw pointer with multiple smart pointers, and use make_unique and make_shared as much as possible.

When you need to use this as a smart pointer in the internal interface of a class, you need to derive this class from enable_shared_from_this

Stack memory usage

Reasonable use of stack memory, especially arrays. Array out-of-bounds problems can easily lead to stack space damage. You can consider using std::array instead of ordinary arrays.

Use of std::thread

Be sure to remember to join or detach, otherwise it will crash.

 void func() {}
 int main() {
 std::thread t(func);
 if (t.joinable()) {
 t.join (); // or t.detach();
 }
 return 0;
 }

Enum usage

Try to use enum class instead of enum. Enum class is an enumeration type with a scope.

For null pointers, use nullptr instead of NULL

As for why it is used this way, you can read my article "You must read this article about nullptr"

 void func( char *) {
 cout << "char*" ;
 }
 void func( int ) {
 cout << "int" ;
 } 
 
 int main() {
 func( NULL ); // Compilation failed error: call of overloaded 'func( NULL )' is ambiguous
 func(nullptr); // char *
 return 0;
 }

Use of std::remove

This remove does not actually delete the element. It needs to be used in conjunction with erase. You will know it by running this code.

 bool isOdd( int i) { return i & 1; } 
 
 void print(const std::vector< int >& vec) {
 for (const auto& i : vec) {
        std::cout << i << ' ' ;
 }
 std::cout << std::endl;
 } 
 
 int main() {
    std::vector< int > v = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 print(v); 
 
    std::remove(v. begin (), v. end (), 5); // error
 print(v); 
 
    v.erase(std::remove(v. begin (), v. end (), 5), v. end ());
 print(v); 
 
    v.erase(std::remove_if(v. begin (), v. end (), isOdd), v. end ());
 print(v);
 }

Global variable initialization problem

The order of initialization of global variables in different files is not fixed. Global variables should not depend on each other as much as possible. Otherwise, bugs may occur due to the problem of unstable initialization order.