C++ Programming Flashcards

Question 1

What is the difference between declaring and defining a variable in C++?

Accepted Answer

A declaration introduces a name and its type to the compiler, while a definition also allocates storage or provides the entity's implementation. For example, extern int count; is a declaration, whereas int count = 0; is a definition that creates the object.

Question 2

Why does C++ distinguish between signed and unsigned integer types?

Accepted Answer

Signed integer types can represent both positive and negative values, while unsigned types represent only zero and positive values across a larger range. Unsigned arithmetic wraps around modulo a power of two when results go out of range. Mixing signed and unsigned operands in comparisons can produce surprising results, so compilers may warn about it.

Question 3

What does auto do in a variable declaration, and what is its limitation?

Accepted Answer

The auto keyword tells the compiler to deduce the variable's type from its initializer, so the declared type is not written explicitly. The limitation is that an initializer is required, because the compiler has no other source for the type. Auto also drops references and top-level const from the deduced type.

Question 4

What is the purpose of const in a C++ declaration?

Accepted Answer

The const qualifier marks an object as read-only after initialization, so the compiler rejects attempts to modify it through that name. It documents intent, lets the compiler catch accidental changes, and allows some optimizations. A const object must be initialized when it is declared, since it can never be assigned to later.

Question 5

How do references differ from pointers in C++?

Accepted Answer

A reference is an alias for an existing object, so it must be bound to an object when created and cannot be reseated to refer to another. A pointer holds an address, may be null, and can be reassigned to point elsewhere. References also avoid explicit dereferencing at the point of use.

Question 6

What is the difference between a C-style array and std::array?

Accepted Answer

A C-style array is a built-in fixed-size sequence that decays to a pointer in most expressions, losing its size information. The std::array class template wraps a fixed-size array as an object, so it knows its size, supports copying and assignment, and offers begin and end for range-based loops.

Question 7

What is the difference between an lvalue and an rvalue?

Accepted Answer

An lvalue names an object with a persistent location, such as a named variable. An rvalue is a temporary value without a persistent name, such as the result of 1 plus 2. Built-in assignment requires an lvalue on its left side.

Question 8

What does uniform initialization with braces protect against?

Accepted Answer

Brace initialization prevents narrowing conversions, so the compiler rejects an initialization that would silently lose data, such as assigning a double value to an int. This check happens at compile time for many cases. Brace initialization also works for containers and aggregates, giving one consistent syntax.

Question 9

What must a switch statement require of its case labels?

Accepted Answer

Each case label must be a constant expression whose value is known at compile time, and it must be convertible to the type of the switch condition. Duplicate case values are not allowed. Control falls through to the next case unless a break or other jump ends the branch, so fall-through often causes bugs.

Question 10

What is the difference between a range-based for loop and an index-based loop?

Accepted Answer

A range-based for loop iterates over every element of a container or array in order without requiring an explicit index or iterator. An index-based loop gives you control over the position, allows skipping or reversing elements, and works when you need the index itself. Range-based loops are clearer when you only need each element.

Question 11

What is function overloading and how does the compiler choose among overloads?

Accepted Answer

Function overloading lets several functions share one name as long as their parameter lists differ in number or type. The compiler selects the best match by comparing argument types against each candidate, applying exact matches first, then promotions and conversions. Return type alone cannot distinguish overloads.

Question 12

What does pass by value mean when a function receives an argument?

Accepted Answer

Pass by value means the function receives a copy of the argument, so changes to the parameter do not affect the caller's object. For class types, the copy may be expensive, which is one reason to pass large objects by reference instead. The copy is made using the parameter type's copy or move constructor.

Question 13

Why do programmers often pass large class objects as const references?

Accepted Answer

Passing a const reference avoids copying the object while promising the function will not modify it. The parameter refers to the caller's object, so no copy is constructed or destroyed. The compiler enforces the read-only promise, catching accidental writes at compile time. Temporaries can bind to const references, so callers may pass computed values.

Question 14

What is a default argument and where must default arguments appear in a parameter list?

Accepted Answer

A default argument is a value the compiler uses when the caller omits that argument in a function call. Default arguments must appear at the end of the parameter list, so every parameter after the first defaulted one must also have a default. The default is specified once, in the declaration.

