Complete C++ Reference Course

// This is a single-line comment — everything after // is ignored

/* This is a multi-line comment.
 It can span many lines.
 Useful for longer explanations. */

int x = 5; // inline comment — after the code on the same line

int i = 1;
int& ri = i; // ri is a reference (alias) to i
 // ri and i now share the SAME memory location

ri = 2; // Changes ri → also changes i (same memory!)
std::cout << "i=" << i; // Prints: i=2

i = 3; // Changes i → also changes ri
std::cout << "ri=" << ri; // Prints: ri=3

#include <array>

// Step 1: Declare empty array of 3 integers, then assign
std::array<int, 3> marks;
marks[0] = 92;
marks[1] = 97;
marks[2] = 98;

// Step 2: Declare AND initialize at once (cleaner)
std::array<int, 3> scores = {92, 97, 98};

// Step 3: Partial init — missing elements default to 0
std::array<int, 3> partial = {92, 97};
std::cout << partial[2]; // Outputs: 0 (default initialized)

// Memory layout: [92][97][98][99][98][94]
// index: 0 1 2 3 4 5

std::array<int, 6> marks = {92, 97, 98, 99, 98, 94};

std::cout << marks[0]; // Read first element → 92
marks[1] = 99; // Write: change 2nd element to 99
std::cin >> marks[2]; // Read from user into 3rd element

char ref[5] = {'R', 'e', 'f'};

// Method 1: Range-based for loop (C++11, recommended)
for (const int &n : ref) {
 std::cout << std::string(1, n); // Convert char to string and print
}

// Method 2: Traditional index-based for loop
for (int i = 0; i < sizeof(ref); ++i) {
 std::cout << ref[i]; // Access by index
}

// Grid layout:
// j→ 0 1 2 3 4 5
// i=0: 1 2 3 4 5 6
// i=1: 6 5 4 3 2 1

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

for (int i = 0; i < 2; ++i) { // Loop over rows
 for (int j = 0; j < 6; ++j) { // Loop over columns
 std::cout << x[i][j] << " ";
 }
}
// Outputs: 1 2 3 4 5 6 6 5 4 3 2 1

// Basic if-else
int number = 16;
if (number % 2 == 0) {
 std::cout << "even"; // Runs when condition is true
} else {
 std::cout << "odd"; // Runs when all conditions above are false
}
// Outputs: even

// Chained else-if ladder
int score = 99;
if (score == 100) std::cout << "Superb";
else if (score >= 90) std::cout << "Excellent"; // ← This runs (99≥90)
else if (score >= 80) std::cout << "Very Good";
else if (score >= 70) std::cout << "Good";
else if (score >= 60) std::cout << "OK";
else std::cout << "What?";

// Ternary syntax: condition ? expr_if_true : expr_if_false
int x = 3, y = 5, max;

max = (x > y) ? x : y; // If x>y use x, else use y
std::cout << max; // Outputs: 5

// Equivalent if-else version (same result):
if (x > y) { max = x; }
else { max = y; }
std::cout << max; // Outputs: 5

int num = 2;
switch (num) {
 case 0:
 std::cout << "Zero";
 break; // MUST break to stop falling through!
 case 1:
 std::cout << "One";
 break;
 case 2:
 std::cout << "Two"; // ← This runs (num == 2)
 break;
 case 3:
 std::cout << "Three";
 break;
 default:
 std::cout << "What?"; // Runs if no case matched
 break;
}

int i = 0;
while (i < 6) {
 std::cout << i++; // Print i, THEN increment (post-increment)
}
// Outputs: 012345

int i = 1;
do {
 std::cout << i++; // Runs FIRST, condition checked after
} while (i <= 5); // Note the semicolon here!
// Outputs: 12345

// Standard for loop
for (int i = 0; i < 10; i++) {
 std::cout << i << "\n";
}

// Multiple variables — i counts up, j counts down simultaneously
for (int i = 0, j = 2; i < 3; i++, j--) {
 std::cout << "i=" << i << ",j=" << j << ";";
}
// Outputs: i=0,j=2;i=1,j=1;i=2,j=0;

// Method 1: while(true) — most readable
while (true) {
 std::cout << "infinite loop";
}

// Method 2: for(;;) — classic C style
for (;;) {
 std::cout << "infinite loop";
}

// Method 3: Condition that's always true (i++ always > 0)
for (int i = 1; i > 0; i++) {
 std::cout << "infinite loop";
}

#include <iostream>

void hello(); // DECLARATION (prototype) — tells compiler: hello exists
 // void = returns nothing, () = takes no arguments

int main() {
 hello(); // CALL — execute the function
 return 0;
}

void hello() { // DEFINITION — the actual code
 std::cout << "Hello QuickRef!\n";
}

