C++ can't access child property from parent - c++

Question

Can anybody explain why Driver init() method is unable to print name property overridden in child?
#include <iostream>
#include <string>
class Driver {
public:
std::string name = "Unknown";
void init() {
std::cout << name << std::endl;
}
};
// need public here to inherit init()
class SpecificDriver : public Driver {
public:
std::string name = "Specific";
};
int main() {
Driver d;
SpecificDriver sd;
// this gives Unknown Unknown =/
d.init();
sd.init();
}
This gives:
Unknown
Unknown
And should be:
Unknown
Specific
Live Demo

Answer 1

You are not doing quite what you think you may be. You are declaring a variable "name" in driver and a variable "name" in SpecificDriver. When you call init() defined in base class driver, that driver can only access its own name field with value "unknown".
Instead you should initialize the "name" variable using a constructor.
Like this:
class Driver {
public:
std::string name;
Driver():name("Unknown"){} //default
Driver(std::string value):name(value){}
void init() {
std::cout << name << std::endl;
}
};
// need public here to inherit init()
class SpecificDriver : public Driver {
public:
SpecificDriver():Driver("Specific"){}
};
int main() {
Driver d;
SpecificDriver sd;
d.init();
sd.init();
}
Edit: Live Demo http://coliru.stacked-crooked.com/a/c453758867454348

Answer 2

In C++, virtual inheritance is opt-in and not implicit.
When you have this code
class Driver {
public:
std::string name = "Unknown";
void init() {
std::cout << name << std::endl;
}
};
the symbol name will be resolved statically based on what is in scope at that time.
If you later declare a global variable name it has no effect on the meaning of this code. If you later derive from this class Driver, the init function when it is inherited for that class, won't have a different meaning, as in your example.
This "static" dispatch is the default behavior in C++ because it is the simplest and fastest. Especially, it is important that it works this way if you are doing things with templates and inheritance later, otherwise lots of code would have lots of extra overhead.
Alex Zywicki shows one way that you could achieve what you want. Another way would be to use virtual dispatch to get the string. Something like this:
class Driver {
public:
virtual std::string name() const {
return "Unknown";
}
void init() {
std::cout << name() << std::endl;
}
};
class SpecificDriver : public Driver {
virtual std::string name() const override {
return "Specific";
}
};

Answer 3

It is possible to access the class member of the child class through CRTP.
#include <iostream>
template <typename Derived>
class Driver {
public:
void init() {
std::cout << static_cast<Derived*>(this)->name << std::endl;
std::cout << Derived::value << std::endl;
}
};
class SpecificDriver : public Driver<SpecificDriver> {
public:
std::string name = "Specific";
static constexpr char* value = "Another specific string";
};
int main() {
SpecificDriver g;
g.init();
}
If you need a common base class for storing these in, or combining with normal polymorphic behavior you can make the template class Driver inherit from a common base class.