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

A Programação Orientada a Objetos (POO) em C++ auxilia na construção de código limpo, reutilizável e escalável ao organizar programas em torno de objetos e classes. Você aprenderá a definir e utilizar classes, criar construtores e destrutores, além de aplicar encapsulamento para proteger dados. Tópicos como herança, polimorfismo, membros estáticos, controle de acesso e sobrecarga de operadores ajudarão a projetar estruturas de código flexíveis e eficientes.

Aprenda a criar classes e objetos, definir atributos e métodos, trabalhar com membros estáticos e a palavra-chave this. Obtenha uma base sólida sobre como os objetos interagem e como escrever código limpo e modular utilizando princípios de POO.

Aprenda como construtores e destrutores gerenciam a criação e a finalização de objetos. Pratique o uso de listas de inicialização, delegação de construtores e a escrita de código limpo e eficiente com o manejo adequado do ciclo de vida dos objetos.

Aprenda como o encapsulamento, um dos princípios fundamentais da POO, aprimora a modularidade e a manutenibilidade do código por meio do ocultamento de dados, controle de acesso e uso de métodos acessores e mutadores.

Aprenda sobre o mecanismo fundamental da programação orientada a objetos que possibilita o reuso de código e promove a criação de relacionamentos hierárquicos entre classes.

O polimorfismo é um conceito fundamental em POO que possibilita a criação de estruturas de código flexíveis e extensíveis. Serão abordados função virtual, classes abstratas e sobrecarga de operadores, bem como seus papéis essenciais na promoção da flexibilidade e escalabilidade do código.

Desafio: Prática com Lista de Inicialização

Exemplo

Solução