这是与家庭作业有关的，所以我必须使用矢量来存储这些对象。 我有一个基类BankAccount，派生的CheckingAccount和SavingsAccount
我问用户他们想要输入哪个帐户的数据，即支票或储蓄，然后要求余额和利率/交易费用。然后，使用switch语句，使用这些输入初始化对象，并使用智能指针将其添加到向量vector<shared_ptr<BankAccount>>account_list。
接下来，我要求用户选择要与之交互的帐户类型，方法是添加成员函数credit或debit的事务（从基类重写，以便在检查或关注时考虑交易费用）储蓄率。）
我的问题在于：根据用户所选择的路线，可能会按照用户选择的顺序添加帐户，因此我不知道对象在向量中的位置。
帐户是这样添加的（在交换机案例中）：
cout << "\nEnter a unique name for this savings account: \t";
cin >> name_input;
cout << "\nEnter your initial balance: \t" << endl;
cin >> balanceInput;
cout << "\nEnter your interest rate: \t" << endl;
cin >> interestRate_input;
account_list.push_back(new SavingsAccount(balanceInput,name_input,interestRate_input)); //create savings account object
cout << "\nAccount created successfully" << endl;
如何在两个对象的向量中找到CheckingAccount类型或类型SavingsAccount，然后知道元素位置，在其上调用相应的成员函数？
这就是我到目前为止所做的，所以请原谅我正在试验并试图解决问题的任何杂乱的代码。例如：
cout << "\nEnter the amount to debit: \t" << endl;
cin >> amount;
//this might work but I don't know if this is where the relevant account resides
account_list[0]->debit(amount);
//here I don't know how to use the element once it is found to call a function on it
vector<shared_ptr<BankAccount>>::iterator
itElem = find_if(account_list.begin(), account_list.end(), HasIdentifier(account_choice));
account_list.itElem -> debit(amount);
//the line above this doesn't work
在基类中，我创建了一个string accountName，因此每个帐户都有一个唯一的ID。
这是为find_if创建的HasIdentifier类，可以按帐户名进行搜索。
class HasIdentifier:public unary_function<BankAccount, bool>
{
public:
HasIdentifier(string id) : m_id(id) { }
bool operator()(const BankAccount& c)const
{
return (c.getName() == m_id);
}
private:
string m_id;
};
这是以下整个计划。我仍然遇到这些错误：
error: no matching function for call to object of type 'HasIdentifier'
if (__pred(*__first))
^~~~~~
.../WA4_2/main.cpp:230:19: note: in instantiation of function template specialization 'std::__1::find_if<std::__1::__wrap_iter<std::__1::shared_ptr<BankAccount> *>, HasIdentifier>' requested here
itElem = std::find_if(account_list.begin(), account_list.end(), HasIdentifier(account_choice));
^
.../WA4_2/main.cpp:169:8: note: candidate function not viable: no known conversion from 'std::__1::shared_ptr<BankAccount>' to 'const BankAccount' for 1st argument
bool operator()(const BankAccount& c)const
我不确定该怎么做。如果HasIdentifier不起作用，则意味着要在向量中搜索任何对象的标识符。
#include <iostream>
#include <vector>
#include <algorithm>
// class for bank account
class BankAccount { //balance as double protected member so child classes can access
protected:
double balance = 0;
std::string account_name = "???";
public:
BankAccount() {};
~BankAccount() {};
BankAccount(double userBalance, std::string name) {
if (userBalance >= 0) { // constructor to receive initial balance and use it to initialize the balance
balance = userBalance;
} else {
balance = 0; //verify balance is greater than or equal to 0, else display error and set balance to 0
std::cout << "\nError, balance set to 0\n";
}
account_name=name;
}
const std::string &getAccount_name() const {
return account_name;
}
void setAccount_name(const std::string &account_name) {
BankAccount::account_name = account_name;
};
virtual void
credit(double amount) { // Member function credit should add an amount to the current balance.
balance += amount;
}
virtual void
debit(double amount) { // Member function debit should withdraw money from the Bank-Account and ensure that the debit amount does not exceed
if (amount >
balance) { // the Bank-Account’s balance. If it does, the balance should be left unchanged and the function should print the message
std::cout << "The balance is less than the debit amount.\n"; // “The balance is less than the debit amount.”
} else {
balance -= amount;
}
}
virtual double getBalance() { // Member function getBalance should return the current balance.
return balance;
};
std::string getName()const {
return this->account_name;
}
bool operator ==(const BankAccount& compare) const{
return this->account_name == compare.account_name;
}
};
class SavingsAccount : public BankAccount { // inherit bank account class to create savings account
double interestRate = 0;
public: // constructor to get initial balance and interest rate
SavingsAccount(double userBalance, const std::string &name, double user_rate) : BankAccount(userBalance, name),
interestRate(user_rate) {
interestRate = user_rate;
}
double
calculateInterest() { // calculateInterest that returns a double indicating the amount of interest earned by an account
double earnings = 0; // this amount is calc by multiplying the interest rate by the bank account balance
double a = 0;
a = getBalance();
earnings = a * interestRate;
return earnings;
}
void credit(double amount) {
balance += amount +
calculateInterest(); // Member function credit should add an amount to the current balance.
}
};
class CheckingAccount : public BankAccount {
double transactionFee;
public:
CheckingAccount(double userBalance, const std::string &name, double transfee_input) : BankAccount(userBalance, name),
transactionFee(
transfee_input) {
transactionFee=transfee_input;
}
void credit(double amount) {
balance += amount + transactionFee; // Member function credit should add an amount to the current balance.
}
void debit(double amount) { // Member function debit should withdraw money from the Bank-Account and ensure that the debit amount does not exceed
if (amount >
getBalance()) { // the Bank-Account’s balance. If it does, the balance should be left unchanged and the function should print the message
std::cout << "The balance is less than the debit amount.\n"; // “The balance is less than the debit amount.”
} else {
balance -= amount + transactionFee;
}
}
};
class HasIdentifier:public std::unary_function<BankAccount, bool>
{
public:
HasIdentifier(std::string id) : m_id(id) { }
bool operator()(const BankAccount& c)const
{
return (c.getName() == m_id);
}
private:
std::string m_id;
};
int main() {
double balanceInput{0}; //variables for getting balance/interest inputs/outputs
double balanceOutput{0};
double interestRate_input{0};
double fee_input{0};
std::string name_input = "???";
std::vector<std::shared_ptr<BankAccount>>account_list; //storage for accounts
std::cout << "\nWhat type of account would you like to input? "
<< "\nSavings (1)"
<< "\nChecking (2)"
<< "\nEnter your choice:\t"
<< std::endl;
int choice{0};
std::cin >> choice;
switch(choice) {
case 1: { //savings input
std::cout << "\nEnter a unique name for this savings account: \t";
std::cin >> name_input;
std::cout << "\nEnter your initial balance: \t" << std::endl;
std::cin >> balanceInput;
std::cout << "\nEnter your interest rate: \t" << std::endl;
std::cin >> interestRate_input;
account_list.emplace_back(new SavingsAccount(balanceInput, name_input,
interestRate_input)); //create savings account object
std::cout << "\nAccount created successfully" << std::endl;
break;
}
case 2: {
std::cout << "\nEnter a unique name for this checking account: \t";
std::cin >> name_input;
std::cout << "\nEnter your initial balance: \t" << std::endl; //checking account input
std::cin >> balanceInput;
std::cout << "\nEnter the transaction fee: \t" << std::endl;
std::cin >> fee_input;
account_list.emplace_back(new CheckingAccount(balanceInput, name_input,fee_input)); //create checking account object
std::cout << "\nAccount created successfully" << std::endl;
break;
}
default: {
std::cout << "\nInvalid entry" << std::endl;
break;
}
}
std::cout << "\nTo enter a transaction for your account,"
<< "\nplease enter the account name: \t";
std::string account_choice="???";
std::cin >> account_choice;
std::vector<std::shared_ptr<BankAccount>>::iterator
itElem = std::find_if(account_list.begin(), account_list.end(), HasIdentifier(account_choice));
std::cout << "\nWould you like to process a (d)ebit or (c)redit to the account?" << std::endl;
int a = 0;
tolower(a);
std::cin >> a;
double amount{0};
switch (a){
case 'd': //debit the account
std::cout << "\nEnter the amount to debit: \t" << std::endl;
std::cin >> amount;
(**itElem).debit(amount);
break;
case 'c': //credit the account
std::cout << "\nEnter the amount to credit: \t" << std::endl;
std::cin >> amount;
(**itElem).credit(amount);
break;
default:
std::cout << "\nInvalid entry" << std::endl;
}
return 0;
}
答案 0 :(得分：0)
迭代器本身就像指针一样（即：它们的接口被设计成类似于指针），所以如果你有一个向量的迭代器，并且想要在底层对象上调用一个方法，你就这样做了＃34; as - 虽然＆＃34;迭代器是指向相关对象的指针。
struct my_struct {
int val;
double other;
void func() {}
};
int main() {
std::vector<my_struct> my_structs = /*...*/;
std::vector<my_struct>::iterator it = std::find_if(my_structs.begin(), my_structs.end(), [](my_struct const& m) {return m.val == 5;});
it->func();
}
在您的情况下，问题是您正在使用std::vector<std::shared_ptr<BankAccount>>。现在，仅基于提供的代码，看起来某种多态性正在发生，所以我想一些指针的使用是绝对必要的（虽然you should always prefer unique_ptr over shared_ptr when given a choice），但是因为向量本身是保存指针，所以你需要乘法 - 间接访问底层对象。
std::vector<std::shared_ptr<BankAccount>>::iterator
itElem = std::find_if(account_list.begin(), account_list.end(), HasIdentifier(account_choice));
(**itElim).debit(amount);
//OR...
itElim->get()->debit(amount);
我不知道 HasIdentifier是什么或它应该做什么：基于这种语法，我非常警惕它是另一个潜在的来源错误。但是有可能这部分代码已经正确编写，并且没有看到它是如何实现的，我无论如何都无法对其进行分析。无论如何，我提出的调整应该可以解决这个错误。
编辑：好的。 HasIdentifier。这是一个非常简单的修复：find_if调用的仿函数的签名应采用bool operator()(T t) const，bool operator()(T const& t) const或bool operator()(T & t) const或其他一些形式，其中T是您使用std::vector实例化的类型。
因此，在您的情况下，std::vector类型为std::vector<std::shared_ptr<BankAccount>>，这意味着T为std::shared_ptr<BankAccount>。但是在您的仿函数中，您已将签名定义为bool operator()(BankAccount const& account) const，而std::shared_ptr<T>不会隐式转换为T&或T const&。
只需更新仿函数即可使用std::shared_ptr<BankAccount> const&：
class HasIdentifier //No need to inherit from unary_function; it's been removed from C++17 anyways
{
public:
HasIdentifier(string id) :
m_id(std::move(id)) //You're passing by value anyways, so move-constructing m_id
//will improve performance, especially if it's a large string.
{}
bool operator()(std::shared_ptr<BankAccount> const& c)const
{
return (c->getName() == m_id);
}
private:
string m_id;
};