Summary  
This chapter covers using initialization lists in constructors to directly initialize member variables, ensuring efficient and correct setup, especially for const and reference members.

General domain of usage  
Object-oriented programming

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

class Transaction {
public:
    Transaction(float amount, float rate)
        : amount(amount), rate(rate), total(amount * rate) {}

    float processTransaction(float feePercent, float targetRate);

    float amount;
    float rate;
    float total;
};

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

TEST_CASE("Convert 100 at rate 1.2 with 5% fee and targetRate 0.8 -> 91.2", "[Transaction]") {
    Transaction t(100.0f, 1.2f);
    float result = t.processTransaction(5.0f, 0.8f);
    REQUIRE(result == Approx(91.2f));
}

TEST_CASE("Convert 50 at rate 0.9 with 10% fee and targetRate 1.1 -> 44.55", "[Transaction]") {
    Transaction t(50.0f, 0.9f);
    float result = t.processTransaction(10.0f, 1.1f);
    REQUIRE(result == Approx(44.55f));
}

TEST_CASE("Convert 200 at rate 1.5 with 0% fee and targetRate 0.5 -> 150.0", "[Transaction]") {
    Transaction t(200.0f, 1.5f);
    float result = t.processTransaction(0.0f, 0.5f);
    REQUIRE(result == Approx(150.0f));
}

TEST_CASE("Convert 100 at rate 2.0 with 100% fee and targetRate 1.5 -> 0.0", "[Transaction]") {
    Transaction t(100.0f, 2.0f);
    float result = t.processTransaction(100.0f, 1.5f);
    REQUIRE(result == Approx(0.0f));
}

TEST_CASE("Convert 0 at rate 2.0 with 10% fee and targetRate 0.5 -> 0.0", "[Transaction]") {
    Transaction t(0.0f, 2.0f);
    float result = t.processTransaction(10.0f, 0.5f);
    REQUIRE(result == Approx(0.0f));
}


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: Initialization List Practice

Example

Solution

Awesome!

Challenge: Initialization List Practice

Example

Solution