我知道 – 在C中,重新定义的函数是静态绑定的,覆盖的函数是动态绑定的,并且一个虚拟函数被覆盖,并且非虚函数被重新定义.

当一个派生类“重新定义”一个基类中的方法时,它被认为是重新定义的.但是当派生类为虚拟时,它不再重新定义,而是覆盖.所以我明白规则的后勤,但我不明白底线.

在下面的例子中,函数Setscore被重新定义.但是,如果我在基类中设置setscore函数(通过向其添加虚拟单词),派生类中的setscore将被覆盖.我不明白底线 – 有什么区别.在setscore？

基础类：

class GradedActivity
{
protected:
   char letter;            // To hold the letter grade
   double score;           // To hold the numeric score
   void determineGrade();  // Determines the letter grade
public:
   // Default constructor
   GradedActivity()
  { letter = ' '; score = 0.0; }

 // Mutator function
   void setscore(double s) 
      { score = s;
        determineGrade();}

   // Accessor functions
   double getscore() const
      { return score; }

       char getLetterGrade() const
      { return letter; }
};

派生类：

class CurvedActivity : public GradedActivity
{
protected:
   double rawscore;     // Unadjusted score
   double percentage;   // Curve percentage
public:
   // Default constructor
   CurvedActivity() : GradedActivity()
      { rawscore = 0.0; percentage = 0.0; }

   // Mutator functions
   void setscore(double s) 
      { rawscore = s;
        GradedActivity::setscore(rawscore * percentage); }

   void setPercentage(double c)
      { percentage = c; }

   // Accessor funtions
   double getPercentage() const
      { return percentage; }

   double getRawscore() const
      { return rawscore; }
};

这是主要的：

// Define a CurvedActivity object.
   CurvedActivity exam;

   ... 

   // Send the values to the exam object.
   exam.setPercentage(percentage);
   exam.setscore(numericscore);