I think I'm confusing name hiding with function overriding - c++

Question

I'm confused...it seems that both things do the same thing.
In this first code, I believe that the derived classes are hiding the function names of the base classes.
#include <iostream>
using namespace std;
class Quadrilateral {
public:
void greeting() {
std::cout << "i am a quadrilateral" << std::endl;
}
};
class Square : public Quadrilateral {
public:
void greeting() {
std::cout << "i am a square" << std::endl;
}
};
class Trapezoid : public Quadrilateral {
public:
void greeting() { //hides greeting from quadrilateral function
std::cout << "Hi I'm a Trapezoid" << std::endl;
}
};
int main()
{
Trapezoid tz;
tz.greeting();
}
This seems to have the same exact result: [here they are being overriden because it is virtual in the base class]
#include <iostream>
using namespace std;
class Quadrilateral {
public:
virtual void greeting() {
std::cout << "i am a quadrilateral" << std::endl;
}
};
class Square : public Quadrilateral {
public:
void greeting() {
std::cout << "i am a square" << std::endl;
}
};
class Trapezoid : public Quadrilateral {
public:
void greeting() { //hides greeting from quadrilateral function
std::cout << "Hi I'm a Trapezoid" << std::endl;
}
};
int main()
{
Trapezoid tz;
tz.greeting();
}
So I guess I'm just really confused as to...what is the difference? Or what is the point of making it virtual in the base class if it's just gonna have the same effect in this situation?

Answer 1

Virtual functions are used to call the overriden function from the base class pointer.
With your second example you can get the same result if you do the following in the main()
Trapezoid tz;
Quadrilateral *base = &tz;
base->greeting(); // it will print "Hi I'm a Trapezoid"
And this is the difference with the first example: possibility to call derived function from the base class pointer.
If you not override the virtual base function in the derived class, then the base virtual function will be called.
Usage example.
Imagine, that you want to create many objects with the base class Quadrilateral (for example five squares and three trapezoids):
Square sq1, sq2, sq3, sq4, sq5;
Trapezoid tz1, tz2, tz3;
Now, at some point in your code you want to go throw all of this objects and call the abstract function (in your case greeting()). So, with help of virtual function you can do it very simple: put all objects in an array of pointers and call the propper function. Here is how:
Quadrilateral *base[8] = {&sq1, &sq2, &sq3, &sq4, &sq5, &tz1, &tz2, &tz3};
for (int i = 0; i < 8; i++) {
base[i]->greeting();
}
In the output you will recieve five times "i am a square" and three times "Hi I'm a Trapezoid".
It comes vary helpfully when you create all different shapes (for example with different dimensions, properties) and want to go throw all of this objects and call, for example, calc() function to make an calculation individualy for each shape.
I hope this helps you.

Answer 2

In C++, if you declare/have a struct or class variable like in this example, the compiler trivially knows its type and always calls the correct function, irrespective of virtual/not.
Virtual functions only matter when dealing with pointers or references.
Try adding this after you existing code, before the end of main:
Quadrliateral *q = &t;
q->greeting();
And you will find it matters a lot whether all the greetings functions are virtual or not.

Answer 3

First of all, format your code please!
First example
class Quadrilateral {
public:
void greeting() {
std::cout << "i am a quadrilateral" << std::endl;
}
};
class Square : public Quadrilateral {
void greeting() {
std::cout << "i am a square" << std::endl;
}
};
class Trapezoid : public Quadrilateral {
public:
void greeting() { //hides greeting from quadrilateral function
std::cout << "Hi I'm a Trapezoid" << std::endl;
}
};
int main() {
Trapezoid tz;
tz.greeting();
}
In this example is totally normal that Trapezoid.greeting() hides Quadrilateral.greeting(): it's an overriding (same method name, same return, same parameters (none)).
Second example
class Quadrilateral {
public:
virtual void greeting() {
std::cout << "i am a quadrilateral" << std::endl;
}
};
class Square : public Quadrilateral {
void greeting() {
std::cout << "i am a square" << std::endl;
}
};
class Trapezoid : public Quadrilateral {
public:
void greeting() { //hides greeting from quadrilateral function
std::cout << "Hi I'm a Trapezoid" << std::endl;
}
};
int main() {
Trapezoid tz;
tz.greeting();
}
The same. You create an objcet of static-type Trapezoid that have dynamic-type Trapezoid. So tz.greeting will print "I'm a trapezoid" because greeting() is an override.
Third example
class Shape {
public:
virtual void greeting() {
std::cout << "Shape" << std::endl;
}
};
class Square : public Shape {
/* override method greeting() of Shape class */
void greeting() {
std::cout << "Square" << std::endl;
}
};
class Triangle : public Shape {
public:
/* override method greeting() of Shape class */
void greeting() {
std::cout << "Triangle" << std::endl;
}
};
int main() {
Shape* shape = new Triangle();
shape->greeting(); /* prints "Triangle" */
shape = new Square();
shape->greeting(); /* prints "Square" */
}