// Three versions of fun() — same name, different signatures
void fun(std::string a, std::string b) {
 std::cout << a + " " + b; // Called when 2 strings passed
}
void fun(std::string a) {
 std::cout << a; // Called when 1 string passed
}
void fun(int a) {
 std::cout << a; // Called when int passed
}

// Compiler picks correct version automatically:
fun("Hello", "World"); // → version 1 (2 strings)
fun("Hi"); // → version 2 (1 string)
fun(42); // → version 3 (int)

#include <iostream>
#include <cmath> // Import the math library

int main() {
 std::cout << std::sqrt(9); // √9 = 3
 std::cout << std::pow(2, 10); // 2¹⁰ = 1024
 std::cout << std::abs(-7); // |-7| = 7
 std::cout << std::floor(3.9); // ⌊3.9⌋ = 3
 std::cout << std::ceil(3.1); // ⌈3.1⌉ = 4
}

class MyClass {
 public: // Access specifier: public = accessible from outside
 int myNum; // Attribute: integer variable
 std::string myString; // Attribute: string variable
}; // ← Don't forget the semicolon after the closing brace!

// Create an object (instance) of MyClass
MyClass myObj;

// Set attribute values using dot notation
myObj.myNum = 15;
myObj.myString = "Hello";

// Read attribute values
std::cout << myObj.myNum << std::endl; // 15
std::cout << myObj.myString << std::endl; // Hello

class MyClass {
 public:
 int myNum;
 std::string myString;

 MyClass() { // Constructor — same name as class, no return type
 myNum = 0; // Initialize to defaults
 myString = "";
 }
};

MyClass myObj; // Constructor runs automatically here
std::cout << myObj.myNum; // 0 (set by constructor)
std::cout << myObj.myString; // "" (set by constructor)

class MyClass {
 public:
 int myNum; std::string myString;

 MyClass() { myNum = 0; myString = ""; } // Constructor

 ~MyClass() { // Destructor (note ~)
 std::cout << "Object destroyed." << std::endl;
 }
};

MyClass myObj; // Constructor called here
// ... use myObj ...
// Destructor called automatically when myObj goes out of scope

class MyClass {
 public:
 int myNum;
 std::string myString;

 void myMethod() { // Method defined inside the class
 std::cout << "Hello World!" << std::endl;
 }
};

MyClass myObj;
myObj.myMethod(); // Call the method → prints: Hello World!

class MyClass {
 public:
 int x; // Accessible from anywhere
 private:
 int y; // Only accessible within this class
 protected:
 int z; // Accessible within this class and subclasses
};

MyClass myObj;
myObj.x = 25; // OK — public
myObj.y = 50; // ERROR — private, not accessible outside
myObj.z = 75; // ERROR — protected, not accessible outside

class MyClass {
 private:
 int myNum; // Private: can't access directly

 public:
 void setMyNum(int num) { // Setter: validates then stores
 myNum = num;
 }
 int getMyNum() { // Getter: returns private value
 return myNum;
 }
};

MyClass myObj;
myObj.setMyNum(15); // Set via setter (indirect write)
std::cout << myObj.getMyNum(); // Get via getter → 15

class Vehicle { // BASE class (parent)
 public:
 std::string brand = "Ford";
 void honk() {
 std::cout << "Tuut, tuut!" << std::endl;
 }
};

class Car : public Vehicle { // DERIVED class (child) — inherits Vehicle
 public:
 std::string model = "Mustang"; // Car's own attribute
};

Car myCar;
myCar.honk(); // Inherited from Vehicle → "Tuut, tuut!"
std::cout << myCar.brand + " " + myCar.model; // Ford Mustang

#include <iostream> // Standard library header (system path)
#include "myfile.h" // Your own header (current directory first)

#defineFOO // Define FOO as a flag (no value)
#defineFOO "hello" // Define FOO as the text "hello"
#undefFOO // Remove the FOO macro

// #ifdef: "if DEBUG macro is defined"
#ifdefDEBUG
 console.log('hi'); // Only compiled in debug build
#elif definedVERBOSE
 // ... compiled if VERBOSE defined but not DEBUG
#else
 // ... compiled if neither DEBUG nor VERBOSE
#endif // Always end with #endif

#ifVERSION == 2.0
 #errorUnsupported // STOPS compilation with this error message
 #warningNot really supported // Shows warning but continues
#endif

// Parameterized macro: like a function but text-substituted
#define DEG(x) ((x) * 57.29) // Converts radians to degrees

// Token concatenation with ##
#define DST(name) name##_s name##_t
DST(object); // Expands to: object_s object_t;

// Stringification with # — wraps in double quotes
#define STR(name) #name
char * a = STR(object); // Expands to: char * a = "object";

// __FILE__ and __LINE__ — built-in macros
#define LOG(msg) console.log(__FILE__, __LINE__, msg)
// Expands to: console.log("file.txt", 3, "hey")