Projeto Contas Bancárias (POO)

Missão (etapa 1): crie uma segunda conta, bruno, do titular "Bruno". Deposite 300 e depois 25.50, e mostre a frase dele igual à da Ana. A saída deve terminar com:

Bruno tem R$ 325.5

#include <iostream>
#include <string>

class Conta {
public:
    explicit Conta(std::string titular) : titular_{titular} {}

    void depositar(double valor) {
        saldo_ += valor;
    }

    std::string titular() const { return titular_; }
    double saldo() const { return saldo_; }

private:
    std::string titular_;
    double saldo_ = 0.0;
};

int main() {
    Conta ana{"Ana"};
    ana.depositar(150.0);
    ana.depositar(49.90);
    std::cout << ana.titular() << " tem R$ " << ana.saldo() << '\n';
}

#include <iostream>
#include <string>

class Conta {
public:
    explicit Conta(std::string titular) : titular_{titular} {}

    void depositar(double valor) {
        saldo_ += valor;
    }

    std::string titular() const { return titular_; }
    double saldo() const { return saldo_; }

private:
    std::string titular_;
    double saldo_ = 0.0;
};

int main() {
    Conta ana{"Ana"};
    ana.depositar(150.0);
    ana.depositar(49.90);
    std::cout << ana.titular() << " tem R$ " << ana.saldo() << '\n';

    Conta bruno{"Bruno"};
    bruno.depositar(300.0);
    bruno.depositar(25.50);
    std::cout << bruno.titular() << " tem R$ " << bruno.saldo() << '\n';
}

Missão (etapa 2): o método sacar está vazio: sempre recusa. Escreva o corpo dele: devolva false se o valor for zero, negativo ou maior que o saldo; senão, tire o valor do saldo e devolva true. (O aviso unused parameter ‘valor’ some quando você usar o parâmetro.) A saída deve ser:

Saque de 250 feito.
Saque de 5000 recusado.
Depósito de -50 recusado.
Ana tem R$ 750

#include <iostream>
#include <string>

class Conta {
public:
    explicit Conta(std::string titular) : titular_{titular} {}

    bool depositar(double valor) {
        if (valor <= 0) {
            return false;          // recusado: nada muda
        }
        saldo_ += valor;
        return true;
    }

    bool sacar(double valor) {
        // Missão: recuse (return false) se o valor for zero, negativo
        // ou maior que o saldo; senão, tire do saldo e devolva true.
        return false;
    }

    std::string titular() const { return titular_; }
    double saldo() const { return saldo_; }

private:
    std::string titular_;
    double saldo_ = 0.0;
};

int main() {
    Conta ana{"Ana"};
    ana.depositar(1000.0);

    if (ana.sacar(250.0)) {
        std::cout << "Saque de 250 feito.\n";
    }
    if (!ana.sacar(5000.0)) {
        std::cout << "Saque de 5000 recusado.\n";
    }
    if (!ana.depositar(-50.0)) {
        std::cout << "Depósito de -50 recusado.\n";
    }
    ana.sacar(800.0);      // ninguém conferiu se deu certo...
    std::cout << ana.titular() << " tem R$ " << ana.saldo() << '\n';
}

#include <iostream>
#include <string>

class Conta {
public:
    explicit Conta(std::string titular) : titular_{titular} {}

    bool depositar(double valor) {
        if (valor <= 0) {
            return false;          // recusado: nada muda
        }
        saldo_ += valor;
        return true;
    }

    bool sacar(double valor) {
        if (valor <= 0 || valor > saldo_) {
            return false;
        }
        saldo_ -= valor;
        return true;
    }

    std::string titular() const { return titular_; }
    double saldo() const { return saldo_; }

private:
    std::string titular_;
    double saldo_ = 0.0;
};

int main() {
    Conta ana{"Ana"};
    ana.depositar(1000.0);

    if (ana.sacar(250.0)) {
        std::cout << "Saque de 250 feito.\n";
    }
    if (!ana.sacar(5000.0)) {
        std::cout << "Saque de 5000 recusado.\n";
    }
    if (!ana.depositar(-50.0)) {
        std::cout << "Depósito de -50 recusado.\n";
    }
    ana.sacar(800.0);      // ninguém conferiu se deu certo...
    std::cout << ana.titular() << " tem R$ " << ana.saldo() << '\n';
}

Missão (etapa 3): o sacar já lança as exceções, mas o depositar aceita qualquer valor, e o depósito de −50 tirou dinheiro da Ana (ela ficou com 700). Faça o depositar lançar std::invalid_argument com a mensagem "o valor precisa ser positivo" quando o valor não for positivo. O main já tem o catch. A saída deve ser:

