C++ multiple inheritance- class method running twice

I found a way around it by dividing printInfo into two different functions: printCommonInfo that runs exclusively from Creature and prints name, age and numOfOffsprings and printSpecificInfo that runs from both Vampire and Werewolf to print only their respective unique members. When I run printInfo from VampireWerewolf, there is a single call to printCommonInfo and I called Vampire::printSpecificInfo() and Werewolf::printSpecificInfo().

Creature:

void printCommonInfo() {
    cout << "===Creature printInfo===" << endl;
    cout << "Name: " << m_name << endl;
    cout << "Age: " << m_age << endl;
    cout << "Number of offsprings: " << m_numOfOffsprings << endl;
}

virtual void printSpecificInfo() = 0;

void printInfo() {
    printCommonInfo();
    printSpecificInfo();
    cout << endl;
}

Vampire:

virtual void printSpecificInfo() override {
    cout << "===Vampire printInfo===" << endl;
    cout << "Light sensitivity: " << m_lightSensitivity << endl;
    if (m_offsprings != nullptr) {
        for (int i = 0; i < m_numOfOffsprings; i++) {
            cout << "- Offspring " << i + 1 << ": " << m_offsprings[i]->m_name << endl;
        }
    }
}

Werewolf:

virtual void printSpecificInfo() override {
    cout << "===Werewolf printInfo===" << endl;
    cout << "Werewolf hours: " << m_werewolfHours << endl;
    cout << "Human hours: " << m_humanHours << endl;
    if (m_offsprings != nullptr) {
        for (int i = 0; i < m_numOfOffsprings; i++) {
            cout << "- Offspring " << i + 1 << ": " << m_offsprings[i]->m_name << endl;
        }
    }
}

VampireWerewolf:

virtual void printSpecificInfo() override {
    Vampire::printSpecificInfo();
    Werewolf::printSpecificInfo();
    cout << "===VampireWerewolf printInfo===" << endl;
    for (int i = 0; i < m_numOfOffsprings; i++) {
        cout << "- Offspring " << i + 1 << endl;
        cout << "Name: " << m_offsprings[i]->getName() << endl;
        cout << "Species: ";
        if (auto* VOffspring = dynamic_cast<Vampire*>(m_offsprings[i])) {
            cout << "Vampire" << endl;
        }
        else if (auto* WOffspring = dynamic_cast<Werewolf*>(m_offsprings[i])) {
            cout << "Werewolf" << endl;
        }
        else if (auto* VWOffspring = dynamic_cast<VampireWerewolf*>(m_offsprings[i])) {
            cout << "Vampire Werewolf" << endl;
        }
    }
}

I would design things quite differently.

Firstly, I would avoid having raw pointers for managing strings, and use std::string.

Second, I would introduce a base class (say) WithOffspring, and have it manage astd::vector<std::shared_ptr<WithOffspring> > (not a pointer to a pointer!) and use it to maintain the collection of offspring. I would impose no constraint on the type or number of offspring (that can be determined by derived classes, if needed). It would also allow multiple parents of any type (say, a Creature descended from two other Creatures of different type).

So the WithOffspring class would look something like

 class WithOffspring
 {
       std:string m_name;
       std::vector<std::shared_ptr<WithOffspring> > m_offspring;

     public:

       virtual void PrintInfo() const = 0;
 };

and then define WithOffspring::PrintInfo() [Yes, this is allowed, and is useful in this case].

void WithOffspring::PrintInfo()
{
    // print name and age

    for (const auto &child : m_offspring)
        if (child.get() != nullptr) child->PrintInfo();
}

There is no need to have a member int m_numOfOffsprings since this may be obtained as m_offspring.size().

Then I would create classes to manage attributes of each particular type of Creature.

 class WerewolfAttributes
 {
     // private members

     public:
         // constructors, etc

        void PrintInfo() const
        {
           // print werewolf attributes
        };

        // other operations/functions/behaviours relevant to a werewolf

 };

 class VampireAttributes
 {
     public:
        // constructors, etc

        void PrintInfo() const
        {
           // print vampire attributes
        };

        // other operations/functions/behaviours relevant to a vampire
 };

Then Creature would be a templated class, derived from WithOffspring.

 template<class Attributes> Creature : public WithOffspring
 {
     private:

        Attributes   m_attrib;

     public:

        Creature(const Attributes &a): WithOffSpring(), m_attrib(a) {}

        void PrintInfo() const
        {
             WithOffspring::PrintInfo();
             m_attrib.PrintInfo(); 
        };
 };

Note that the PrintInfo() function prints the info from the base class (exactly once, which avoids duplication) then the info related to its attributes.

Then individual types of creatures can be specialisations of Creature (assuming Creature provides everything needed for all creature types in its interface).

 using Vampire = Creature<VampireAttributes>;
 using Werewolf = Creature<WereWolfAttributes>;

To handle hybrids, I would create a HybridAttributes class

 template<class AttribA, class AttribB> class HybridAttributes
 {
     private:

         AttribA  parent_a;
         AttribA  parent_b;

     public:

         HybridAttributes(const AttribA &a, const AttribB &b) : parent_a(a), parent_b(b) {}
         
         void PrintInfo() const
         {
             parent_a.PrintInfo()
             parent_b.PrintInfo();
         };
 };

and also create hybrids as specialisations of Creature.

 using WerewolfVampireHybrid = Creature<HybridAttributes<WerewolfAttributes, VampireAttributes> >;

If there is a need for a hybrid of more than two creature types (say, the offspring of two different types of hybrid) then HybridAttributes can be easily modified to use a variadic template (parameter pack)

Creating any creature then has essential steps of create/populate the object representing attributes, then use it to create the particular creature.

   int main()
   {
       VampireAttributes Selene_attributes;
           // populate the attributes
       Vampire Selene(Selene_attributes);

       WerewolfAttributes William_attributes;
           // populate the attributes
       Werewolf William(William_attributes);

       WerewolfVampireAttributes Michael_attributes;
           // populate the attributes
       WerewolfVampireHybrid  Michael(Michael_attributes);
       
       // whatever
  }

Note that

• There is no multiple inheritance, so no need for virtual bases.
• The only class with a pure virtual function is WithOffspring (although that function is defined to provide functionality used by derived classes). All other classes are concrete.

Just remove the line Creature::printInfo();

explanation: by invoking Creature::printInfo() inside overriden printInfo you are calling the base class function inside the overriden function, so it is printing twice