For Small Programs/Learning:

using namespace std; // Fine for small programs

Selective Using:

using std::cout;
using std::endl;

1. Integer Types (Whole Numbers)

int age = 25;                    // Regular integer (-2B to 2B)
short small = 100;                // Small integer (-32,768 to 32,767)
long big = 1000000;                // Large integer
long long veryBig = 1000000000;    // Very large integer

unsigned int positive = 50;        // Only positive numbers (0 to 4B)

2. Floating Point Types (Decimal Numbers)

float price = 19.99f;              // Single precision (6-7 decimal digits)
double pi = 3.14159265359;         // Double precision (15-16 decimal digits)
long double precise = 3.14159265359L; // Even more precision

3. Character Type

char grade = 'A';                   // Single character (in single quotes)
char newline = '\n';                 // Escape sequence
char ascii = 65;                     // ASCII value (prints 'A')

4. Boolean Type

bool isStudent = true;               // true or false
bool isDone = false;

5. String Type

#include <string>
string name = "John";                // Text (in double quotes)

Multiple Variables

int a, b, c;                          // Declare multiple variables
int x = 5, y = 10, z = 15;             // Declare and initialize
int p = 20, q;                         // Mix of initialized and uninitialized

Type Modifiers

signed int normal = -10;               // Can be negative (default)
unsigned int positive = 10;             // Only positive
short int smallNum = 5;                  // Short integer
long int bigNum = 1000000;                // Long integer
const int FIXED = 100;                   // Constant (can't be changed)

Basic Calculator Variables

int students = 30;
int classes = 5;
int totalStudents = students * classes;

double gpa = 3.75;
float temperature = 98.6f;

string studentName = "Alice";
bool passed = true;

Choose your data type based on:

• The kind of data you need to store
• The range of values you expect
• Memory constraints
• Precision requirements

Declaring Pointers

int* ptr;        // Pointer to an integer (preferred style)
double* dPtr;    // Pointer to a double
char* cPtr;      // Pointer to a character

The Two Key Operators

• & (Address-of operator) - Gets the memory address of a variable
• * (Dereference operator) - Accesses the value at the address stored in a pointer

1. Null Pointer

int* ptr = nullptr;      // Modern C++ (preferred)

2. Void Pointer

Can point to any data type. Must be cast before dereferencing.

void* genericPtr = #
cout << *(static_cast<int*>(genericPtr));

3. Pointer to Pointer

int** ptr2 = &ptr;       // Pointer to pointer to int

Passing Pointers

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

Summary

• Pointers store addresses, not values.
• Always initialize pointers (use nullptr).
• Use smart pointers (unique_ptr, shared_ptr) in modern C++.
• Be careful with manual memory management.

1. Arithmetic Operators

2. Relational Operators

Used to compare two values. They return true (1) or false (0).

3. Assignment Operators

int a = 10;      // Simple assignment
a += 5;          // a = a + 5 (15)
a -= 3;          // a = a - 3 (12)
a *= 2;          // a = a * 2 (24)
a /= 4;          // a = a / 4 (6)

Important: Integer Division

When you divide two integers, the result is always an integer (decimal part is truncated).

int result = 5 / 2; // result is 2, not 2.5

1. If Statement

if (condition) {
    // Code to execute if condition is true
}

2. Else Statement

if (condition) {
    // Executes if true
} else {
    // Executes if false
}

3. Else If Statement

if (score >= 90) {
    cout << "Grade: A";
} else if (score >= 80) {
    cout << "Grade: B";
} else {
    cout << "Grade: F";
}

1. For Loop

Best used when you know the number of iterations in advance.

for (int i = 0; i < 5; i++) {
    cout << "Iteration: " << i << endl;
}

2. While Loop

Repeats as long as the condition remains true. Condition is checked before the loop starts.

int count = 0;
while (count < 5) {
    cout << count << endl;
    count++;
}

3. Do-While Loop

Similar to while, but the code executes at least once because the condition is checked at the end.

int count = 0;
do {
    cout << count << endl;
    count++;
} while (count < 5);

Simple Function Example

#include <iostream>
using namespace std;

// Function definition
void greet() {
    cout << "Hello, World!" << endl;
}

int main() {
    greet();  // Function call
    return 0;
}

1. Function Declaration (Prototype)

Tells the compiler about the function before it's used.

int add(int a, int b);  // Declaration ends with semicolon

2. Function Definition

Contains the actual implementation.

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

Pass by Value (Copy)

void func(int x) { x = 100; } // Original unchanged

Pass by Reference (using &)

void func(int &x) { x = 100; } // Original modified

Pass by Pointer (using *)

void func(int *x) { *x = 100; } // Original modified

Summary

• Functions promote code reuse and modularity.
• Always declare functions before calling them.
• Choose your passing method (value, reference, pointer) based on performance and needs.
• Modern C++ offers Lambdas and Templates for powerful abstractions.

Accessing Elements

Arrays are 0-indexed. The first element is at index 0, and the last is at size - 1.

