C++ is a powerful, high-performance programming language that supports procedural, object-oriented, and generic programming. It is widely used in software development for applications requiring real-time performance, such as game development, system/software development, and large-scale simulations.

Basic Syntax and Structure

Comments :
- Single-line comments start with double slashes (//).
- Multi-line comments are enclosed in /* and */.
Preprocessor Directives :
- Preprocessor directives begin with a hash (#).

Main Function :

The entry point of a C++ program is the main function.

int main() {
 std::cout << "Hello, World!" << std::endl;
 return 0;
}

Data Types :

Common data types include int, float, double, char, and bool.

int age = 25;
float height = 5.9f;
double pi = 3.14159;
char initial = 'A';
bool isActive = true;

Control Structures

Conditional Statements :

if, else if, and else are used for decision making.

if (age > 18) {
 std::cout << "Adult" << std::endl;
} else {
 std::cout << "Minor" << std::endl;
}

Switch Statement :

Used for multi-way branching.

switch (initial) {
 case 'A':
 std::cout << "Grade A" << std::endl;
 break;
 case 'B':
 std::cout << "Grade B" << std::endl;
 break;
 default:
 std::cout << "Other Grade" << std::endl;
}

Loops :

for, while, and do-while loops for iteration.

for (int i = 0; i < 5; i++) {
 std::cout << i << std::endl;
}
int j = 0;
while (j < 5) {
 std::cout << j << std::endl;
 j++;
}
int k = 0;
do {
 std::cout << k << std::endl;
 k++;
} while (k < 5);

Functions

Defining Functions :

Functions are defined using the return type, function name, and parameters.

int add(int a, int b) {
 return a + b;
}
int main() {
 int sum = add(5, 3);
 std::cout << "Sum: " << sum << std::endl;
 return 0;
}

Void Functions :

Functions that do not return a value.

void greet() {
 std::cout << "Hello, World!" << std::endl;
}
int main() {
 greet();
 return 0;
}

Inline Functions :

Declared with the inline keyword to suggest to the compiler to expand the function inline.

inline int square(int x) {
 return x * x;
}
int main() {
 std::cout << "Square of 5: " << square(5) << std::endl;
 return 0;
}

Object-Oriented Programming

Classes and Objects :

Classes define the blueprint for objects.
Objects are instances of classes.

class Dog {
public:
 std::string name;
 int age;
 Dog(std::string name, int age) {
 this->name = name;
 this->age = age;
 }
 void bark() {
 std::cout << name << " says woof!" << std::endl;
 }
};
int main() {
 Dog myDog("Buddy", 3);
 myDog.bark();
 return 0;
}

Inheritance :

Allows a class to inherit attributes and methods from another class.

class Animal {
public:
 std::string name;
 void speak() {
 std::cout << "Animal speaks" << std::endl;
 }
};
class Dog : public Animal {
public:
 void speak() {
 std::cout << name << " says woof!" << std::endl;
 }
};
int main() {
 Dog myDog;
 myDog.name = "Buddy";
 myDog.speak();
 return 0;
}

Polymorphism :

Allows methods to do different things based on the object it is acting upon.

class Animal {
public:
 virtual void speak() {
 std::cout << "Animal speaks" << std::endl;
 }
};
class Dog : public Animal {
public:
 void speak() override {
 std::cout << "Dog barks" << std::endl;
 }
};
class Cat : public Animal {
public:
 void speak() override {
 std::cout << "Cat meows" << std::endl;
 }
};
int main() {
 Animal* myDog = new Dog();
 Animal* myCat = new Cat();
 myDog->speak(); // Output: Dog barks
 myCat->speak(); // Output: Cat meows
 delete myDog;
 delete myCat;
 return 0;
}

Templates

Function Templates :

Allow functions to operate with generic types.

template 
T add(T a, T b) {
 return a + b;
}
int main() {
 std::cout << "Sum of ints: " << add(3, 4) << std::endl;
 std::cout << "Sum of doubles: " << add(3.5, 4.5) << std::endl;
 return 0;
}

Class Templates :

Allow classes to operate with generic types.

template 
class Box {
public:
 T value;
 Box(T value) : value(value) {}
 T getValue() {
 return value;
 }
};
int main() {
 Box intBox
 Box doubleBox(456.78);
 std::cout << "Integer Box: " << intBox.getValue() << std::endl;
 std::cout << "Double Box: " << doubleBox.getValue() << std::endl;
 return 0;
}

Exception Handling

Try-Catch Blocks :

Used to handle exceptions and prevent program crashes.

try {
 int result = 10 / 0;
} catch (const std::exception& e) {
 std::cerr << "Exception: " << e.what() << std::endl;
}

Custom Exceptions :

Define custom exception classes for specific error conditions.

class DivisionByZeroException : public std::exception {
public:
 const char* what() const noexcept override {
 return "Division by zero is not allowed!";
 }
};
int divide(int a, int b) {
 if (b == 0) {
 throw DivisionByZeroException();
 }
 return a / b;
}
int main() {
 try {
 int result = divide(10, 0);
 } catch (const DivisionByZeroException& e) {
 std::cerr << "Exception: " << e.what() << std::endl;
 }
 return 0;
}

Standard Template Library (STL)

Vectors :

Dynamic array that can resize itself automatically.

#include 
#include 
int main() {
 std::vector numbers = {1, 2, 3, 4, 5};
 numbers.push_back(6);
 for (int num : numbers) {
 std::cout << num << " ";
 }
 return 0;
}

Maps :

Associative containers that store key-value pairs.

#include 
#include 
int main() {
 std::map ages;
 ages["Alice"] = 30;
 ages["Bob"] = 25;
 std::cout << "Alice's age: " << ages["Alice"] << std::endl;
 return 0;
}

Iterators :

Objects that point to elements in containers and can traverse through the container.

#include 
#include 
int main() {
 std::vector numbers = {1, 2, 3, 4, 5};
 for (std::vector::iterator it = numbers.begin(); it != numbers.end(); ++it) {
 std::cout << *it << " ";
 }
 return 0;
}

File I/O

Reading from a File :

#include 
#include 
#include 
int main() {
 std::ifstream file("example.txt");
 std::string line;
 if (file.is_open()) {
 while (getline(file, line)) {
 std::cout << line << std::endl;
 }
 file.close();
 } else {
 std::cerr << "Unable to open file" << std::endl;
 }
 return 0;
}

Writing to a File :

#include 
#include 
int main() {
 std::ofstream file("example.txt");
 if (file.is_open()) {
 file << "Hello, World!" << std::endl;
 file.close();
 } else {
 std::cerr << "Unable to open file" << std::endl;
 }
 return 0;
}

Memory Management

Dynamic Memory Allocation :

Memory can be allocated and deallocated using new and delete.

int* ptr = new int(10);
std::cout << "Value: " << *ptr << std::endl;
delete ptr;
int* arr = new int[5];
for (int i = 0; i < 5; i++) {
 arr[i] = i + 1;
}
delete[] arr;

Preprocessor Directives

Macros :

Define constants or functions using the #define directive.

#define PI 3.14159
#define SQUARE(x) ((x) * (x))
int main() {
 std::cout << "PI: " << PI << std::endl;
 std::cout << "Square of 5: " << SQUARE(5) << std::endl;
 return 0;
}

Conditional Compilation :

Control the compilation process using #if, #ifdef, #ifndef, #else, and #endif.

#define DEBUG
int main() {
#ifdef DEBUG
 std::cout << "Debug mode" << std::endl;
#else
 std::cout << "Release mode" << std::endl;
#endif
 return 0;
}

Summary

C++ is a powerful and versatile programming language that provides low-level access to memory and system resources. Understanding its basic syntax, control structures, functions, object-oriented principles, templates, exception handling, the Standard Template Library (STL), file I/O, and memory management is essential for developing efficient and effective programs. C++ is widely used in system programming, game development, and performance-critical applications.

The content on this website is provided for educational and informational purposes only to support exam preparation (e.g., MLA, MRCP, USMLE) and learning. This is NOT medical advice, diagnosis, treatment, or professional guidance. It does not replace consultation with a qualified healthcare professional, official guidelines (e.g., NICE, GMC, BNF), or supervised clinical practice. Always verify information with current, authoritative sources. Makindo and its contributors accept no liability for any reliance on this content, including errors, omissions, or any resulting harm, loss, or consequences. By using this site, you agree to these terms.

C++ Programming