Saque de 250 feito.
Recusado: saldo insuficiente (saldo 750.00, pedido 5000.00)
Erro: o valor precisa ser positivo
Ana tem R$ 750

#include <format>
#include <iostream>
#include <stdexcept>
#include <string>

class SaldoInsuficiente : public std::runtime_error {
public:
    SaldoInsuficiente(double saldo, double pedido)
        : std::runtime_error{std::format("saldo insuficiente (saldo {:.2f}, pedido {:.2f})",
                                         saldo, pedido)} {}
};

class Conta {
public:
    explicit Conta(std::string titular) : titular_{titular} {}

    void depositar(double valor) {
        // Missão: lance std::invalid_argument se o valor não for positivo.
        saldo_ += valor;
    }

    void sacar(double valor) {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        if (valor > saldo_) {
            throw SaldoInsuficiente{saldo_, valor};
        }
        saldo_ -= valor;
    }

    std::string titular() const { return titular_; }
    double saldo() const { return saldo_; }

private:
    std::string titular_;
    double saldo_ = 0.0;
};

int main() {
    Conta ana{"Ana"};
    ana.depositar(1000.0);

    try {
        ana.sacar(250.0);
        std::cout << "Saque de 250 feito.\n";
        ana.sacar(5000.0);
        std::cout << "Esta linha não aparece.\n";
    } catch (const SaldoInsuficiente& e) {
        std::cout << "Recusado: " << e.what() << '\n';
    }

    try {
        ana.depositar(-50.0);
    } catch (const std::invalid_argument& e) {
        std::cout << "Erro: " << e.what() << '\n';
    }

    std::cout << ana.titular() << " tem R$ " << ana.saldo() << '\n';
}

#include <format>
#include <iostream>
#include <stdexcept>
#include <string>

class SaldoInsuficiente : public std::runtime_error {
public:
    SaldoInsuficiente(double saldo, double pedido)
        : std::runtime_error{std::format("saldo insuficiente (saldo {:.2f}, pedido {:.2f})",
                                         saldo, pedido)} {}
};

class Conta {
public:
    explicit Conta(std::string titular) : titular_{titular} {}

    void depositar(double valor) {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        saldo_ += valor;
    }

    void sacar(double valor) {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        if (valor > saldo_) {
            throw SaldoInsuficiente{saldo_, valor};
        }
        saldo_ -= valor;
    }

    std::string titular() const { return titular_; }
    double saldo() const { return saldo_; }

private:
    std::string titular_;
    double saldo_ = 0.0;
};

int main() {
    Conta ana{"Ana"};
    ana.depositar(1000.0);

    try {
        ana.sacar(250.0);
        std::cout << "Saque de 250 feito.\n";
        ana.sacar(5000.0);
        std::cout << "Esta linha não aparece.\n";
    } catch (const SaldoInsuficiente& e) {
        std::cout << "Recusado: " << e.what() << '\n';
    }

    try {
        ana.depositar(-50.0);
    } catch (const std::invalid_argument& e) {
        std::cout << "Erro: " << e.what() << '\n';
    }

    std::cout << ana.titular() << " tem R$ " << ana.saldo() << '\n';
}

Missão (etapa 4): crie a conta que cobra tarifa. A classe ContaTarifada já herda de Conta; escreva nela tipo(), devolvendo "Tarifada", e fecharMes(), que saca a tarifa de 12.90 (use o sacar herdado). Não esqueça o override. A saída deve ser:

Carla (Tarifada): R$ 87.1

#include <format>
#include <iostream>
#include <stdexcept>
#include <string>

class SaldoInsuficiente : public std::runtime_error {
public:
    SaldoInsuficiente(double saldo, double pedido)
        : std::runtime_error{std::format("saldo insuficiente (saldo {:.2f}, pedido {:.2f})",
                                         saldo, pedido)} {}
};

class Conta {
public:
    explicit Conta(std::string titular) : titular_{titular} {}
    virtual ~Conta() = default;

    virtual std::string tipo() const { return "Corrente"; }
    virtual void fecharMes() {}      // a conta corrente não rende

    void depositar(double valor) {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        saldo_ += valor;
    }

    void sacar(double valor) {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        if (valor > saldo_) {
            throw SaldoInsuficiente{saldo_, valor};
        }
        saldo_ -= valor;
    }

    std::string titular() const { return titular_; }
    double saldo() const { return saldo_; }

private:
    std::string titular_;
    double saldo_ = 0.0;
};