Question 15

What is the difference between a while loop and a do-while loop?

Accepted Answer

A while loop checks its condition before each iteration, so the body may run zero times. A do-while loop executes its body first and then checks the condition, so the body always runs at least once. Both forms require the loop variable or condition to change, or the loop may never end.

Question 16

What must a recursive function include to avoid infinite recursion?

Accepted Answer

A recursive function must include a base case that returns without making another recursive call. Each recursive call should move the inputs closer to that base case, so the recursion eventually stops. Without a reachable base case, the calls keep nesting until the program runs out of stack space, which ends with a crash.

Question 17

How do a class and a struct differ in C++?

Accepted Answer

In C++, a class and a struct are nearly identical, with both able to hold data, functions, and constructors. The main difference is default access: class members are private by default, while struct members are public by default. Default inheritance access follows the same pattern, private for class and public for struct.

Question 18

What is the role of a constructor, and what happens if you do not declare one?

Accepted Answer

A constructor initializes an object's members so that the object starts in a valid state as soon as it is created. If you declare no constructor, the compiler provides a default constructor, but only when the class has no other constructors. That generated constructor default-initializes members, which may leave built-in types with indeterminate values.

Question 19

What is a destructor for and when is it called?

Accepted Answer

A destructor releases resources an object holds, such as memory, file handles, or locks, when the object's lifetime ends. It is called automatically when a local object goes out of scope, when a heap object is deleted, or when a containing object is destroyed. Local objects are destroyed in reverse order of construction.

Question 20

What does the rule of zero recommend about resource management in classes?

Accepted Answer

The rule of zero recommends that classes not declare copy, move, or destructor functions when they can avoid managing resources directly. Instead, they hold resources through standard library types such as std::string, std::vector, or std::unique_ptr, which handle their own cleanup. The compiler then generates correct special members automatically.

Question 21

What is a virtual function and why is it used with inheritance?

Accepted Answer

A virtual function is a member function that a derived class can override, with the specific version chosen at runtime based on the object's actual type. This dynamic dispatch lets code written against a base class reference call the correct derived behavior. This works through base class pointers or references.

Question 22

Why do classes usually keep data members private?

Accepted Answer

Private members hide the internal representation, so the class can enforce its invariants and change internal details without breaking code that uses the class. Public member functions act as a controlled interface through which callers read or modify the state. This separation makes classes easier to maintain, test, and reason about.

Question 23

What does the explicit keyword do when applied to a single-argument constructor?

Accepted Answer

The explicit keyword prevents the compiler from using that constructor for implicit conversions from the argument type to the class type. Without it, a single-argument constructor can silently create objects in assignments and function calls. Marking such constructors explicit makes conversions visible and avoids surprising behavior.

Question 24

Why use a member initializer list instead of assigning members inside a constructor body?

Accepted Answer

A member initializer list initializes members directly when they are constructed, rather than default-constructing them first and then assigning. This matters for const members, reference members, and members whose types have no default constructor, since those can only be initialized directly. The list also avoids an extra assignment for class-type members.

Question 25

What is the difference between the stack and the heap in terms of object lifetime?

Accepted Answer

Automatic objects on the stack are destroyed when they go out of scope, following a last-in, first-out pattern. Objects allocated dynamically with new live on the heap until they are explicitly deleted or released by a smart pointer. The programmer or a managing type is responsible for ending heap object lifetimes.

Question 26

What is a dangling pointer and how does it arise?

Accepted Answer

A dangling pointer holds the address of an object that no longer exists, usually because the object was deleted or went out of scope. Using such a pointer produces undefined behavior, which can crash the program or silently corrupt data. Returning a pointer or reference to a local variable is a common cause.

Question 27

What is a memory leak in C++ and how can it be avoided?

Accepted Answer

A memory leak occurs when heap memory is allocated but never released, so it stays unavailable for the rest of the program's run. It can be avoided by pairing every allocation with a deallocation, which is most reliably done by letting RAII types such as std::unique_ptr or std::vector own the memory.

Question 28

What is RAII and why is it central to safe C++ code?

