Question

我正在尝试从父母的定义中重新定义两个成员函数。
我不知道我是否正确，但我的代码中的某些内容附加了错误，我无法找出点。

一些标题：

class Account 
{
public:
   Account(double);
   void creditBalance(double);
   void debitBalance(double);
   double getBalance() const;
protected:
   double balance;      
};


class CheckingAccount : public Account
{
public:
   CheckingAccount(double, double);
   void feeCreditBalance(double);
   void feeDebitBalance(double);

private:
   double fee = 10;

};

相关的cpp文件部分：

void Account::creditBalance(double plus)
{
   if(plus > 0)
      balance += plus;
   else
      cout << "Cannot credit negative.";
}

void Account::debitBalance(double minus)
{
   if(minus <= balance)
      balance -= minus;
   else
      cout << "Debit amount exceeded account balance.";
}

void CheckingAccount::feeCreditBalance(double plus)
{
   if(plus > 0){
      balance += plus;
      balance -= fee;
   }
   else
      cout << "Cannot credit negative.";
}

void CheckingAccount::feeDebitBalance(double minus)
{
   if(minus <= balance){
      balance -= minus;
      balance -= fee;
   }
   else
      cout << "Debit amount exceeded account balance.";
}

更新：

我补充说：

class Account 
{
public:
   Account(double);
   virtual void creditBalance(double);
   virtual void debitBalance(double);
   double getBalance() const;
protected:
   double balance;      
};

现在我收到错误：虚拟外部类声明

我可以使用一个如何正确初始化费用的例子。

编辑2：

我尝试将构造函数行更改为：

CheckingAccount::CheckingAccount(double initBal, double phi) :  Account(initBal), fee(phi)
{
   if(initBal < 0)
      initBal = 0;
   balance = initBal;
   cerr << "Initial balance was invalid.";

   if(phi < 0)
      phi = 0;
   fee = phi;
}

不工作，我将继续改变费用（phi）部分的语法。我不知道是否有人会对此作出回应。

Answer 1

你不能像这样初始化成员变量（双倍费用= 10）。您必须在派生类构造函数的initiasation列表中初始化。另请注意，如果使用继承，则应使基类析构函数为virtual。

Answer 2

您需要了解overriding成员函数（使用virtual关键字）。如果要更改基类成员函数实现，则需要覆盖这些方法并在派生类中提供不同的实现。

编辑：

double fee = 10;

这可能是你说的错误。使用member initializer list初始化fee。您无法将fee初始化为类内常量。

Answer 3

如果要覆盖父类中的方法，则应该为方法指定相同的名称。如果您希望它覆盖creditBalance，请不要将其称为feeCreditBalance。此外，如果您希望对creditBalance的调用始终使用子类中的一个，则需要在父类的方法定义中使用“virtual”关键字。

Answer 4

如果意图是对于CheckingAccount帐户的实例，则调用使用费用的版本，那么您希望使用虚拟方法。

虚方法是一种方法（至少在基类中）为“虚拟”，并且在任何派生类中具有相同的名称和签名。调用虚方法时，它将调用实例的“派生程度最高”版本。

要做到这一点，只需声明“void creditBalance（double）;”和“无效debitBalance（双）;” virtual（即“virtual void creditBalance（double）;”和“virtual void debitBalance（double）;”。然后在CheckingAccount中将“feeCreditBalance”和“feeDebitBalance”重命名为“creditBalance”和“debitBalance”。

编辑：简单的例子。

标题

class Base
{
public:
    Base(int x);
    //declare virtual so that derived classes may overide it
    virtual void sayHello();
protected:
    int x;
};

class Derived : public Base
{
public:
    Derived(int x, int y);
    //overide Base::sayHello(). the virtual keyword here is optional.
    virtual void sayHello();
protected:
    int y;
};

.cpp的

Base::Base(int x)
    :x(x)
{}
Derived::Devired(int x, int y)
    :Base(x), y(y)
{}
void Base::sayHello()
{
    std::cout << "Hello from Base!" << std::endl;
    std::cout << "X = " << x << std::endl;
}
void Derived::sayHello()
{
    std::cout << "Hello from Derived!" << std::endl;
    std::cout << "X = " << x << "  Y = " << y << std::endl;
}

int main()
{
    Base a(5);
    a.sayHello();//"Hello from Base!..."

    Derived b(10, -20);
    b.sayHello();//"Hello from Derived!..."

    Base *c = &b;//take pointer to b, reference would also do
    c->sayHello();//"Hello from Derived!..." because its a Derived instance, eventhough its a Base variable.
}

然后，您可以再次从Derive派生（类DerivedAgain：public Derived），并再次重载函数。

你也可以从Base派生出多个子类，每个子类都有自己的虚拟方法覆盖，就像我对Derived类所做的那样。

EDIT2：向示例添加变量以及如何使用初始化列表初始化基类和成员变量。

Answer 5

我认为费用应该是静态常量，如果它保持不变并且每个对象不变。

在类中声明：

static const double fee;

像这样定义外部类：

const double ClassName::fee = 10;

如果你想要你的实现不应该允许-Ve平衡而不是像这样的东西，你也应该在继承中使用虚函数，这是更好的方法：

void CheckingAccount::feeCreditBalance(double plus)
{
    if(plus - fee > 0)
        balance += (plus - fee);
    else
        cout << "Cannot credit negative.";
}

关于重新定义成员职能的小问题

5 个答案: