Overloading/Overriding ?

[Susan Baker]

Hello everybody,

I'm new to C++ (I have some C background). I've read up on this topic a
few times but it just dosen't seem to be sinking in.

1. Whats the difference between overloading and overriding?
2. When is one preferable to use as opposed to the other?
3. How are virtual functions related to this topic
(overloading/overriding) - a real world example of using virtual
functions would be very much appreciated.

Thank you

[velthuijsen]

> 1. Whats the difference between overloading and overriding?

overloading is the definition of several functions with the same name
but different arguments and/or a different number of arguments.

void Foo(int);
void Foo(int, int);
void Foo(char);

overriding is writing a different body (in a derived class) for a
function defined in a base class.

class base
{
public:
int Foo()
{
return 1;
}
};

class derived: public base
{
public:
int Foo()
{
return 2;
}
};

2. When is one preferable to use as opposed to the other? They are not exclusive but complimentary. It is possible to have
several overloaded functions in a base class that are overridden in a
derived class. Also overriding only works when a class is derived from
another class where overloading can be used inside a class (or for non
class function definitions).
3. How are virtual functions related to this topic

I'd suggest to read the FAQ at
http://www.parashift.com/c++-faq-lite/index.html

[Jaspreet]

ve*********@hot mail.com wrote:

1. Whats the difference between overloading and overriding?

overloading is the definition of several functions with the same name
but different arguments and/or a different number of arguments.

void Foo(int);
void Foo(int, int);
void Foo(char);

Just to add,
Overloading can be done without usage of classes. However if you are
using a class then these functions have to be in the same class.

Also, the return type is not relevant. Soo, as said above only the
function name should be same while paramter type/number must be
differnt.

[Victor Bazarov]

ve*********@hot mail.com wrote:

1. Whats the difference between overloading and overriding?

overloading is the definition of several functions with the same name
but different arguments and/or a different number of arguments.

void Foo(int);
void Foo(int, int);
void Foo(char);

Overloading _only_ applies to names of functions in the *same scope*.
overriding is writing a different body (in a derived class) for a
function defined in a base class.
.... and *only* if the function in the base class is declared _virtual_
and *only* if the function in the derived class has the same signature.

class base
{
public:
int Foo()
{
return 1;
}
};

class derived: public base
{
public:
int Foo()
{
return 2;
}
};
Here you have an example of name hiding since 'base::Foo' isn't virtual.

2. When is one preferable to use as opposed to the other?

They are not exclusive but complimentary. It is possible to have
several overloaded functions in a base class that are overridden in a
derived class.

This is incorrect. All functions in the derived class _hide_ the base
class functions with the same name, except in the case of virtual ones,
which override the base class functions with the _same_signature _.

Also overriding only works when a class is derived from
another class where overloading can be used inside a class (or for non
class function definitions).

Overloading only relates to the functions in the same _scope_, i.e. in
the same class or outside of any class.

3. How are virtual functions related to this topic

I'd suggest to read the FAQ at
http://www.parashift.com/c++-faq-lite/index.html

It's always a GOOD IDEA(tm).

V

[Greg]

Victor Bazarov wrote:

ve*********@hot mail.com wrote:

1. Whats the difference between overloading and overriding?

overloading is the definition of several functions with the same name
but different arguments and/or a different number of arguments.

void Foo(int);
void Foo(int, int);
void Foo(char);

Overloading _only_ applies to names of functions in the *same scope*.

overriding is writing a different body (in a derived class) for a
function defined in a base class.

... and *only* if the function in the base class is declared _virtual_
and *only* if the function in the derived class has the same signature.

class base
{
public:
int Foo()
{
return 1;
}
};

class derived: public base
{
public:
int Foo()
{
return 2;
}
};

Here you have an example of name hiding since 'base::Foo' isn't virtual.

2. When is one preferable to use as opposed to the other?

They are not exclusive but complimentary. It is possible to have
several overloaded functions in a base class that are overridden in a
derived class.

This is incorrect. All functions in the derived class _hide_ the base
class functions with the same name, except in the case of virtual ones,
which override the base class functions with the _same_signature _.

But the signature of a virtual function override can declare a
different return type than the function it overrides, provided that the
return type that it does declare is a virtual subclass of the return
type of the function declared in the base. [assuming compilation with a
C++ compiler that supports "covariant return types"]

Greg

[Steven T. Hatton]

Greg wrote:

But the signature of a virtual function override can declare a
different return type than the function it overrides, provided that the
return type that it does declare is a virtual subclass of the return
type of the function declared in the base. [assuming compilation with a
C++ compiler that supports "covariant return types"]

Greg

