Properly extending a class in C++ - c++

Question

with this code:
class Plant
{
public:
virtual std::string getPlantName();
virtual void setPlantName(std::string s);
virtual std::string getPlantType();
virtual void setPlantType(std::string s);
};
class Carrot : public Plant
{
public:
Carrot();
~Carrot();
private:
std::string _plantName;
};
and then:
#include "Carrot.hpp"
Carrot::Carrot()
{
}
Carrot::~Carrot() { }
std::string Carrot::getPlantName() { return _plantName; }
I am getting a link error:
Carrot.cpp:16:21: Out-of-line definition of 'getPlantName' does not match any declaration in 'Carrot'
So the goal here is to create a Plant class where other classes extend like class Carrot : public Plant
But, what I am not sure about is could I just inline the functionality in Plant so that I dont have to create these get and set functions in each class like Carrot or Peas, etc?
if I did:
inline virtual std::string getPlantName( return _plantName; );
would that work? I would then add std::string _PlantName; to class Plant and then when I create Carrot from Plant I get all the same functions and Carrot will have variables like _plantName, etc, correct?
So this would be:
class Plant
{
public:
inline virtual std::string getPlantName( return _plantName; );
virtual void setPlantName(std::string s);
virtual std::string getPlantType();
virtual void setPlantType(std::string s);
private:
std::string _plantName;
};
class Carrot : public Plant
{
public:
Carrot();
~Carrot();
};
#include "Carrot.hpp"
Carrot::Carrot()
{
setPlantName(CARROT::plantName);
}
Carrot::~Carrot() { }

Answer 1

If all objects of the Plant class should have a type and a name, both std::strings, you probably want those common members in the base class:
// Plant.hpp
class Plant
{
public:
Plant();
virtual ~Plant(); // virtual destructor!
virtual std::string getPlantName();
virtual void setPlantName(std::string s);
virtual std::string getPlantType();
virtual void setPlantType(std::string s);
protected:
std::string _plantName;
std::string _plantType;
};
// Plant.cpp
#include <Plant.hpp>
std::string Plant::getPlantName() { return _plantName; }
void Plant::setPlantName(std::string s) { _plantName = s; }
... same for type
When creating a derived class using class Carrot : public Plant, that class will have the same data members and the same functions. You would also have the ability to override them if needed (thanks to the virtual keyword, derived classes' implementations will be called when using a Plant pointer to a Carrot object).
Note that if you want to make sure never to instansiate a Plant object, you should make any non-common functions (like a DoSomethingTypeSpecific() that a Carrot or a Flower would do differently) pure virtual and by that creating an abstract base class. All base classes would then have to implement those functions.
Inlining here does not make a real difference, it's just a matter of defining the functions in the header or in a separate .cpp file. Generally, it's a good idea to keep the implementation in a separate file but these small setters and getters could easily be inlined if you wanted to.

Answer 2

You could correct the error by adding the method to the class declaration:
class Carrot : public Plant
{
public:
Carrot();
~Carrot();
virtual std::string getPlantName();
private:
std::string _plantName;
};
Or, if all plants have names, you could define the method in the Plant class instead (likely in in plant.cpp). In fact, you have to define it unless you declare it to be pure virtual.

Answer 3

You need to declare the function.
class Carrot : public Plant
{
public:
Carrot();
~Carrot();
std::string getPlantName(); //Add this
private:
std::string _plantName;
};
A couple of notes:
It isn't strictly necessary for Carrot::getPlantName to be virtual, although many C++ developers consider it good form. I personally prefer to only use virtuals in abstract base classes, and use none in concrete classes
You probabally need to add virtual ~Plant() {} to the Plant class. You almost always want classes with virtual methods to also have virtual destructors.