Accepted Answer

RAII, short for resource acquisition is initialization, ties a resource's lifetime to an object's lifetime: the constructor acquires the resource and the destructor releases it. Because destructors run during stack unwinding, resources are released even when an exception is thrown. This pattern prevents many leaks and makes ownership explicit.

Question 29

What does std::unique_ptr represent, and how does it differ from std::shared_ptr?

Accepted Answer

A std::unique_ptr represents exclusive ownership of a heap object, and it deletes the object when it goes out of scope. It cannot be copied, though it can be moved to transfer ownership. A std::shared_ptr allows several owners through reference counting, and the object is destroyed when the last owner releases it.

Question 30

Why is std::make_unique generally preferred over a raw new expression?

Accepted Answer

std::make_unique creates a heap object and wraps it in a std::unique_ptr in one step, so ownership is established. This avoids the risk of forgetting to delete the object, and it prevents leaks if an exception interrupts code between a raw allocation and the creation of its owner. It also avoids repeating the type name.

Question 31

What is move semantics and why does it matter for resources?

Accepted Answer

Move semantics let an object take ownership of resources from a temporary or from an object whose value is no longer needed, instead of copying them. The source is left in a valid but unspecified state, which is safe to destroy or assign to. This makes returning and passing heavy objects efficient.

Question 32

What does it mean to dereference a null pointer?

Accepted Answer

Dereferencing a null pointer means accessing the object it would point to, which does not exist, and the result is undefined behavior. In practice this often crashes the program. Checking a pointer against nullptr before dereferencing it is a common defense.

Question 33

What is a function template and how does the compiler use it?

Accepted Answer

A function template is a pattern that lets one definition work with many types, using parameters such as typename T. The compiler generates a specific function for each set of template arguments it encounters, a process called instantiation. Errors in template code often appear only when instantiation occurs.

Question 34

How does template argument deduction determine the type parameter?

Accepted Answer

Template argument deduction infers the type parameter from the types of the function arguments at the call site. For example, calling maximum(3, 7) deduces int for a parameter declared as T. When deduction conflicts, as with maximum(3, 2.5), the call fails unless you specify the type explicitly.

Question 35

What is a std::vector and how does it manage its storage?

Accepted Answer

A std::vector is a dynamically sized sequence container that stores its elements contiguously in memory. When it runs out of capacity, it allocates a larger block, moves or copies the elements over, and releases the old block. Reserving capacity in advance avoids repeated reallocations.

Question 36

What is an iterator and why do standard algorithms use iterators?

Accepted Answer

An iterator is an object that refers to an element in a container and can advance through the sequence, similar to a generalized pointer. Standard algorithms use iterators so one algorithm, such as std::find, works with many container types without knowing how each one stores its elements. Iterator pairs usually mark a half-open range.

Question 37

What is a lambda expression and what does its capture list control?

Accepted Answer

A lambda expression creates an unnamed function object inline, which is useful for short callbacks passed to algorithms. Its capture list specifies which variables from the surrounding scope the lambda can use, and whether each is captured by value or by reference. Captures determine what state the lambda carries with it.

Question 38

What is std::string_view and when should it be used?

Accepted Answer

A std::string_view is a lightweight, non-owning reference to a sequence of characters, so it does not allocate or copy the text. It is useful for reading strings passed as parameters when the function does not need to store them. The viewed characters must outlive the view, or the view becomes dangling.

Question 39

What does std::optional represent, and how is it checked?

Accepted Answer

A std::optional holds either a value of a given type or no value at all, which makes the absence of a result explicit in the type. You can test it with has_value or in a boolean context. Calling value on an empty optional throws an exception, so checking first is the safer habit.

Question 40

Why do many programmers prefer standard algorithms over hand-written loops?

Accepted Answer

Standard algorithms express a common task by name, such as sorting or counting matches, which makes intent clearer than a manual loop. They are widely used and work with any iterator range, so the same call adapts to many containers. Using them also reduces the chance of off-by-one errors in loop bounds.

C++ Programming Flashcards

1Declarations and basic types

2Control flow and functions

3Classes and object-oriented design

4Memory and resource management

5Templates and the standard library

Learning Resources