C ++多态性：如果派生类中的虚函数在基类中声明为常量，是否需要将其声明为常量

Question

I have two classes. In base class A virtual function window(void) is declared constant const while in derived class B, window(void) is not declared as cont . Does this satisfy polymorphism? If I call window() in main, will it first call the derived class B window() first and then class A version of window() . In my case it's not doing like this. Should I have to put const at the end of function in derived too?

  class A 
  {
   public:
      virtual int window (void) const
      {
         std::cout<<" We are in class A "<<std::endl;
         return std::min(x,y); // x is smaller
      }
    private:
    int x, y;              
   }

  class B : public A 
  {
   public:
       virtual int window (void)
       { 
          std::cout<<" We are in class B "<<std::endl;
          return A::window ();
       }
   }

   void main()
   {
     int z = window();
     std::cout<<z<<std::endl;
   }

The output should be like this

 We are in class B
 We are in class A
 x

Answer 1

The signature of an overriding method must exactly match the signature of the virtual base method that it is overriding (well, except for the case of covariant return values, but that is not relevant to your question). That signature includes trailing const ness. So yes, if the base method is declared as const , the overriding method must be declared as const as well.

If you are using C++11 or later, you should mark an overriding method with the override specifier , then the compiler will validate that it is actually overriding a virtual base method of matching signature , and will generate an error if a matching base method is not found. You don't get that validation at compile-time if you omit the override specifier.