question about polymorphism

[Locia]

What are the techniques used to implement parametric polymorphism in
C++?

A Polymorphic method can be virtual?

[Victor Bazarov]

Locia wrote:

What are the techniques used to implement parametric polymorphism in
C++?
[Public] Inheritance and virtual functions.
A Polymorphic method can be virtual?

Run-time polymorphism is only achieved through virtual functions.

V

[E. Robert Tisdale]

Locia wrote:

What are the techniques used
to implement parametric polymorphism in C++?

A Polymorphic method can be virtual?

The term "polymorphism"
can be applied to lots of different things in C++.

First, take a look at
The Free On-Line Dictionary Of Computing (FOLDOC)

http://wombat.doc.ic.ac.uk/foldoc/

and search for

polymorphism

C++ supports "ad-hoc polymorphism" (function and operator overloading),
"compile-time polymorphism" (class templates) and
"run-time polymorphism" (virtual functions).
Run-time polymorphism is invariably implemented using jump-tables --
virtual function tables
which contain the addresses of the actual functions to be called.
In general, the actual function to be called is not known
until the virtual function is invoked
so this is sometimes called "late-binding".

[Peter_Julian]

"Locia" <ro********@yahoo.it> wrote in message
news:11**********************@g47g2000cwa.googlegr oups.com...
| What are the techniques used to implement parametric polymorphism in
| C++?
|
| A Polymorphic method can be virtual?
|

Late binding relies on virtual member functions. That means that the
behaviour called depends on the actual object (or derivative thereof) at
run-time and where the virtual member function(s) is/are defined in the
hierarchy.

If what you are wondering is how C++ achieves this: look up the subject
of the vtable. The vtable is only generated if at least one member
function or d~tor is implemented as virtual.

Example:

#include <iostream>

class B
{
public:
B() { std::cout << "B()\n"; }
virtual ~B() { std::cout << "~B()\n"; }
virtual void foo() { std::cout << "B::foo()\n"; }
void bar() { std::cout << "B::bar()\n"; }
};

class D : public B
{
public:
D() { std::cout << "D()\n"; }
~D() { std::cout << "~D()\n"; }
void foo() { std::cout << "D::foo()\n"; }
};

// note: both ~D() and void D::foo() are inherently virtual

int main()
{
std::cout << "--- B b ---\n";
B b;
b.foo();

std::cout << "--- D d ---\n";
D d;
d.foo();
d.bar();

std::cout << "--- new D ---\n";
B *p_b = new D;
p_b->foo(); // polymorphic upcast
delete p_b;

std::cout << "--- stack unwind ---\n";

return 0;
}

/*

--- B b ---
B()
B::foo()
--- D d ---
B()
D()
D::foo()
B::bar()
--- new D ---
B()
D()
D::foo() // upcast
~D()
~B()
--- stack unwind ---
~D()
~B()
~B()
*/

[Alf P. Steinbach]

* Locia:

What are the techniques used to implement parametric polymorphism in
C++?
I had to google for the meaning of "parametric polymorphism".

And found it in <url:
http://en.wikipedia.org/wiki/Polymorphism_(computer_science)>.

It just means generics.

In C++ generics are implemented using the 'template' mechanism. This
mechanism implements _unrestricted_ genericity, which means that some
constructs available with more restricted genericity schemes (e.g. in Eiffel)
are not possible. In particular, you can not have a generic virtual function.

Unfortunately one of the authors of the Google article didn't know anything
about the subject, so currently the Google article states "Some argue that
templates should be considered an example of parametric polymorphism, though
instead of actually reusing generic code they rely on macros to generate
specific code (which can result in code bloat)" which is 100% incorrect.

A Polymorphic method can be virtual?

That is a meaningless question.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[red floyd]

Alf P. Steinbach wrote:

Unfortunately one of the authors of the Google article didn't know anything
about the subject, so currently the Google article states ...

You mean the WikiPedia article.

[John Carson]

"Alf P. Steinbach" <al***@start.no> wrote in message
news:43****************@news.individual.net

Unfortunately one of the authors of the Google article didn't know
anything about the subject, so currently the Google article states
"Some argue that templates should be considered an example of
parametric polymorphism, though instead of actually reusing generic
code they rely on macros to generate specific code (which can result
in code bloat)" which is 100% incorrect.

Is is the use of the word macro that you object to or the failure to clearly
distinguish source code bloat from object code bloat --- or both or
something else?
--
John Carson

[Alf P. Steinbach]

* John Carson:

"Alf P. Steinbach" <al***@start.no> wrote in message
news:43****************@news.individual.net

Unfortunately one of the authors of the Google article didn't know
anything about the subject, so currently the Google article states
"Some argue that templates should be considered an example of
parametric polymorphism, though instead of actually reusing generic
code they rely on macros to generate specific code (which can result
in code bloat)" which is 100% incorrect.

Is is the use of the word macro that you object to or the failure to clearly
distinguish source code bloat from object code bloat --- or both or
something else?

Both of those, + "Some argue that...", + failure to distinguish concept from
language from implementation (e.g., the language has 'export'), and so on; the
worst is perhaps the supposition that some technical drawback, whether it
exists or not, has anything to do with the categorization.
Note: as Red Floyd helpfully pointed out, I did mean the _Wikipedia_ article.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Locia]

> "compile-time polymorphism" (class templates) and

Can you explain me how c++ implement templates?