C++ can't define virtual function OUTSIDE classes and header file - c++

Question

As function name had been already declared in header file: function.h and header file were preloaded in OJ, I need to define myAdd in main.cpp, aka OUTSIDE classes. However, most tutorial I can find online about virtual function just define what the function should do INSIDE the class.This is header file:
#ifndef _FUNCTION_H_
#define _FUNCTION_H_
class abstractAdd
{
public:
abstractAdd(){};
~abstractAdd(){};
virtual int myAdd(int a, int b) = 0;
};
class Implement : public abstractAdd
{
private:
public:
Implement();
~Implement();
int myAdd(int a,int b);
};
;
#endif
I have tried this in main.cpp
//include every libraries needed
#include "function.h"
int Implement::myAdd(int a,int b)
{
int c=a+b;
return c;
}
int main(){
abstractAdd& ra = *new Implement();
string input;
while(getline(std::cin, input)){
istringstream testcase(input);
int a,b;
testcase >> a;
testcase >> b;
cout << ra.myAdd(a,b) << endl;
}
return 0;
}
But compiler said:
Undefined symbols for architecture x86_64:
"Implement::Implement()", referenced from:
_main in cc3KANpW.o
ld: symbol(s) not found for architecture x86_64
collect2: error: ld returned 1 exit status
How can I implement the function OUTSIDE classes and header files?

Answer 1

new Implement() will create an object. That entails calling the constructor. You declared a constructor Implement();, but didn't define it anywhere.
So the linker is complaining because it can't find the constructor definition.
If you simply wish to use the default constructor as a compiler would define it, you can declare it as follows:
Implement() = default;
It will be defaulted, and defined inline.
Same goes for Implement's destructor as well.
As an aside, while your program is small and probably hosted, it still contains a leak. You allocate with new but don't delete the created object. In real production code, that will be unacceptable. You can simplify your code and rid you self of this concern by using a smart pointer:
std::unique_ptr<abstractAdd> ra = std::make_unique<Implement>();
Now that the object is disposed of correctly when the time comes, you should also make the destructor of abstractAdd virtual as well. Because now you are destroying an object polymorphically.