Comprehensive Guide to C++

C++ is a powerful, high-performance programming language often used in system programming, game development, and applications that require direct memory control. It combines the features of procedural, object-oriented, and generic programming.

Core Concepts of C++

• Object-Oriented Programming (OOP): C++ supports OOP principles such as:
  • Classes and Objects: Classes define a blueprint; objects are instances of classes.
  • Encapsulation: Bundles data and methods operating on the data into a single unit.
  • Inheritance: Enables creating new classes from existing ones.
  • Polymorphism: Allows methods to behave differently based on the object.

  class Animal {
  public:
      void speak() { cout << "Animal speaks"; }
  };
  
  class Dog : public Animal {
  public:
      void speak() { cout << "Dog barks"; }
  };

• Pointers and Memory Management: Pointers store memory addresses. C++ allows manual memory allocation using new and deallocation using delete.

  int* ptr = new int(5);
  cout << *ptr; // Output: 5
  delete ptr;

  This gives fine-grained control but requires caution to avoid memory leaks.
• Templates: Templates let you write generic functions/classes that work with any data type.

  template <typename T>
  T add(T a, T b) {
      return a + b;
  }

  This reduces code duplication for operations on different data types.

Important Topics

• Primitive Data Types: These are basic types such as int, float, double, char, bool. Example:

  int age = 25;
  float salary = 75000.5;

• Control Structures: These include decision-making and looping constructs like:

  if (x > 10) {
    cout << "x is greater than 10";
  } else {
    cout << "x is 10 or less";
  }
  
  for (int i = 0; i < 5; i++) {
    cout << i;
  }

• Functions and Overloading: Functions perform specific tasks. Overloading allows functions with the same name but different parameters.

  int add(int a, int b) { return a + b; }
  double add(double a, double b) { return a + b; }

• Dynamic Memory Allocation: Memory can be allocated during runtime.

  int* arr = new int[5]; // dynamically allocated array
  arr[0] = 10;
  delete[] arr;         // free memory

• Standard Template Library (STL): STL includes commonly used data structures and algorithms.

  #include <vector>
  #include <map>
  
  vector<int> v = {1, 2, 3};
  map<string, int> m = {{"apple", 2}};

  STL greatly simplifies development and improves performance.

Advanced Concepts

• Operator Overloading: Allows custom behavior for operators like +, -, etc., for user-defined types.

  class Complex {
    int real, imag;
  public:
    Complex(int r, int i): real(r), imag(i) {}
    Complex operator + (const Complex& obj) {
      return Complex(real + obj.real, imag + obj.imag);
    }
  };

• RAII (Resource Acquisition Is Initialization): Resources like memory or files are acquired in constructors and released in destructors, ensuring safe cleanup.

  class FileWrapper {
    FILE* f;
  public:
    FileWrapper(const char* name) { f = fopen(name, "r"); }
    ~FileWrapper() { fclose(f); }
  };

• Multithreading: C++11 introduced std::thread for concurrent execution.

  #include <thread>
  void run() {
    cout << "Thread running";
  }
  int main() {
    thread t(run);
    t.join();
  }

  This runs run() in a separate thread and waits for it to finish.