C++ prevent inherit specific public member of base class - c++

Question

How can I prevent a public member to be inherited by it's derived class? Like, if I have this:
class Person {
public:
enum { MALE, FEMALE, BOTH };
Person(std::string name, int gender)
: _name(name)
{
switch (gender) { /* processing here */ }
}
protected:
std::string _name;
};
class Male : public Person {
public:
Male(std::string name)
: _name(name, 0) { }
};
The reason I want to do this is, I want to be able to instantiate a person class with something like:
Person person("The Name", Person::MALE);
But, because the enum is public this is also available:
Male::MALE
Male::FEMALE
Male::BOTH
which doesn't make any sense anymore. How can I prevent the derived class to be able to access those enum values, but make it available for public from the base class?

Answer 1

If you insist on keeping the enum within the base class, you can place the enum in a protected section.
class Person {
protected:
enum Gender { MALE, FEMALE, BOTH };
Person(std::string name, Gender gender)
: _name(name)
{
switch (gender) { /* processing here */ }
}
std::string _name;
public:
virtual ~Person () {}
//...
};
A class that derives from Person publicly will still have access to the enum values, but users of the derived class will not.
class Male : public Person {
public:
Male (std::string name) : Person(name, MALE) {}
//...
};
Thus, a Male can use MALE, but users of Male will not see Male::MALE, Male::FEMALE, nor Male::BOTH, which was one of your original issues. As to your questions, you don't really want to deny the derived class access, since you want the derived class to be able to specify the Gender. And you should not really allow any direct users of Person. Instead, a user of Person picks one of the correct derived classes, which will then establish Gender properly.
class Female : public Person {
public:
Female (std::string name) : Person(name, FEMALE) {}
//...
};
class Transgender : public Person {
public:
Transgender (std::string name) : Person(name, BOTH) {}
//...
};
std::shared_ptr<Person> p = std::make_shared<Female>("Beth");

Answer 2

The comments in the OP suggest a rethinking of your design, and probably that is the best alternative.
Still, if you want to keep up with what you wrote in the answer, one possibility is to derive protectedly from your base class
class Person {
public:
enum { MALE, FEMALE, BOTH };
Person(std::string name, int gender)
: _name(name)
{
switch (gender) { /* processing here */ }
}
protected:
std::string _name;
};
class Male : protected Person
{ //^^^^^^^^^
public:
Male(std::string name)
: Person(name, 0) { }
void foo() { FEMALE; } // still ok, a public field derived protected'ly is accessible
};
int main()
{
Male male("Joe");
male.MALE; //error, cannot call the enum from outside the class
}

Answer 3

the problem seems to be a literate one, there is no problem with the code per se, but in viewing the code as a language reflecting common notions.
In this sense i would suggest the following answer:
have a factory (or factory method) where the enum is public only in that factory. In other words create a new factory Human and have all base and derived classes using Human enums. Then the base class can still be Person but Person does not have any enum MALE/FEMALE/etc.. only the Human factory does, and it is not a base class that is subclassed. This would result in code which can be read literaly like this:
Person person("The Name", Human::MALE);
You can also use Gender factory (instead of Human) like this (to be even more literate and separate the inter-dependencies):
Person person("The Name", Gender::MALE);
Note that a base class includes the lowest common denominator that all derived classes must share. So since the derived classes Male Female etc are not supposed to share the gender enum then it should not be part of the base class, but a class or construct in itself which is then used by Person classes and its derivatives.

Answer 4

Simple make the Person class abstract using a protected constructor:
class Person {
public:
enum Gender {
MALE,
FEMALE,
BOTH
};
protected:
// Protected constructor can only be called from subclasses.
Person(std::string name, Gender gender)
: _name(name)
{
switch (gender) { /* processing here */ }
}
protected:
std::string _name;
};
class Male : public Person {
public:
Male(std::string name)
: Person(name, MALE)
{
}
};
If the gender is anyway independent from the Person class, just move it out of the class:
enum Gender {
GenderMale,
GenderFemale,
GenderBoth
};
class Person //...
class Male // ...
You can also encapsulate the Gender into a own class:
class Gender {
public:
enum Type { Male, Female, Both };
Gender(Type type);
Gender(const Gender &copy);
Gender& operator=(Gender &assign);
public:
bool operator==(const Gender &other) const;
// etc.
public:
std::string toString() const;
};