मैं 3 व्युत्पन्न वर्गों के साथ बैंक खाता वर्ग बनाने का अभ्यास कर रहा हूं।

मैं सोच रहा था कि मैं सभी तीन व्युत्पन्न वर्गों की एकमुश्त राशि को मूल शेष में कैसे प्राप्त कर सकता हूं क्योंकि एक बैंक स्टेटमेंट एक उपयोगकर्ता खाते से संबंधित सभी विभिन्न प्रकार के खातों की कुल शुद्ध राशि कैसे दिखाता है।

क्या मुझे get_Balance func और setbalance के साथ तीनों को समेटने के लिए केवल एक फ़ंक्शन को अलग करना चाहिए? या विरासत का उपयोग करने के साथ कुछ ऐसा है जो मैं func बनाये बिना कर सकता हूं?

#include "pch.h"
#include <iostream>
#include <vector>

using namespace std;

class bankaccount {
    int accountnum;
    double balance;
public:
    //bankaccount() { accountnum = 0; balance = 0.00; }
    bankaccount(int newacctnum) :accountnum(newacctnum) { balance = 1000.00; }
    int getacctnum() { return accountnum; }
    double getbalance() { return balance; }
    void set_balance(double x) { balance = x; }
    void deposit(double deposits) { balance += deposits; }
    void withdraw(double minus) { balance -= minus; }
    virtual void runMonthly() { balance = balance; };
};

class CheckingAccount:public bankaccount {
    int fee;
public:
    CheckingAccount(int acctnum, int newfee) :bankaccount(acctnum) { fee = newfee; };
    void runMonthly() {  set_balance(getbalance() - fee); }
};

class SavingsAccount:public bankaccount {
    double interest;
public:
    //SavingsAccount() { interest = 0.00; }
    SavingsAccount(int acctnum, double newint) :bankaccount(acctnum) { interest = newint; };
    void runMonthly() { set_balance(getbalance() *(1.00+ interest)); }
};


class CreditCard :public bankaccount {
    double cardint;
public:
    //CreditCard() { cardint = 0.00; }
    CreditCard(int acctnum, double newint) :bankaccount(acctnum) { cardint = newint/100; }
    void runMonthly() { set_balance(-1*getbalance() *(1.00 + cardint)); }
};


class Bank {
    vector<bankaccount*>thelist;
public:
    void addAccount(bankaccount *accounts){
        thelist.push_back(accounts);
    }
    void runMonthly() {
        thelist[0]->deposit(60000);
        for (int i = 0; i < thelist.size(); i++)
            thelist[i]->runMonthly();
        for (int i = 0; i < thelist.size(); i++) {
            cout << thelist[i]->getacctnum() << " " << thelist[i]->getbalance() << endl;
        }
    }

};


int main() {

    Bank b;
    b.addAccount(new bankaccount(122552));
    b.addAccount(new CheckingAccount(12345, 18)); //$18 monthly fee
    b.addAccount(new SavingsAccount(12346, 0.02)); // 2% per month interest!
    b.addAccount(new CreditCard(12347, 21.5)); // 21.5% interest rate!  


    b.runMonthly();

}
0
George Go 15 जून 2020, 10:18

1 उत्तर

सबसे बढ़िया उत्तर

मेरी राय में, मुख्य अंतर्दृष्टि यह महसूस करना है कि मूल खाता वास्तव में मूल खाता नहीं है।

नीचे दिए गए मेरे कोड में, प्रत्येक ग्राहक के पास आपके कोड में मूल खाते के बजाय एक BaseAccount होगा। (हालांकि अधिक उन्नत बैंकिंग के लिए, एकाधिक ग्राहकों के पास एक ही खाते तक पहुंच हो सकती है।)

आप किसी BaseAccount से withdraw() या deposit नहीं कर सकते। इसके बजाय, बेसअकाउंट सिर्फ सभी उप-खातों को रखता है।

नोट: यह वर्चुअल इनहेरिटेंस अपेक्षाकृत धीमा है। कोड बहुत सारे पॉइंटर का पीछा करते हुए समाप्त हो जाएगा। रनटाइम पॉलीमॉर्फिज्म (== वर्चुअल इनहेरिटेंस) के बेहतर विकल्प CRTP और std::variant हैं। मैं दिखाए गए मूल कोड से बहुत ज्यादा विचलित नहीं होना चाहता था।

परिणाम: https://godbolt.org/z/WjWMe-

#include <algorithm>
#include <cassert>
#include <iostream>
#include <memory>
#include <numeric>
#include <vector>

