C++ Language for Interviews

Build a solid C++ foundation by mastering how data is declared, stored, converted, and scoped in memory.

• Variable initialization — int x = 10; vs int x(10); vs int x{10}; syntax variations

• Integer division — both operands must be float/double for decimal results, int/int truncates

• bool data type — holds true or false, useful in conditional and loop expressions

• ASCII conversion — implicit char to int conversion and its use in character arithmetic

• sizeof operator — returns size in bytes of a data type or variable at compile time

• Type casting — explicit conversion using (int)value or type-safe static_cast<int>(value)

• Global vs local variables — scope, lifetime, and default initialization differences

• Data type modifiers — short, long, signed, unsigned for controlling value ranges

Master the full range of C++ operators — from arithmetic and bitwise to increment, ternary, and precedence rules.

• Modulus operator — returns remainder of integer division (10 % 3 = 1), integers only

• Pre-increment (++x) — increments first, returns new value, slightly more efficient for objects

• Post-increment (x++) — returns current value first, then increments, creates a temporary copy

• Bitwise operators — &, |, ^, ~, <<, >> for low-level bit manipulation

• Logical operators — && (AND), || (OR), ! (NOT) with short-circuit evaluation

• Ternary operator — condition ? value_if_true : value_if_false for compact conditionals

• Operator precedence — *, / evaluated before +, -, parentheses override default order

• Division vs modulus — / truncates integer result, % gives remainder, both integers only for %

The most tested C++ topic in interviews — master pointer declaration, dereferencing, arithmetic, and the key differences from references.

• Pointer declaration — int* ptr or int *ptr stores the memory address of another variable

• Dereferencing — *ptr accesses the value stored at the address the pointer holds

• nullptr vs NULL — nullptr (C++11) is type-safe and prevents function overloading ambiguity

• Pointer arithmetic — ptr + 1 advances by one element size based on the pointer's type

• Double pointer — int** ptr declaration and **ptr double-dereference to access the value

• Pointer vs reference — pointers can be null and reassigned, references cannot

• Pointer size — typically 8 bytes on 64-bit and 4 bytes on 32-bit systems

• Pointers and arrays — array name decays to a pointer to the first element

Write precise decision-making logic using the full range of conditional constructs available in C++.

• if statement — executes a block only when the condition evaluates to true

• if-else structure — handles binary decisions with a fallback block for the false case

• else-if ladder — checks multiple conditions sequentially, stops at the first true branch

• switch statement — multi-way branch on integer or character values

• break in switch — prevents fall-through to subsequent cases

• Nested if — if statements inside if blocks for layered conditional logic

• Ternary operator as if-else — compact syntax for simple single-expression conditions

Control iteration precisely with C++'s loop constructs and understand their execution order and edge cases.

• for loop — for(init; condition; increment), best when iteration count is known upfront

• while loop — condition checked before each iteration, may not execute if initially false

• do-while loop — body executes at least once, condition checked after each iteration

• break statement — exits the loop immediately regardless of the remaining condition

• continue statement — skips the rest of the current iteration and jumps to the next

• Nested loops — total iterations equal outer count multiplied by inner count

• Infinite loop — while(1) or for(;;) where the condition never becomes false

Read from and write to files using C++ file stream classes — essential for systems programming and data persistence scenarios.

• #include <fstream> — required header for all file stream operations in C++

• ofstream — output file stream class used for writing data to files

• ifstream — input file stream class used for reading data from files

• File modes — ios::in (read), ios::out (write), ios::app (append), ios::binary for non-text

• Multiple modes — combining flags with | operator, e.g., ios::in | ios::out

• getline() — reads an entire line including spaces from a file or standard input

• file.close() — releases resources, flushes the buffer, and finalizes the file operation

Design reusable, efficient C++ functions using overloading, default arguments, pass-by-reference, and recursion.

• Function overloading — same function name with different parameter types or counts

• Pass by value — creates a copy, original variable remains unchanged after the call

• Pass by reference — passes original using &, modifications affect the caller's variable

• Pass by const reference — avoids copying large objects without allowing modification

• Pass by pointer — allows nullptr, used for arrays and optional parameters

• Default arguments — parameters with preset values used when caller omits them

• Inline functions — compiler suggestion to substitute function body at the call site

• Recursion — function calling itself, used for factorial, Fibonacci, and tree problems

Store and process collections of data with C++ arrays and understand their close relationship with pointers.

• Array declaration — type name[size]; fixed-size, zero-indexed sequential collection

• Array initialization — int arr[] = {1,2,3}; or partial int arr[5] = {1,2};

• Out-of-bounds access — undefined behavior, no runtime checking, may corrupt memory

• sizeof on arrays — returns total bytes (number of elements × size of element type)

• Multidimensional arrays — int arr[rows][cols]; accessed with arr[row][col]

• Arrays and functions — array name decays to a pointer when passed to a function

• Vector with at() — std::vector provides bounds-checked access, throws out_of_range exception

Apply the four pillars of OOP in C++ — encapsulation, inheritance, polymorphism, and abstraction — and master virtual functions.

• Class declaration — class ClassName {}; defines the blueprint for object creation

• Access specifiers — private (default), protected, and public control member visibility

• Constructor — initializes object state, same name as class, called on object creation

• Destructor — ~ClassName() cleanup method, essential for freeing dynamic memory

• Inheritance — class Derived : public Base {}; enables code reuse across class hierarchies

• Virtual functions — enable runtime polymorphism, resolved by actual object type not pointer type

• Pure virtual functions — virtual void func() = 0; makes a class abstract, cannot be instantiated

• Virtual destructor — always declare base class destructor virtual to prevent memory leaks

• this pointer — implicit pointer to the current object, used within member functions

• V-Table — internal dispatch table used by the compiler to resolve virtual function calls

Manipulate text efficiently using C++'s STL string class and understand its methods for searching, modifying, and comparing strings.

• String declaration — string str; requires #include <string> header

• str.length() / str.size() — both return the number of characters in the string

• String concatenation — + operator or str.append() method to join strings

• str.substr(pos, len) — extracts a substring starting at pos with given length

• String comparison — ==, !=, <, > operators work directly on string objects

• str.find() — returns position of first match, or string::npos if not found

• str.replace(), str.erase(), str.insert() — in-place string modification methods

• c_str() — converts STL string to a null-terminated C-style char array