Common C++ Programming Mistakes

Introduction

C++ is a powerful programming language, but it can be easy to make mistakes if you're not careful. Here are some of the most common C++ programming mistakes:

1. Forgetting to initialize variables

If you forget to initialize a variable before you use it, you'll end up with unpredictable behavior. Make sure to initialize all variables before you use them.
cpp 
	int main() {
	  int x;
	  // variable x is uninitialized, may contain garbage value
	  std::cout << x;
	  return 0;
	}

2. Null pointer dereferencing

If you dereference a null pointer, you'll get a segmentation fault. Always make sure to check for null pointers before you use them.
cpp 
	int main() {
	  int* ptr = nullptr;
	  // dereferencing a null pointer is undefined behavior
	  std::cout << *ptr;
	  return 0;
	}

3. Memory leaks

If you allocate memory using new, make sure to deallocate it using delete when you're done. If you don't, you'll end up with memory leaks that can cause your program to run out of memory.
cpp 
	int main() {
	  int* ptr = new int;
	  // do something with ptr
	  // forget to delete the memory pointed to by ptr
	  return 0;
	}

4. Buffer overflows

A buffer overflow occurs when you attempt to write data outside the boundaries of a fixed-length buffer. This can cause memory corruption, crashes, or even security vulnerabilities. In C++, buffer overflows can happen when using standard C library functions like strcpy or scanf, which do not perform bounds checking on input data. Properly checking and limiting the size of input data can prevent buffer overflow errors.
cpp 
	int main() {
	  char buffer[5];
	  // if user inputs more than 5 characters,
	  // buffer overflow occurs
	  std::cin >> buffer;
	  return 0;
	}

5. Array Indexing

Array indexing errors in C++ occur when an index used to access an array element is outside the range of valid indices for that array. This can lead to memory access violations, data corruption, and program crashes. When writing code, always ensure that the index used to access an array is always within the bounds of the array.
cpp 
	int main() {
	int arr[3] = {1, 2, 3};
	std::cout << arr[3]; // trying to access element outside the array bounds
	return 0;
	}

6. Division by Zero

Division by zero occurs when a program tries to divide a number by zero, which is undefined and can lead to program crashes or incorrect results. You should handle this error condition by checking for zero denominators before performing division operations.
cpp 
	int main() {
	  int x = 10, y = 0;
	  // division by zero is undefined behavior
	  int z = x / y;
	  return 0;
	}

7. Incorrect use of pointers and references

Pointers and references are powerful features in C++, but they can be confusing if you don't use them correctly. Make sure to understand how to use them properly.

Example for an incorrect use of a pointer:

cpp 
	int main() {
	  int arr[3] = {1, 2, 3};
	  int* ptr = arr;
	  // output is not guaranteed, as order of evaluation
	  // is undefined
	  std::cout << *ptr++ << " " << *ptr++ << " " << *ptr;
	  return 0;
	}

Example for using uninitialized pointers

cpp 
	int main() {
	  int* ptr;
	  // dereferencing an uninitialized pointer is
	  // undefined behavior
	  *ptr = 5;
	  return 0;
	}

Example for using uninitialized references:

cpp 
	int main() {
	  int& ref;
	  // using an uninitialized reference is undefined behavior
	  std::cout << ref;
	  return 0;
	}

8. Incorrect operator precedence

Incorrect operator precedence is a common mistake in C++ where the order of operators is not respected leading to unexpected results. This mistake can be avoided by using parentheses to enforce the correct order of operations.

cpp 
	int main() {
	  int x = 10, y = 5, z = 2;
	  int result = x / y * z; // result will be 0, not the expected 4
	  return 0;
	}

9. Using goto statements

goto statements can make your code difficult to read and understand, especially in larger codebases. Avoid using goto statements whenever possible. In many cases, it may be better to use structured control statements such as while loops, for loops, and if-else statements to achieve the desired functionality.

cpp 
	#include <iostream>
	
	int main() {
	  int i = 0;
	loop:
	  std::cout << i << std::endl;
	  i++;
	  if (i < 5)
	    goto loop;
	  return 0;
	}