Summary  
This chapter covers constructor delegation: using one constructor to call another within the same class to centralize and reuse initialization code.

General domain of usage  
Object-oriented programming

#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
#include <string>

class Book {
public:
    Book(const std::string& bookTitle, const std::string& bookAuthor, int publicationYear)
        : title(bookTitle), author(bookAuthor), year(publicationYear) {}

    Book(const std::string& bookTitle, const std::string& bookAuthor)
        : Book(bookTitle, bookAuthor, 0) {}

    Book(const std::string& bookTitle)
        : Book(bookTitle, "Unknown", 0) {}

    std::string title;
    std::string author;
    int year;
};

// ------------------- Tests -------------------

TEST_CASE("Book with full info should store title, author, and year", "[Book]") {
    Book book("1984", "George Orwell", 1949);

    REQUIRE(book.title == "1984");
    REQUIRE(book.author == "George Orwell");
    REQUIRE(book.year == 1949);
}

TEST_CASE("Book without year should default year to 0", "[Book]") {
    Book book("Clean Code", "Robert C. Martin");

    REQUIRE(book.title == "Clean Code");
    REQUIRE(book.author == "Robert C. Martin");
    REQUIRE(book.year == 0);
}

TEST_CASE("Book with only title should default author to Unknown and year to 0", "[Book]") {
    Book book("Mystery Book");

    REQUIRE(book.title == "Mystery Book");
    REQUIRE(book.author == "Unknown");
    REQUIRE(book.year == 0);
}

test.cpp

Object-Oriented Programming (OOP) in C++ helps you build clean, reusable, and scalable code by organizing programs around objects and classes. You’ll learn how to define and use classes, create constructors and destructors, and apply encapsulation to protect data. Topics like inheritance, polymorphism, static members, access control, and operator overloading will help you design flexible and efficient code structures. 

Learn how to create classes and objects, define attributes and methods, work with static members and the this keyword. Gain a solid foundation in how objects interact and how to write clean, modular code using OOP principles.

Learn how constructors and destructors manage object creation and cleanup. Practice using initialization lists, constructor delegation, and writing clean, efficient code with proper object lifecycle handling.

Learn how encapsulation, one of OOP's core principles, improves code modularity and maintainability through data hiding, access control, and the use of accessor and mutator methods.

Learn about fundamental mechanism of object-oriented programming that enables code reuse and promotes the creation of hierarchical relationships among classes.

Polymorphism is a foundational concept in OOP that enables the creation of flexible and extensible code structures. You will learn about virtual function, abstract classes and operator overloading and their pivotal roles in promoting code flexibility and scalability.

Challenge: Constructor Delegation

Example

Solution

Challenge: Constructor Delegation

Example

Solution