Bjarne Stroustrup created C++ at Bell Labs starting in 1979, originally calling it “C with Classes” before renaming it C++ in 1983. Dennis Ritchie created C, James Gosling created Java, and Guido van Rossum created Python.

cout (character output) is the standard output stream declared in <iostream>. printf() is a C library function, cin is the input stream, and System.out.println is Java syntax.

The <iostream> header declares the standard stream objects cin, cout, cerr and clog. <stdio.h> and <stdlib.h> are C headers, and <string> provides std::string.

.cpp is the conventional C++ source extension (.cc, .cxx and .c++ also work). A .c file is treated as C by the compiler, and .class is a compiled Java file.

The extraction operator >> pulls data out of a stream, e.g. cin >> x;. The insertion operator << pushes data into a stream (cout).

The :: operator resolves scope, e.g. std::cout or MyClass::method(). The dot accesses members of an object and -> accesses members through a pointer.

The class keyword defines a class. struct also defines a class-like type but with public default access. “object” and “interface” are not C++ keywords.

Members of a class are private by default. This is one of the few differences between class and struct, whose members default to public. “package-private” is Java, not C++.

In C++, a struct defaults to public access (both for members and for inheritance). This is the key practical difference from class.

The new operator allocates memory from the free store and calls the object’s constructor. malloc() is the C library function that only allocates raw bytes and does not run constructors.

delete releases memory obtained with new and invokes the destructor. free() is the C counterpart to malloc(). Every new must be matched by a delete, and every new[] by delete[].

The ampersand & declares a reference, e.g. void f(int &x). A reference is an alias for the original object, so no copy is made. The * symbol declares a pointer instead.

A constructor runs automatically when an object is created and initialises it. A destructor runs automatically when the object goes out of scope or is deleted.

A destructor is written as ~ClassName(). For example, the destructor of class Car is ~Car(). It takes no parameters and has no return type.

Yes — a class can have many constructors as long as their parameter lists differ (default, parameterised, copy, move, etc.). This is called constructor overloading.

No. A destructor takes no arguments and has no return type, so there is no way to give it a different signature. A class can have exactly one destructor.

Function overloading means several functions share a name but differ in the number or types of parameters; the compiler picks the right one at compile time (static polymorphism).

Marking a function virtual tells the compiler to resolve the call at runtime through the vtable, based on the actual object type rather than the pointer/reference type.

A class with at least one pure virtual function is abstract and cannot be instantiated. Derived classes must override every pure virtual function to become concrete.

The = 0 suffix makes a virtual function pure: virtual void display() = 0;. Option (b) is just an ordinary virtual function with a body expected elsewhere.

sizeof, the ternary conditional ?: and the member access dot . are all non-overloadable. The full list also includes ::, .* and the preprocessor # and ##.

A friend declaration inside a class gives a non-member function (or another class) full access to its private and protected members.

The this pointer holds the address of the object on which the member function was called. It is passed implicitly to every non-static member function.

Multiple inheritance lets one class derive from two or more base classes, e.g. class C : public A, public B. Multilevel inheritance is a chain (A → B → C).

This is the Diamond Problem: the bottom class ends up with two copies of the shared base sub-object, creating ambiguity when accessing base members.

Virtual inheritance (class B : virtual public A) makes the shared base exist only once in the final object, eliminating the duplicate sub-object.

sizeof(bool) is 1 on essentially every mainstream implementation. Strictly speaking the standard only requires at least 1, but in practice it is always exactly 1 byte.

A template is introduced with the template keyword, and the type parameter is declared with typename (or class): template <typename T> T max(T a, T b);. “generic” is not a C++ keyword.

The try block wraps code that might throw. Any exception raised inside it is passed to a matching catch block. C++ has no “finally” keyword.

throw raises an exception, e.g. throw std::runtime_error("fail");. “raise” is Python and “catch” handles the exception rather than creating it.

The catch block receives the thrown object and handles it. “except” is Python, “rescue” is Ruby, and “finally” is Java/C#.

STL stands for Standard Template Library — the collection of generic containers, iterators, algorithms and function objects that later became part of the C++ standard library.

std::list is a doubly linked list, so insertion and removal anywhere are O(1) once the position is known, but there is no random access by index.

std::set keeps unique elements automatically sorted (typically as a red-black tree). std::unordered_set also enforces uniqueness but uses a hash table with no ordering.

You must include <vector>. <array> provides the fixed-size std::array and <list> provides std::list.

size() returns the number of elements currently stored. capacity() returns how many elements can be held before reallocation — it is often larger than size().

push_back() appends an element to the end (amortised O(1)). insert() adds at an arbitrary position but is generally O(n). C++ has no append() or add() on vector.

When both operands are integers, / performs integer division and truncates toward zero, so 7 / 2 = 3. Use 7.0 / 2 to get 3.5.

The modulus operator % returns the remainder: 7 divided by 2 is 3 with remainder 1. The % operator works only on integral types.

Both const and constexpr produce values that cannot be modified. constexpr goes further, requiring the value to be computable at compile time. “static” controls storage duration and linkage, not mutability.

In C++11 the meaning of auto changed from “automatic storage” to type deduction from the initialiser, e.g. auto x = 5;. decltype is related but deduces the type of an expression without evaluating it.

nullptr was added in C++11 as a proper null pointer literal of type std::nullptr_t. It avoids the ambiguities that NULL (usually just 0) creates in overload resolution.

Resource Acquisition Is Initialization ties a resource’s lifetime to an object’s lifetime: the constructor acquires, the destructor releases. It is the foundation of smart pointers and exception safety.

std::unique_ptr owns its object exclusively and cannot be copied (only moved). shared_ptr allows multiple owners, weak_ptr observes without owning, and auto_ptr was removed in C++17.

std::shared_ptr maintains a reference count and destroys the object only when the last owner is gone. std::weak_ptr observes a shared_ptr without incrementing that count.

Smart pointers live in <memory>, along with std::make_unique and std::make_shared. <utility> provides std::move and std::pair instead.

inline is a hint that the compiler should expand the function body at the call site instead of performing a call. Modern compilers usually decide on their own; the main guaranteed effect of inline is relaxed ODR rules for definitions in headers.

dynamic_cast performs a checked conversion between polymorphic types at runtime, returning nullptr (for pointers) if the conversion is invalid. It requires the base class to have at least one virtual function.

const_cast adds or removes const (and volatile). Modifying an object that was originally declared const through such a cast is undefined behaviour.

reinterpret_cast reinterprets the bit pattern of a value as another type, e.g. converting a pointer to an integer. It is the most dangerous cast and is highly platform-dependent.

A function-local static variable has static storage duration but local scope. It is initialised once and keeps its value between calls, yet is invisible outside the function.

A lambda expression defines an unnamed function object inline: [](int x){ return x * 2; }. The compiler generates a unique closure type for it.

A string literal has type const char[N] and decays to const char*. It is stored in read-only memory, so writing to it is undefined behaviour. It is not a std::string unless you construct one.