class ContaPoupanca : public Conta {
public:
    ContaPoupanca(std::string titular, double taxa)
        : Conta{titular}, taxa_{taxa} {}

    std::string tipo() const override { return "Poupança"; }

    void fecharMes() override {
        double rendimento = saldo() * taxa_;
        if (rendimento > 0) {
            depositar(rendimento);
        }
    }

private:
    double taxa_;
};

class ContaTarifada : public Conta {
public:
    explicit ContaTarifada(std::string titular) : Conta{titular} {}

    // Missão: tipo() devolve "Tarifada" e fecharMes() saca a tarifa de 12.90.
};

void mostrar(const Conta& conta) {
    std::cout << conta.titular() << " (" << conta.tipo() << "): R$ "
              << conta.saldo() << '\n';
}

int main() {
    ContaTarifada carla{"Carla"};
    carla.depositar(100.0);
    carla.fecharMes();
    mostrar(carla);
}

#include <format>
#include <iostream>
#include <stdexcept>
#include <string>

class SaldoInsuficiente : public std::runtime_error {
public:
    SaldoInsuficiente(double saldo, double pedido)
        : std::runtime_error{std::format("saldo insuficiente (saldo {:.2f}, pedido {:.2f})",
                                         saldo, pedido)} {}
};

class Conta {
public:
    explicit Conta(std::string titular) : titular_{titular} {}
    virtual ~Conta() = default;

    virtual std::string tipo() const { return "Corrente"; }
    virtual void fecharMes() {}      // a conta corrente não rende

    void depositar(double valor) {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        saldo_ += valor;
    }

    void sacar(double valor) {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        if (valor > saldo_) {
            throw SaldoInsuficiente{saldo_, valor};
        }
        saldo_ -= valor;
    }

    std::string titular() const { return titular_; }
    double saldo() const { return saldo_; }

private:
    std::string titular_;
    double saldo_ = 0.0;
};

class ContaPoupanca : public Conta {
public:
    ContaPoupanca(std::string titular, double taxa)
        : Conta{titular}, taxa_{taxa} {}

    std::string tipo() const override { return "Poupança"; }

    void fecharMes() override {
        double rendimento = saldo() * taxa_;
        if (rendimento > 0) {
            depositar(rendimento);
        }
    }

private:
    double taxa_;
};

class ContaTarifada : public Conta {
public:
    explicit ContaTarifada(std::string titular) : Conta{titular} {}

    std::string tipo() const override { return "Tarifada"; }

    void fecharMes() override {
        sacar(12.90);
    }
};

void mostrar(const Conta& conta) {
    std::cout << conta.titular() << " (" << conta.tipo() << "): R$ "
              << conta.saldo() << '\n';
}

int main() {
    ContaTarifada carla{"Carla"};
    carla.depositar(100.0);
    carla.fecharMes();
    mostrar(carla);
}

Missão (etapa 5): abra uma quarta conta, uma poupança do "Diego" com taxa 0.02. Depois do último laço, some o saldo de todas as contas numa variável total (com mais um for) e mostre o total. A saída deve terminar com:

Diego (Poupança): R$ 1020
Total no banco: R$ 4035

#include <format>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>

class SaldoInsuficiente : public std::runtime_error {
public:
    SaldoInsuficiente(double saldo, double pedido)
        : std::runtime_error{std::format("saldo insuficiente (saldo {:.2f}, pedido {:.2f})",
                                         saldo, pedido)} {}
};

class Conta {
public:
    explicit Conta(std::string titular) : titular_{titular} {}
    virtual ~Conta() = default;

    virtual std::string tipo() const { return "Corrente"; }
    virtual void fecharMes() {}      // a conta corrente não rende

    void depositar(double valor) {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        saldo_ += valor;
    }

    void sacar(double valor) {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        if (valor > saldo_) {
            throw SaldoInsuficiente{saldo_, valor};
        }
        saldo_ -= valor;
    }

    std::string titular() const { return titular_; }
    double saldo() const { return saldo_; }

private:
    std::string titular_;
    double saldo_ = 0.0;
};

class ContaPoupanca : public Conta {
public:
    ContaPoupanca(std::string titular, double taxa)
        : Conta{titular}, taxa_{taxa} {}

    std::string tipo() const override { return "Poupança"; }

    void fecharMes() override {
        double rendimento = saldo() * taxa_;
        if (rendimento > 0) {
            depositar(rendimento);
        }
    }

private:
    double taxa_;
};

