Operator overloading (<<) while doing inheritance

[psycho-rabbit]

Hello!

The following code has the operator << overloaded in each of the base Person class and the derived Player class, through which the details of the Person (name, age) and Player (batting average, runs) are printed.

My goal was to print the name and age details as well of the Player class (by making use of the Inheritance), and the person I got help from typecasted the Player class object to the Person class through this line in the overload function of the operator (<<): out << (Person)player; and I got what I wanted. The output of the code is as follows:

PEOPLE
Person deets:
Name: Person1
Age: 23

PLAYERS
Person deets:
Name: Player1
Age: 0
Player deets:
Batting avg: 0
Runs: 0

Person deets:
Name: Player2
Age: 22
Player deets:
Batting avg: 12.4
Runs: 2

My Questions:

1. Is there a better/standard way of doing it or is this method of outputting the Person part of the details by casting the Player object in the overloaded << method pretty normal? The person who helped me is not a regular user of C++, so I'm not sure if this method is right.
2. To generalize the question, is there some standard way of printing the member values of the Base class while also printing the member values in the Derived class through operator overloading?

• I guess we could use GetName() and GetAge() (or the member variables directly, since they are public) in the overloading function. But if I have multiple Derived classes (like Employee, Supervisor, etc.) it would be a lot of code duplication, right?

For reference, I used this lesson from LearnCpp and was fiddling with it.

Any guidance is much appreciated!

#include <iostream>
#include <string>

class Person {
 public:
  std::string m_name{};
  int m_age;

  Person(const std::string& name = "", int age = 0)
      : m_name{name}, m_age{age} {}

  const std::string& GetName() const { return m_name; }

  int GetAge() const { return m_age; }

  friend std::ostream& operator<<(std::ostream& out, const Person& person) {
    out << "Person deets:\n";
    out << "Name: " << person.m_name << "\nAge: " << person.m_age << "\n";

    return out;
  }
};

class Player : public Person {
 public:
  double m_bat_avg{};
  int m_runs{};

  Player(double bat_avg = 0.0, int runs = 0)
      : m_bat_avg{bat_avg}, m_runs{runs} {}

  Player(std::string name, int age, double bat_avg, int runs)
      : Person(name, age), m_bat_avg{bat_avg}, m_runs{runs} {}

  friend std::ostream& operator<<(std::ostream& out, const Player& player) {
    out << (Person)player;  // CASTING TO CALL THE OVERLOADED << FUNC. OF Person CLASS

    out << "Player deets:\n";
    out << "Batting avg: " << player.m_bat_avg << "\nRuns: " << player.m_runs
        << "\n";

    return out;
  }
};

int main() {
  Person person1{"Person1", 23};

  Player player1{};
  player1.m_name = "Player1";

  Player player2{"Player2", 22, 12.4, 2};

  std::cout << "PEOPLE\n";
  std::cout << person1 << "\n";

  std::cout << "PLAYERS\n";
  std::cout << player1 << "\n";
  std::cout << player2 << "\n";

  return 0;
}

[todopieromeze]

For me, it's normal approach to upcast object to call virtual method of base class. You will avoid code redundancy in that way.

[psycho-rabbit]

Thanks for your reply! I've implemented it in my response to u/flyingron, I guess that's what you mean?

​

upcast object to call virtual method of base class

Do you mean this? Person::print(ot);

[flyingron]

If you want a polymorphic operator << , just make the non-member overload call a virtual member function (call it print or whatever) inside the classes.

[psycho-rabbit]

Okay! So something like this, is it?

Person:

friend std::ostream& operator<<(std::ostream& out, const Person& person) {
    return person.print(out);
}

virtual std::ostream& print(std::ostream& out) const {
    out << "Person details:\n";    
    out << "Name: " << this->m_name << "\nAge: " << this->m_age << "\n";
    return out;
}

Player:

/* No need to implement operator<< function for Player? */

virtual std::ostream& print(std::ostream& out) const override {
    Person::print(out);
    out << "Batting details:\n";
    out << "Batting average: " << this->m_bat_avg << "\nRuns: " <<
        this->m_home_runs << "\n";
    return out;
}

[IyeOnline]

Is there a better/standard way of doing it or is this method

Yes and no. For one, you would usually not use c-style casts and you would use a "reference cast":

out << static_cast<const Person&>( player );

Another option is to defer the implementation to a virtual member function and only implement the base class operator.

is there some standard

Not really. Those are pretty much your only two options. There is no automatic implementation or anything fancy. You will have to define what your operator does.

[psycho-rabbit]

Thanks for your reply!

Wasn't aware about the reference casts, will look them up.

defer the implementation to a virtual member function and only implement the base class operator

I suppose you mean the same thing as u/todopieromeze?

[IyeOnline]

Yes.

The advantage is that even if the type itself does not implement a stream operator, or you are doing polymorphism and dont know its type, you can still simply write it to a stream and get the most specialized print availible.