class BankAccount {
  int accountnum;
  double balance;

public:
  BankAccount(int newacctnum) : accountnum(newacctnum), balance(0.0) {}
  virtual ~BankAccount(){};
  int getAccountNumber() { return accountnum; }
  double getBalance() { return balance; }
  void set_balance(double x) { balance = x; }
  void deposit(double deposits) { balance += deposits; }
  void withdraw(double minus) { balance -= minus; }
  virtual void consolidateMonthly() = 0; // Better name than runMonthly
};

class CheckingAccount : public BankAccount {
  int fee;

public:
  CheckingAccount(int acctnum, int newfee) : BankAccount(acctnum) {
    fee = newfee;
  };
  void consolidateMonthly() final { set_balance(getBalance() - fee); }
};

class SavingsAccount : public BankAccount {
  double interest;

public:
  SavingsAccount(int acctnum, double newint) : BankAccount(acctnum) {
    interest = newint;
  };
  void consolidateMonthly() final {
    set_balance(getBalance() * (1.00 + interest));
  }
};

class CreditCard : public BankAccount {
  double cardint;

public:
  CreditCard(int acctnum, double newint) : BankAccount(acctnum) {
    cardint = newint / 100;
  }
  void consolidateMonthly() final {
    set_balance(-1 * getBalance() * (1.00 + cardint));
  }
};
class BaseAccount { // NOTE: Purposefully not inheriting from a 'BankAccount' as
                    // deposit,withdraw do not make sense.
public:
  BaseAccount(int account_number) : account_number_(account_number){};
  void addSubsidiaryAccount(std::unique_ptr<BankAccount> account) {
    sub_accounts_.push_back(std::move(account));
  }

  std::vector<std::tuple<int, double>> getSubAccountStatements() const {
    std::vector<std::tuple<int, double>> ret;
    ret.push_back({account_number_, getBalance()});
    for (const auto &account : sub_accounts_) {
      ret.push_back({account->getAccountNumber(), account->getBalance()});
    }
    return ret;
  }

  void consolidateMonthly() {
    for (auto &account : sub_accounts_) {
      account->consolidateMonthly();
    }
  }

  int getAccountNumber() const { return account_number_; }
  int getBalance() const {
    return std::accumulate(
        sub_accounts_.begin(), sub_accounts_.end(), 0.,
        [](double balance, const std::unique_ptr<BankAccount> &acc) {
          return balance + acc->getBalance();
        });
  }

  BankAccount *getAccount(int account_number) const {
    auto act =
        std::find_if(sub_accounts_.begin(), sub_accounts_.end(),
                     [account_number](const std::unique_ptr<BankAccount> &ptr) {
                       return ptr->getAccountNumber() == account_number;
                     });
    return act != sub_accounts_.end() ? act->get() : nullptr;
  }

private:
  const int account_number_;
  std::vector<std::unique_ptr<BankAccount>> sub_accounts_;
};

class Bank {
  std::vector<std::unique_ptr<BaseAccount>> account_list;

public:
  void addAccount(std::unique_ptr<BaseAccount> account) {
    account_list.push_back(std::move(account));
  }
  void runMonthly() const {
    for (const auto &account : account_list) {
      account->consolidateMonthly();
      auto sub = account->getSubAccountStatements();
      for (auto [acct, balance] :
           sub) { // Requires "structured bindings" from C++17
        std::cout << acct << ": " << balance << "\n";
      }
    }
  }
  void deposit(BankAccount *account, double amount) {
    assert(account);
    account->deposit(amount);
  }
};

int main() {
  Bank bank;
  // First, let's have a base_account and add all the subsidiary accounts to
  // this base account.
  auto base_account = std::make_unique<BaseAccount>(122552);
  base_account->addSubsidiaryAccount(
      std::make_unique<CheckingAccount>(12345, 18));
  base_account->addSubsidiaryAccount(
      std::make_unique<SavingsAccount>(12346, 0.02)); // 2% per month interest!
  base_account->addSubsidiaryAccount(
      std::make_unique<CreditCard>(12347, 21.5)); // 21.5% interest rate!

  auto checking_account_ptr = base_account->getAccount(12345);
  if (!checking_account_ptr) {
    std::cerr << "Failed to find account with ID 12345!\n";
    return -1;
  }
  // Deposit 60k into the checking account(12345)
  checking_account_ptr->deposit(60000);

  bank.addAccount(std::move(base_account));

  bank.runMonthly();
}
0
Unapiedra 16 जून 2020, 09:38