int main() {
    std::vector<std::unique_ptr<Conta>> contas;
    contas.push_back(std::make_unique<Conta>("Ana"));
    contas.push_back(std::make_unique<ContaPoupanca>("Bruno", 0.005));
    contas.push_back(std::make_unique<ContaPoupanca>("Carla", 0.01));

    for (const auto& conta : contas) {
        conta->depositar(1000.0);
    }
    for (const auto& conta : contas) {
        conta->fecharMes();               // cada uma do seu jeito
    }
    for (const auto& conta : contas) {
        std::cout << conta->titular() << " (" << conta->tipo() << "): R$ "
                  << conta->saldo() << '\n';
    }
}

#include <format>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>

class SaldoInsuficiente : public std::runtime_error {
public:
    SaldoInsuficiente(double saldo, double pedido)
        : std::runtime_error{std::format("saldo insuficiente (saldo {:.2f}, pedido {:.2f})",
                                         saldo, pedido)} {}
};

class Conta {
public:
    explicit Conta(std::string titular) : titular_{titular} {}
    virtual ~Conta() = default;

    virtual std::string tipo() const { return "Corrente"; }
    virtual void fecharMes() {}      // a conta corrente não rende

    void depositar(double valor) {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        saldo_ += valor;
    }

    void sacar(double valor) {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        if (valor > saldo_) {
            throw SaldoInsuficiente{saldo_, valor};
        }
        saldo_ -= valor;
    }

    std::string titular() const { return titular_; }
    double saldo() const { return saldo_; }

private:
    std::string titular_;
    double saldo_ = 0.0;
};

class ContaPoupanca : public Conta {
public:
    ContaPoupanca(std::string titular, double taxa)
        : Conta{titular}, taxa_{taxa} {}

    std::string tipo() const override { return "Poupança"; }

    void fecharMes() override {
        double rendimento = saldo() * taxa_;
        if (rendimento > 0) {
            depositar(rendimento);
        }
    }

private:
    double taxa_;
};

int main() {
    std::vector<std::unique_ptr<Conta>> contas;
    contas.push_back(std::make_unique<Conta>("Ana"));
    contas.push_back(std::make_unique<ContaPoupanca>("Bruno", 0.005));
    contas.push_back(std::make_unique<ContaPoupanca>("Carla", 0.01));
    contas.push_back(std::make_unique<ContaPoupanca>("Diego", 0.02));

    for (const auto& conta : contas) {
        conta->depositar(1000.0);
    }
    for (const auto& conta : contas) {
        conta->fecharMes();               // cada uma do seu jeito
    }
    for (const auto& conta : contas) {
        std::cout << conta->titular() << " (" << conta->tipo() << "): R$ "
                  << conta->saldo() << '\n';
    }

    double total = 0.0;
    for (const auto& conta : contas) {
        total += conta->saldo();
    }
    std::cout << "Total no banco: R$ " << total << '\n';
}

Missão (etapa 6): no fim do main, em vez dos extratos, mostre um resumo com uma linha por conta, usando std::format("{:<6}{:<10}{:>8.2f}\n", …) com o titular, o tipo e o saldo. A saída deve ser:

Ana   Corrente    799.90
Bruno Poupança   1005.00

#include <format>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>

class SaldoInsuficiente : public std::runtime_error {
public:
    SaldoInsuficiente(double saldo, double pedido)
        : std::runtime_error{std::format("saldo insuficiente (saldo {:.2f}, pedido {:.2f})",
                                         saldo, pedido)} {}
};

struct Movimento {
    std::string descricao;
    double valor;              // positivo entra, negativo sai
};

class Conta {
public:
    explicit Conta(std::string titular) : titular_{titular} {}
    virtual ~Conta() = default;

    virtual std::string tipo() const { return "Corrente"; }
    virtual void fecharMes() {}      // a conta corrente não rende

    void depositar(double valor, std::string descricao = "Depósito") {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        saldo_ += valor;
        movimentos_.push_back({descricao, valor});
    }

    void sacar(double valor) {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        if (valor > saldo_) {
            throw SaldoInsuficiente{saldo_, valor};
        }
        saldo_ -= valor;
        movimentos_.push_back({"Saque", -valor});
    }

    std::string extrato() const {
        std::string texto = std::format("Extrato de {} ({})\n", titular_, tipo());
        for (const auto& m : movimentos_) {
            texto += std::format("  {:<12}{:>+10.2f}\n", m.descricao, m.valor);
        }
        texto += std::format("  {:<12}{:>10.2f}\n", "Saldo", saldo_);
        return texto;
    }

    std::string titular() const { return titular_; }
    double saldo() const { return saldo_; }

private:
    std::string titular_;
    double saldo_ = 0.0;
    std::vector<Movimento> movimentos_;
};

class ContaPoupanca : public Conta {
public:
    ContaPoupanca(std::string titular, double taxa)
        : Conta{titular}, taxa_{taxa} {}

    std::string tipo() const override { return "Poupança"; }

    void fecharMes() override {
        double rendimento = saldo() * taxa_;
        if (rendimento > 0) {
            depositar(rendimento, "Rendimento");
        }
    }

private:
    double taxa_;
};

int main() {
    std::vector<std::unique_ptr<Conta>> contas;
    contas.push_back(std::make_unique<Conta>("Ana"));
    contas.push_back(std::make_unique<ContaPoupanca>("Bruno", 0.005));

    contas[0]->depositar(1000.0);
    contas[0]->sacar(250.0);
    contas[0]->depositar(49.9, "Pix da Carla");
    contas[1]->depositar(1000.0);

    for (const auto& conta : contas) {
        conta->fecharMes();
    }
    // Missão: uma linha por conta com
    // std::format("{:<6}{:<10}{:>8.2f}\n", titular, tipo, saldo)
}

#include <format>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>

class SaldoInsuficiente : public std::runtime_error {
public:
    SaldoInsuficiente(double saldo, double pedido)
        : std::runtime_error{std::format("saldo insuficiente (saldo {:.2f}, pedido {:.2f})",
                                         saldo, pedido)} {}
};

struct Movimento {
    std::string descricao;
    double valor;              // positivo entra, negativo sai
};

class Conta {
public:
    explicit Conta(std::string titular) : titular_{titular} {}
    virtual ~Conta() = default;

    virtual std::string tipo() const { return "Corrente"; }
    virtual void fecharMes() {}      // a conta corrente não rende

    void depositar(double valor, std::string descricao = "Depósito") {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        saldo_ += valor;
        movimentos_.push_back({descricao, valor});
    }

    void sacar(double valor) {
        if (valor <= 0) {
            throw std::invalid_argument{"o valor precisa ser positivo"};
        }
        if (valor > saldo_) {
            throw SaldoInsuficiente{saldo_, valor};
        }
        saldo_ -= valor;
        movimentos_.push_back({"Saque", -valor});
    }

    std::string extrato() const {
        std::string texto = std::format("Extrato de {} ({})\n", titular_, tipo());
        for (const auto& m : movimentos_) {
            texto += std::format("  {:<12}{:>+10.2f}\n", m.descricao, m.valor);
        }
        texto += std::format("  {:<12}{:>10.2f}\n", "Saldo", saldo_);
        return texto;
    }

    std::string titular() const { return titular_; }
    double saldo() const { return saldo_; }

private:
    std::string titular_;
    double saldo_ = 0.0;
    std::vector<Movimento> movimentos_;
};

class ContaPoupanca : public Conta {
public:
    ContaPoupanca(std::string titular, double taxa)
        : Conta{titular}, taxa_{taxa} {}

    std::string tipo() const override { return "Poupança"; }

    void fecharMes() override {
        double rendimento = saldo() * taxa_;
        if (rendimento > 0) {
            depositar(rendimento, "Rendimento");
        }
    }

private:
    double taxa_;
};

int main() {
    std::vector<std::unique_ptr<Conta>> contas;
    contas.push_back(std::make_unique<Conta>("Ana"));
    contas.push_back(std::make_unique<ContaPoupanca>("Bruno", 0.005));

    contas[0]->depositar(1000.0);
    contas[0]->sacar(250.0);
    contas[0]->depositar(49.9, "Pix da Carla");
    contas[1]->depositar(1000.0);

    for (const auto& conta : contas) {
        conta->fecharMes();
    }
    for (const auto& conta : contas) {
        std::cout << std::format("{:<6}{:<10}{:>8.2f}\n",
                                 conta->titular(), conta->tipo(), conta->saldo());
    }
}

Missão (etapa 7): o main.cpp já chama contas[0]->transferir(*contas[1], 100.0), mas o método não existe, e a compilação falha. Crie-o: declare void transferir(Conta& destino, double valor); no conta.h e escreva o corpo no conta.cpp (saque da própria conta e depósito no destino com a descrição "Transferência"). O *contas[1] é a conta do Bruno: o * pega a conta para a qual o ponteiro aponta. Na saída devem aparecer:

  Saldo           699.90
  Transferência   +100.00

#include <iostream>
#include <memory>
#include <vector>
#include "conta.h"

int main() {
    std::vector<std::unique_ptr<Conta>> contas;
    contas.push_back(std::make_unique<Conta>("Ana"));
    contas.push_back(std::make_unique<ContaPoupanca>("Bruno", 0.005));

    contas[0]->depositar(1000.0);
    contas[0]->sacar(250.0);
    contas[0]->depositar(49.9, "Pix da Carla");
    contas[1]->depositar(1000.0);
    contas[0]->transferir(*contas[1], 100.0);   // Ana manda 100 para o Bruno

    for (const auto& conta : contas) {
        std::cout << conta->extrato() << '\n';
    }
}

#pragma once
#include <stdexcept>
#include <string>
#include <vector>

class SaldoInsuficiente : public std::runtime_error {
public:
    SaldoInsuficiente(double saldo, double pedido);
};

struct Movimento {
    std::string descricao;
    double valor;
};

class Conta {
public:
    explicit Conta(std::string titular);
    virtual ~Conta() = default;

    void depositar(double valor, std::string descricao = "Depósito");
    void sacar(double valor);

    virtual std::string tipo() const;
    virtual void fecharMes();

    std::string titular() const;
    double saldo() const;
    std::string extrato() const;

private:
    std::string titular_;
    double saldo_ = 0.0;
    std::vector<Movimento> movimentos_;
};

class ContaPoupanca : public Conta {
public:
    ContaPoupanca(std::string titular, double taxa);

    std::string tipo() const override;
    void fecharMes() override;

private:
    double taxa_;
};

#include "conta.h"
#include <format>

SaldoInsuficiente::SaldoInsuficiente(double saldo, double pedido)
    : std::runtime_error{std::format("saldo insuficiente (saldo {:.2f}, pedido {:.2f})", saldo, pedido)} {}

Conta::Conta(std::string titular) : titular_{titular} {}

void Conta::depositar(double valor, std::string descricao) {
    if (valor <= 0) {
        throw std::invalid_argument{"o valor precisa ser positivo"};
    }
    saldo_ += valor;
    movimentos_.push_back({descricao, valor});
}

void Conta::sacar(double valor) {
    if (valor <= 0) {
        throw std::invalid_argument{"o valor precisa ser positivo"};
    }
    if (valor > saldo_) {
        throw SaldoInsuficiente{saldo_, valor};
    }
    saldo_ -= valor;
    movimentos_.push_back({"Saque", -valor});
}

std::string Conta::tipo() const { return "Corrente"; }
void Conta::fecharMes() {}   // a conta corrente não rende
std::string Conta::titular() const { return titular_; }
double Conta::saldo() const { return saldo_; }

std::string Conta::extrato() const {
    std::string texto = std::format("Extrato de {} ({})\n", titular_, tipo());
    for (const auto& m : movimentos_) {
        texto += std::format("  {:<12}{:>+10.2f}\n", m.descricao, m.valor);
    }
    texto += std::format("  {:<12}{:>10.2f}\n", "Saldo", saldo_);
    return texto;
}

ContaPoupanca::ContaPoupanca(std::string titular, double taxa)
    : Conta{titular}, taxa_{taxa} {}

std::string ContaPoupanca::tipo() const { return "Poupança"; }

void ContaPoupanca::fecharMes() {
    double rendimento = saldo() * taxa_;
    if (rendimento > 0) {
        depositar(rendimento, "Rendimento");
    }
}

#pragma once
#include <stdexcept>
#include <string>
#include <vector>

class SaldoInsuficiente : public std::runtime_error {
public:
    SaldoInsuficiente(double saldo, double pedido);
};

struct Movimento {
    std::string descricao;
    double valor;
};

class Conta {
public:
    explicit Conta(std::string titular);
    virtual ~Conta() = default;

    void depositar(double valor, std::string descricao = "Depósito");
    void sacar(double valor);
    void transferir(Conta& destino, double valor);

    virtual std::string tipo() const;
    virtual void fecharMes();

    std::string titular() const;
    double saldo() const;
    std::string extrato() const;

private:
    std::string titular_;
    double saldo_ = 0.0;
    std::vector<Movimento> movimentos_;
};

class ContaPoupanca : public Conta {
public:
    ContaPoupanca(std::string titular, double taxa);

    std::string tipo() const override;
    void fecharMes() override;

private:
    double taxa_;
};

#include "conta.h"
#include <format>

SaldoInsuficiente::SaldoInsuficiente(double saldo, double pedido)
    : std::runtime_error{std::format("saldo insuficiente (saldo {:.2f}, pedido {:.2f})", saldo, pedido)} {}

Conta::Conta(std::string titular) : titular_{titular} {}

void Conta::depositar(double valor, std::string descricao) {
    if (valor <= 0) {
        throw std::invalid_argument{"o valor precisa ser positivo"};
    }
    saldo_ += valor;
    movimentos_.push_back({descricao, valor});
}

void Conta::sacar(double valor) {
    if (valor <= 0) {
        throw std::invalid_argument{"o valor precisa ser positivo"};
    }
    if (valor > saldo_) {
        throw SaldoInsuficiente{saldo_, valor};
    }
    saldo_ -= valor;
    movimentos_.push_back({"Saque", -valor});
}

void Conta::transferir(Conta& destino, double valor) {
    sacar(valor);                            // se faltar saldo, para aqui
    destino.depositar(valor, "Transferência");
}

std::string Conta::tipo() const { return "Corrente"; }
void Conta::fecharMes() {}   // a conta corrente não rende
std::string Conta::titular() const { return titular_; }
double Conta::saldo() const { return saldo_; }

std::string Conta::extrato() const {
    std::string texto = std::format("Extrato de {} ({})\n", titular_, tipo());
    for (const auto& m : movimentos_) {
        texto += std::format("  {:<12}{:>+10.2f}\n", m.descricao, m.valor);
    }
    texto += std::format("  {:<12}{:>10.2f}\n", "Saldo", saldo_);
    return texto;
}

ContaPoupanca::ContaPoupanca(std::string titular, double taxa)
    : Conta{titular}, taxa_{taxa} {}

std::string ContaPoupanca::tipo() const { return "Poupança"; }

void ContaPoupanca::fecharMes() {
    double rendimento = saldo() * taxa_;
    if (rendimento > 0) {
        depositar(rendimento, "Rendimento");
    }
}