int arr[3] = {10, 20, 30};
cout << arr[0];                  // 10
arr[1] = 50;                     // Update value

2D Array Syntax

int matrix[2][3] = {
    {1, 2, 3},       // Row 0
    {4, 5, 6}        // Row 1
};

cout << matrix[1][2]; // 6 (Row 1, Column 2)

Important Notes

• Arrays do not have built-in bounds checking. Accessing arr[10] on a 5-element array is undefined behavior.
• The size of a static array must be a constant known at compile time.
• For dynamic sizes, use std::vector (modern C++) or dynamic memory (heap).

Member Access

Use the dot operator (.) to access or modify members of a struct.

Student s1;
s1.name = "Alice";
s1.age = 20;

cout << s1.name << " is " << s1.age;

Key Takeaways

• Structs help organize related data (e.g., a "User" or "Product").
• Always terminate a struct definition with a semicolon.
• Structs are passed by value by default—use references for efficiency!

Classes and Objects

A Class is a blueprint for creating objects. An Object is an instance of a class.

class Car {
public:
    string brand;
    void drive() { cout << "Driving..." << endl; }
};

int main() {
    Car myCar;      // Creating an Object
    myCar.brand = "Tesla";
    myCar.drive();
}

Constructors and Destructors

Constructors are special methods called automatically when an object is created. Destructors are called when an object is destroyed.

class User {
public:
    User() { cout << "Created"; }   // Constructor
    ~User() { cout << "Deleted"; }  // Destructor
};

Access Specifiers

Define how members (attributes/methods) can be accessed:

• public: Accessible from outside the class.
• private: Only accessible within the class.
• protected: Accessible within the class and inherited classes.

The 'this' Pointer

A pointer accessible within non-static member functions, pointing to the object for which the function is called.

class Player {
    int id;
public:
    void setID(int id) {
        this->id = id; // Differentiates member from parameter
    }
};

Static Members

Belong to the class itself rather than any specific object.

class Counter {
public:
    static int count; // Shared by all objects
};
int Counter::count = 0; // Definition

1. Encapsulation

Bundling data and methods that operate on that data into a single unit (class) and restricting access to some of the object's components (using access specifiers).

class BankAccount {
private:
    double balance;
public:
    void deposit(double amount) { balance += amount; }
    double getBalance() { return balance; }
};

2. Abstraction

Hiding complex implementation details and showing only the necessary features of an object. This is often achieved through abstract classes and interfaces.

class RemoteControl {
virtual void turnOn() = 0; // Pure virtual function
};

3. Inheritance

Creating new classes based on existing ones. This allows a "child" class to inherit attributes and methods from a "parent" class.

class Animal { public: void eat() {} };
class Dog : public Animal { public: void bark() {} };

4. Polymorphism

The ability of a single function or operator to behave differently based on the data type or object it is acting upon. Usually implemented via function overriding.

class Shape { virtual void draw() {} };
class Circle : public Shape { void draw() override {} };

Summary of OOP Pillars

Declaration vs. Definition

Typically, you place the declaration (what it looks like) in a .h file and the definition (how it works) in a .cpp file.

int add(int a, int b);

#include "Math.h"
int add(int a, int b) {
    return a + b;
}

Header Guards

Prevent a header file from being included multiple times in the same translation unit, which would cause "redefinition" errors.

#ifndef MY_HEADER_H
#define MY_HEADER_H
// Declarations here
#endif

#pragma once

// Declarations here
// Faster and simpler

Best Practices

• Always use #pragma once or header guards.
• Avoid putting variable definitions in header files (use extern instead).
• Keep includes to a minimum to reduce compilation time.
• Only include what you actually use.

Common Directives

• #include: Includes the content of a file.
• #define: Creates a macro (search and replace).
• #undef: Removes a macro definition.

#define PI 3.14159
#define MAX(a,b) ((a) > (b) ? (a) : (b))

cout << PI; // Replaced with 3.14159 before compilation

#define DEBUG_MODE

int main() {
#ifdef DEBUG_MODE
    cout << "Debug info: App started" << endl;
#endif

    cout << "Hello World" << endl;
    return 0;
}

Other Conditional Directives

Important Caution

Macros are simple text replacements. They don't respect scope and have no type checking. In modern C++, prefer:

• const or constexpr instead of #define for constants.
• inline functions or templates instead of #define for functional macros.

1. Preprocessing (-E)

The preprocessor handles directives starting with #. It expands macros, includes header files, and handles conditional compilation.

*Output: .i file (expanded source code)

2. Compilation (-S)

The compiler translates the preprocessed C++ code into Assembly language specific to the target architecture (e.g., x86_64).

*Output: .s file (assembly code)

3. Assembly (-c)

The assembler converts assembly code into Machine Code (binary), creating an Object File.

*Output: .o file (machine code/object file)

4. Linking

The linker combines one or more object files and library files into a single Executable File. It resolves references to external functions (like cout).

*Output: myProg (executable binary)

Shortcut: All-in-One

In daily development, you usually run everything in one step: