Overview of C++ Programming
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
/*
This is a multi-line comment
spanning multiple lines
*/
Preprocessor Directives:
- Preprocessor directives begin with a hash (#).
#include
#define PI 3.14159
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
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
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
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
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
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
Preprocessor Directives
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.