Missão (etapa 8): acrescente ao menu o comando v N, que mostra só o saldo da conta N, com duas casas: Saldo de Ana: R$ 750.00. Use escolher e std::format (lembre do #include <format>). A caixa já digita para você: d 1 1000, s 1 250, v 1 e q.

#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
#include "conta.h"

using Contas = std::vector<std::unique_ptr<Conta>>;

Conta& escolher(Contas& contas, int numero) {
    if (numero < 1 || numero > static_cast<int>(contas.size())) {
        throw std::out_of_range{"não existe a conta " + std::to_string(numero)};
    }
    return *contas[numero - 1];
}

int main() {
    Contas contas;
    contas.push_back(std::make_unique<Conta>("Ana"));
    contas.push_back(std::make_unique<ContaPoupanca>("Bruno", 0.005));

    std::cout << "Banco da Ana. Comandos: l, d N VALOR, s N VALOR, e N, m, q\n";
    std::string linha;
    while (std::cout << "banco> " && std::getline(std::cin, linha)) {
        std::istringstream pedaco{linha};
        char comando = ' ';
        int numero = 0;
        double valor = 0.0;
        pedaco >> comando >> numero >> valor;

        try {
            if (comando == 'q') {
                break;
            } else if (comando == 'l') {
                for (std::size_t i = 0; i < contas.size(); ++i) {
                    std::cout << i + 1 << ". " << contas[i]->titular() << " ("
                              << contas[i]->tipo() << ")\n";
                }
            } else if (comando == 'd') {
                escolher(contas, numero).depositar(valor);
                std::cout << "Depósito feito.\n";
            } else if (comando == 's') {
                escolher(contas, numero).sacar(valor);
                std::cout << "Saque feito.\n";
            } else if (comando == 'e') {
                std::cout << escolher(contas, numero).extrato();
            } else if (comando == 'm') {
                for (auto& conta : contas) {
                    conta->fecharMes();
                }
                std::cout << "Mês fechado.\n";
            } else {
                std::cout << "Comando desconhecido: " << linha << '\n';
            }
        } catch (const SaldoInsuficiente& e) {
            std::cout << "Recusado: " << e.what() << '\n';
        } catch (const std::exception& e) {
            std::cout << "Erro: " << e.what() << '\n';
        }
    }
    std::cout << "\nAté logo!\n";
}

#pragma once
#include <stdexcept>
#include <string>
#include <vector>

class SaldoInsuficiente : public std::runtime_error {
public:
    SaldoInsuficiente(double saldo, double pedido);
};

struct Movimento {
    std::string descricao;
    double valor;
};

class Conta {
public:
    explicit Conta(std::string titular);
    virtual ~Conta() = default;

    void depositar(double valor, std::string descricao = "Depósito");
    void sacar(double valor);

    virtual std::string tipo() const;
    virtual void fecharMes();

    std::string titular() const;
    double saldo() const;
    std::string extrato() const;

private:
    std::string titular_;
    double saldo_ = 0.0;
    std::vector<Movimento> movimentos_;
};

class ContaPoupanca : public Conta {
public:
    ContaPoupanca(std::string titular, double taxa);

    std::string tipo() const override;
    void fecharMes() override;

private:
    double taxa_;
};

#include "conta.h"
#include <format>

SaldoInsuficiente::SaldoInsuficiente(double saldo, double pedido)
    : std::runtime_error{std::format("saldo insuficiente (saldo {:.2f}, pedido {:.2f})", saldo, pedido)} {}

Conta::Conta(std::string titular) : titular_{titular} {}

void Conta::depositar(double valor, std::string descricao) {
    if (valor <= 0) {
        throw std::invalid_argument{"o valor precisa ser positivo"};
    }
    saldo_ += valor;
    movimentos_.push_back({descricao, valor});
}

void Conta::sacar(double valor) {
    if (valor <= 0) {
        throw std::invalid_argument{"o valor precisa ser positivo"};
    }
    if (valor > saldo_) {
        throw SaldoInsuficiente{saldo_, valor};
    }
    saldo_ -= valor;
    movimentos_.push_back({"Saque", -valor});
}

std::string Conta::tipo() const { return "Corrente"; }
void Conta::fecharMes() {}   // a conta corrente não rende
std::string Conta::titular() const { return titular_; }
double Conta::saldo() const { return saldo_; }

std::string Conta::extrato() const {
    std::string texto = std::format("Extrato de {} ({})\n", titular_, tipo());
    for (const auto& m : movimentos_) {
        texto += std::format("  {:<12}{:>+10.2f}\n", m.descricao, m.valor);
    }
    texto += std::format("  {:<12}{:>10.2f}\n", "Saldo", saldo_);
    return texto;
}

ContaPoupanca::ContaPoupanca(std::string titular, double taxa)
    : Conta{titular}, taxa_{taxa} {}

std::string ContaPoupanca::tipo() const { return "Poupança"; }

void ContaPoupanca::fecharMes() {
    double rendimento = saldo() * taxa_;
    if (rendimento > 0) {
        depositar(rendimento, "Rendimento");
    }
}

#include <format>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
#include "conta.h"

using Contas = std::vector<std::unique_ptr<Conta>>;

Conta& escolher(Contas& contas, int numero) {
    if (numero < 1 || numero > static_cast<int>(contas.size())) {
        throw std::out_of_range{"não existe a conta " + std::to_string(numero)};
    }
    return *contas[numero - 1];
}

int main() {
    Contas contas;
    contas.push_back(std::make_unique<Conta>("Ana"));
    contas.push_back(std::make_unique<ContaPoupanca>("Bruno", 0.005));

    std::cout << "Banco da Ana. Comandos: l, d N VALOR, s N VALOR, e N, m, q\n";
    std::string linha;
    while (std::cout << "banco> " && std::getline(std::cin, linha)) {
        std::istringstream pedaco{linha};
        char comando = ' ';
        int numero = 0;
        double valor = 0.0;
        pedaco >> comando >> numero >> valor;

        try {
            if (comando == 'q') {
                break;
            } else if (comando == 'l') {
                for (std::size_t i = 0; i < contas.size(); ++i) {
                    std::cout << i + 1 << ". " << contas[i]->titular() << " ("
                              << contas[i]->tipo() << ")\n";
                }
            } else if (comando == 'd') {
                escolher(contas, numero).depositar(valor);
                std::cout << "Depósito feito.\n";
            } else if (comando == 's') {
                escolher(contas, numero).sacar(valor);
                std::cout << "Saque feito.\n";
            } else if (comando == 'v') {
                Conta& conta = escolher(contas, numero);
                std::cout << std::format("Saldo de {}: R$ {:.2f}\n", conta.titular(), conta.saldo());
            } else if (comando == 'e') {
                std::cout << escolher(contas, numero).extrato();
            } else if (comando == 'm') {
                for (auto& conta : contas) {
                    conta->fecharMes();
                }
                std::cout << "Mês fechado.\n";
            } else {
                std::cout << "Comando desconhecido: " << linha << '\n';
            }
        } catch (const SaldoInsuficiente& e) {
            std::cout << "Recusado: " << e.what() << '\n';
        } catch (const std::exception& e) {
            std::cout << "Erro: " << e.what() << '\n';
        }
    }
    std::cout << "\nAté logo!\n";
}