Waterloo CS246 - Object-Oriented Software Development in C++ Flashcards

Question 1

What is RAII (Resource Acquisition Is Initialization) in C++?

Accepted Answer

RAII is a C++ programming idiom where resource acquisition is tied to object lifetime. Resources (like memory, file handles, mutexes) are acquired in a constructor and released in the destructor, ensuring automatic cleanup when the object goes out of scope.

Question 2

How does RAII prevent resource leaks?

Accepted Answer

By tying resource management to object lifetime, RAII guarantees that resources are released automatically when an object's destructor is called, regardless of how the scope is exited (e.g., normal return, exception). This prevents common resource leaks and simplifies error handling.

Question 3

Why are smart pointers preferred over raw pointers in modern C++?

Accepted Answer

Smart pointers provide automatic memory management, preventing memory leaks and dangling pointers by ensuring that dynamically allocated memory is deallocated when it's no longer needed. They encapsulate raw pointers and manage their lifetime using RAII principles.

Question 4

Explain `std::unique_ptr`.

Accepted Answer

`std::unique_ptr` is a smart pointer that owns and manages a dynamically allocated object. It enforces *exclusive ownership*, meaning only one `unique_ptr` can point to a resource at a time. It cannot be copied, only moved, ensuring the resource is deleted exactly once when the `unique_ptr` goes out of scope.

Question 5

When would you use `std::unique_ptr`?

Accepted Answer

Use `std::unique_ptr` when you need exclusive ownership of a dynamically allocated object, and the object's lifetime is tied to the `unique_ptr`'s scope. It's ideal for local variables, function returns, or as a member of a class where the class exclusively owns the resource.

Question 6

Explain `std::shared_ptr`.

Accepted Answer

`std::shared_ptr` is a smart pointer that manages a dynamically allocated object using *shared ownership*. Multiple `shared_ptr` instances can point to the same resource. It uses a reference count to track the number of owners; the resource is deallocated when the last `shared_ptr` owning it is destroyed.

Question 7

When would you use `std::shared_ptr`?

Accepted Answer

Use `std::shared_ptr` when multiple objects need to share ownership of a single dynamically allocated resource, and the resource should only be deallocated when all owners are gone. This is common in scenarios like caching or graph structures where multiple nodes might refer to the same object.

Question 8

What is `std::weak_ptr` and why is it used?

Accepted Answer

`std::weak_ptr` is a non-owning smart pointer that observes a `std::shared_ptr` without affecting its reference count. It's primarily used to break circular references between `std::shared_ptr` objects, which would otherwise lead to memory leaks. To access the managed object, a `weak_ptr` must first be converted to a `shared_ptr` using its `lock()` method.

Question 9

What is dynamic dispatch (polymorphism) in C++ and how is it achieved?

Accepted Answer

Dynamic dispatch is the process of selecting which implementation of a polymorphic operation (method call) to run at runtime, based on the actual type of the object pointed to by a base class pointer or reference. In C++, it's achieved using `virtual` functions in the base class.

Question 10

Why are virtual destructors important in polymorphic base classes?

Accepted Answer

A virtual destructor ensures that when an object of a derived class is deleted through a pointer to its base class, the correct destructor (i.e., the derived class's destructor followed by the base class's destructor) is called. Failing to make the base class destructor virtual leads to undefined behavior and potential resource leaks if the derived class has its own resources.

Question 11

What is a pure virtual function and an abstract class?

Accepted Answer

A pure virtual function is a virtual function declared with `= 0` in the base class (e.g., `virtual void func() = 0;`). It has no implementation in the base class, forcing derived classes to provide their own implementation. A class containing at least one pure virtual function is an *abstract class* and cannot be instantiated directly.

Question 12

Explain the "Rule of Three/Five/Zero" in C++.

Accepted Answer

The **Rule of Three** states that if you explicitly declare a destructor, copy constructor, or copy assignment operator, you should declare all three. The **Rule of Five** extends this to include move constructor and move assignment operator for C++11 and later. The **Rule of Zero** suggests that if your class manages no raw resources and relies on other RAII types (like smart pointers), you don't need to declare any of these special member functions, as compiler-generated versions will usually be correct.

Question 13

What is a copy constructor and when is it called?

Accepted Answer

A copy constructor is a special constructor that creates a new object as a copy of an existing object. Its signature is typically `ClassName(const ClassName& other);`. It's called when:
*   An object is passed by value to a function.
*   An object is returned by value from a function.
*   An object is initialized from another object of the same type (e.g., `ClassName obj2 = obj1;` or `ClassName obj2(obj1);`).

Question 14

What is a copy assignment operator and when is it called?

Accepted Answer

A copy assignment operator is a special member function that assigns the contents of an existing object to another existing object. Its signature is typically `ClassName& operator=(const ClassName& other);`. It's called when an existing object is assigned the value of another existing object (e.g., `obj2 = obj1;`).

Question 15

What is a move constructor and when is it called?

Accepted Answer

A move constructor creates a new object by "stealing" the resources from an existing *rvalue* object (an object about to be destroyed or a temporary). Its signature is typically `ClassName(ClassName&& other);`. It's called when an object is initialized from an rvalue (e.g., `ClassName obj2 = std::move(obj1);` or `ClassName obj2(std::move(obj1));`). It avoids deep copies, improving performance.

Question 16

What is a move assignment operator and when is it called?

Accepted Answer

A move assignment operator assigns the resources of an existing *rvalue* object to another existing object, effectively "moving" the resources. Its signature is typically `ClassName& operator=(ClassName&& other);`. It's called when an existing object is assigned the value of an rvalue (e.g., `obj2 = std::move(obj1);`).

Question 17

Explain the Observer design pattern.

Accepted Answer

The Observer pattern defines a one-to-many dependency between objects so that when one object (the `Subject`) changes state, all its dependents (the `Observers`) are notified and updated automatically. It promotes loose coupling between the subject and its observers, allowing them to interact without knowing each other's concrete classes.

Question 18

Explain the Factory design pattern.

Accepted Answer

The Factory pattern provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. It encapsulates the object creation logic, making the system more flexible and extensible by decoupling the client code from the concrete classes it instantiates.

Question 19

Explain the Decorator design pattern.

Accepted Answer

The Decorator pattern allows behavior to be added to an individual object, dynamically, without affecting the behavior of other objects from the same class. It provides a flexible alternative to subclassing for extending functionality, by wrapping the original object with one or more "decorator" objects that add new responsibilities.

Question 20

Explain the Model-View-Controller (MVC) design pattern.

Accepted Answer

MVC is an architectural pattern that separates an application into three interconnected components:
*   **Model:** Manages the application's data, logic, and rules.
*   **View:** Presents the data from the Model to the user.
*   **Controller:** Handles user input, interacts with the Model to update data, and selects a View to display.
It aims to separate concerns, improving modularity, testability, and maintainability.

Waterloo CS246 - Object-Oriented Software Development in C++

Card Preview

Related Flashcard Sets

German B1 - Intermediate Grammar, Sentence Structure & Vocabulary

Neuroscience - Central Nervous System Pathways & Action Potentials

French A1/A2 - High-Frequency Vocabulary & Core Grammar

Kubernetes Orchestration & Cloud-Native Deployment