C++: a quick overview

See the dedicated pages for details.

Basics of a Class

A class in C++ is a blueprint for creating objects. It encapsulates data and functions that operate on the data. Syntax:

class ClassName {
  // Access specifiers
  // Data members
  // Member functions
};Copy

Class Constructor

A constructor initializes objects of a class. It has the same name as the class:

ClassName() {
  // Initialization code
}Copy

Class Constructor Initializer List

Use an initializer list to initialize class members before the constructor body executes:

ClassName() : member1(value1), member2(value2) {
// Constructor body
}Copy

Class Destructor and Virtual Destructor

A destructor cleans up resources. Use a virtual destructor in base classes to ensure derived class destructors are called:

virtual ~ClassName() {
// Cleanup code
}Copy

Class Assignment Operator

Overload the assignment operator to assign values from one object to another:

ClassName& operator=(const ClassName& other) {
// Assignment code
return *this;
}Copy

Class Access Specifiers

Access specifiers define the scope of class members:

• public: Accessible from outside the class.
• protected: Accessible within the class and derived classes.
• private: Accessible only within the class.

Class Friendship

A friend function or class can access private and protected members of another class:

class ClassName {
friend void FriendFunction();
};Copy

Class Relationship

• Inheritance: Establishes an "is-a" relationship.
• Composition: Establishes a "has-a" relationship.

Inheritance

Derive a class from a base class:

class Derived : public Base {
  // Additional members
};Copy

Polymorphism

Achieve polymorphism using virtual functions:

virtual void FunctionName() {
  // Code
}Copy

Const Member Function

A const member function does not modify the object:

void FunctionName() const {
// Function code
}Copy

Smart Pointers

• shared_ptr: Manages shared ownership of an object.
• unique_ptr: Manages exclusive ownership of an object.
• weak_ptr: Observes an object managed by shared_ptr.

Templates

Function Template: Define functions with generic types.

template <typename T>
T FunctionName(T param) {
  // Code
}Copy

Class Template: Define classes with generic types.

template <typename T>
class ClassName {
  T member;
};Copy

Variable Template: Define variables with generic types.

template <typename T>
constexpr T pi = T(3.1415926535897932385);Copy

Template Specification

Provide specific implementation for certain types:

template <>
class ClassName {
  // Specialized code for int
};Copy

Type Casting

• C-Style Casting: (type)value
• Static Casting: static_cast<type>(value)
• Dynamic Casting: dynamic_cast<type*>(ptr)
• Const Casting: const_cast<type>(value)
• Reinterpret Casting: reinterpret_cast<type>(value)

Pass by Value, Pointer, or Reference

• Pass by Value: Function gets a copy of the argument.
• Pass by Pointer: Function gets the address of the argument.
• Pass by Reference: Function operates directly on the argument.