Care to provide ISO/IEC 14882:2003 chapter and verse on that? Not that I
doubt what you assert, I would simply like to see how it's actually stated
in the Standard.
--
If our hypothesis is about anything and not about some one or more
particular things, then our deductions constitute mathematics. Thus
mathematics may be defined as the subject in which we never know what we
are talking about, nor whether what we are saying is true.-Bertrand Russell

[Victor Bazarov]

Greg wrote:

Victor Bazarov wrote:

ve*********@hot mail.com wrote:

1. Whats the difference between overloading and overriding?
overloading is the definition of several functions with the same
name but different arguments and/or a different number of arguments.

void Foo(int);
void Foo(int, int);
void Foo(char);

Overloading _only_ applies to names of functions in the *same scope*.

overriding is writing a different body (in a derived class) for a
function defined in a base class.

... and *only* if the function in the base class is declared
_virtual_ and *only* if the function in the derived class has the
same signature.

class base
{
public:
int Foo()
{
return 1;
}
};

class derived: public base
{
public:
int Foo()
{
return 2;
}
};

Here you have an example of name hiding since 'base::Foo' isn't
virtual.

2. When is one preferable to use as opposed to the other?

They are not exclusive but complimentary. It is possible to have
several overloaded functions in a base class that are overridden in
a derived class.

This is incorrect. All functions in the derived class _hide_ the
base class functions with the same name, except in the case of
virtual ones, which override the base class functions with the
_same_signature _.

But the signature of a virtual function override can declare a
different return type than the function it overrides, provided that
the return type that it does declare is a virtual subclass of the
return type of the function declared in the base. [assuming
compilation with a C++ compiler that supports "covariant return
types"]

Yes. Covariant return types are part of the definition of "the same
signature" when talking about virtual functions. So, I don't really
understand the "But" in the beginning of your reply.

V

[Victor Bazarov]

Steven T. Hatton wrote:

Greg wrote:

But the signature of a virtual function override can declare a
different return type than the function it overrides, provided that
the return type that it does declare is a virtual subclass of the
return type of the function declared in the base. [assuming
compilation with a C++ compiler that supports "covariant return
types"]

Greg

Care to provide ISO/IEC 14882:2003 chapter and verse on that? Not
that I doubt what you assert, I would simply like to see how it's
actually stated in the Standard.

Can't you search your copy of the Standard for "covariant" ?

[Steven T. Hatton]

Victor Bazarov wrote:

Steven T. Hatton wrote:

Greg wrote:

But the signature of a virtual function override can declare a
different return type than the function it overrides, provided that
the return type that it does declare is a virtual subclass of the
return type of the function declared in the base. [assuming
compilation with a C++ compiler that supports "covariant return
types"]

Greg

Care to provide ISO/IEC 14882:2003 chapter and verse on that? Not
that I doubt what you assert, I would simply like to see how it's
actually stated in the Standard.

Can't you search your copy of the Standard for "covariant" ?

I don't see the part about requiring the return type to be virtual.

"The return type of an overriding function shall be either identical to the
return type of the overridden function or covariant with the classes of the
functions. If a function D::f overrides a function B::f, the
return types of the functions are covariant if they satisfy the following
criteria:
? both are pointers to classes or references to classes98)
? the class in the return type of B::f is the same class as the class in the
return type of D::f, or is an
unambiguous and accessible direct or indirect base class of the class in
the return type of D::f
? both pointers or references have the same cv-qualification and the class
type in the return type of D::f
has the same cv-qualification as or less cv-qualification than the class
type in the return type of B::f.
If the return type of D::f differs from the return type of B::f, the class
type in the return type of D::f
shall be complete at the point of declaration of D::f or shall be the class
type D. When the overriding
function is called as the final overrider of the overridden function, its
result is converted to the type returned
by the (statically chosen) overridden function (5.2.2)."

--
If our hypothesis is about anything and not about some one or more
particular things, then our deductions constitute mathematics. Thus
mathematics may be defined as the subject in which we never know what we
are talking about, nor whether what we are saying is true.-Bertrand Russell

[Victor Bazarov]

Steven T. Hatton wrote:

Victor Bazarov wrote:

Steven T. Hatton wrote:

Greg wrote:

But the signature of a virtual function override can declare a
different return type than the function it overrides, provided that
the return type that it does declare is a virtual subclass of the
return type of the function declared in the base. [assuming
compilation with a C++ compiler that supports "covariant return
types"]

Greg

Care to provide ISO/IEC 14882:2003 chapter and verse on that? Not
that I doubt what you assert, I would simply like to see how it's
actually stated in the Standard.
Can't you search your copy of the Standard for "covariant" ?

I don't see the part about requiring the return type to be virtual.

Come again... How can a return type be virtual?
[...]

V