Why must I re-declare a virtual function from an inherited class?

Question

I'm working on a simple C++ program and am having a difficult time understanding a compiler error I was getting. The issue was caused by me attempting to create a derived class from a base class. I've posted my code below with the same structure but have changed the names.

BaseClass.h

#ifndef BASECLASS_H
#define BASECLASS_H

class BaseClass {

    public:
        BaseClass(void);

        virtual int method1(void) = 0;
        virtual int method2(void) = 0;
        virtual float method3(void) = 0;

};

#endif // BASECLASS_H

DerivedClass.h

#ifndef DERIVEDCLASS_H
#define DERIVEDCLASS_H

#include "DerivedClass.h"

class DerivedClass: public BaseClass
{

    public:
        DerivedClass(void);     
};

#endif // DERIVEDCLASS_H

DerivedClass.cpp

#include "DerivedClass.h"

DerivedClass::DerivedClass(void)
{
}

int DerivedClass::method1(void)
{
  // TODO
} 

int DerivedClass::method2(void)
{
  // TODO
}

float DerivedClass::method3(void) 
{
  // TODO
}

When attempting to compile this, I get the following error for all the virtual methods:

no 'int DerivedClass::methodX()' member function declared in class 'DerivedClass'

As soon as I declare these methods in the 'DerivedClass.h', the errors go away since the compiler is now aware of the methods.

However, I'm confused. Why was it necessary to re-declare the pure virtual functions in DerivedClass.h? When I #include DerivedClass.h, that will automatically include BaseClass.h, thus I assume my DerivedClass.cpp should be fully aware of the methods. Am I doing something incorrect?

Answer 1

When you declare a method in a derived class, you say to the compiler:

I want to override this method in this class

So if you don't declare a method in the derived class, you say:

I don't want to override this method; derived class's implementation is the same as the one in the base class

In your case, the base class declares them as pure virtual, so in this case it can be paraphrased:

I don't want to implement this method in this class

If you try to define a method but not declare it, you contradict yourself. The compiler detects that (to protect you from your own negligence).