Inheriting a Protected Field from a Base Class

[bydrachen]

I'm trying to implement my java assignment (it's working in java) to C++ but when I tried to inherit from the Animal class, Crocodile class' constructor says "class 'Crocodile' does not have any field named 'name'". How can I fix this problem. I saw that they're using templates but I don't understand the point.

  
#include <iostream>
#include <string>

class Predator
{
    virtual std::string hunt() = 0;
};

class Walker : public Predator
{
    virtual std::string walk() = 0;
};

class Flyer : public Predator
{
    virtual std::string fly() = 0;
};

class Swimmer : public Predator
{
    virtual std::string swim() = 0;
};

class Animal
{
protected:
    std::string name;
public:
    std::string getName() {return name;}
    void setName(std::string name) {this->name = name;}
    
    Animal() : Animal {"Unknown Name"} {}
    Animal(std::string name) : name {name} {}
    
    std::string hunt() {return "";}
    std::string swim() {return "";}
    std::string walk() {return "";}
    std::string fly() {return "";}
};

class Crocodile : public Animal, public Walker, public Swimmer
{
public:
    std::string swim() override 
    {
        return " swims fast in water.";
    }
    
    std::string walk() override 
    {
        return " walks slow on land";
    }
    
    std::string hunt() override 
    {
        return " hunts on land and in water.";
    }
    
    Crocodile() : Crocodile{"Unknown name"} {}
    Crocodile(std::string) : name {name} {}
    
    
};

int main()
{
    
    return 0;
}

[Peter87]

You can not use the member initializer list to initialize members of a base class.

Either set the member in the constructor body

Crocodile(std::string name) { this->name = name; }

or use the member initializer list to pass the name to the Animal constructor

Crocodile(std::string name) : Animal(name) {}

I would recommend the latter.

[seeplus]

Try:

Crocodile(const std::string& nam) : Animal{ nam } {}

Note L31 - setName(). Either pass by const ref or use a std::move when setting name.

void setName(const std::string& nam) {name = nam;}

or

void setName(std::string name) {name = std::move(name);}

PS. Also note that member functions (such as getters) that don't change member data should be marked as const:

[seeplus]

Not sure what the exercise is asking, but consider:

#include <iostream>
#include <string>

class Animal {
private:
	std::string name { "Unknown Name" };

public:
	virtual std::string walk() const = 0;
	virtual std::string fly() const = 0;
	virtual std::string swim() const = 0;
	virtual std::string hunt() const = 0;
	virtual std::string type() const = 0;

	std::string getName() const {
		return name;
	}

	void setName(const std::string& nam) {
		name = nam;
	}

	Animal() {}
	Animal(const std::string& nam) : name { nam } {}
	virtual ~Animal() {}
};

class Crocodile : public Animal {
public:
	using Animal::Animal;

	std::string type() const override {
		return "Crocodile";
	}

	std::string swim() const override {
		return " swims fast in water.";
	}

	std::string walk() const override {
		return " walks slow on land.";
	}

	std::string hunt() const override {
		return " hunts on land and in water.";
	}

	std::string fly() const override {
		return " cannot fly.";
	}
};

class Tiger : public Animal {
public:
	using Animal::Animal;

	std::string type() const override {
		return "Tiger";
	}

	std::string swim() const override {
		return " swims good in water.";
	}

	std::string walk() const override {
		return " runs fast on land.";
	}

	std::string hunt() const override {
		return " hunts on land and in water.";
	}

	std::string fly() const override {
		return " cannot fly.";
	}
};

void display(const Animal& an) {
	std::cout << "For " << an.getName() << '\n';
	std::cout << " is a " << an.type() << '\n';
	std::cout << an.fly() << '\n';
	std::cout << an.swim() << '\n';
	std::cout << an.walk() << '\n';
	std::cout << an.hunt() << '\n';
}

int main() {
	const auto c { Crocodile("ticktock") };
	const auto t { Tiger("tigger") };

	display(c);
	display(t);
}

which displays:

For ticktock
 is a Crocodile
 cannot fly.
 swims fast in water.
 walks slow on land.
 hunts on land and in water.
For tigger
 is a Tiger
 cannot fly.
 swims good in water.
 runs fast on land.
 hunts on land and in water.

[JLBorges]

#include <iostream>
#include <string>

class Predator
{
    public:
        // A class with a virtual function should have a virtual or protected destructor
        // https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rh-dtor
        virtual ~Predator() {}

        virtual std::string hunt() = 0;
};

class Walker : public Predator { virtual std::string walk() = 0; };

class Flyer : public Predator { virtual std::string fly() = 0; };

class Swimmer : public Predator { virtual std::string swim() = 0; };

class Animal
{
    protected: std::string name;

    public:

        std::string getName() const { return name;} // const
        void setName( std::string name ) noexcept { this->name = std::move(name) ; }

        Animal( std::string its_name = "Unknown Name" ) noexcept : name { std::move(its_name) } {}
};

class Crocodile : public Animal, public Walker, public Swimmer
{
    public:

        // inherited constructor: https://www.stroustrup.com/C++11FAQ.html#inheriting
        using Animal::Animal ;

        virtual std::string swim() override { return " swims fast in water."; }
        virtual std::string hunt() override { return " hunts on land and in water."; }
        virtual std::string walk() override { return " walks slow on land."; }
};

int main()
{
    Crocodile anon ; std::cout << anon.getName() << '\n' ; // Unknown Name

    Crocodile alphy( "Alfy Gator" ) ; std::cout << alphy.getName() << '\n' ; // Alfy Gator
}

http://coliru.stacked-crooked.com/a/d1f980748d07d989

[bydrachen]

Thanks for helping, I thought that C++ is inheriting fields like java. But it's just letting the sub-class use it.