Can inserter/extractor operator overrides be made run-time polymorphic?

[Randy]

Since these operators can't be member functions, and since
friend functions can't be declared virtual, how do I make my
inserters and extractors polymorphic?

--Randy Yates

[Victor Bazarov]

Randy wrote:

Since these operators can't be member functions, and since
friend functions can't be declared virtual, how do I make my
inserters and extractors polymorphic?

Make another member virtual and call it in your operator <<.

struct Base {
virtual ostream& output(ostream& ) const = 0;
};

ostream& operator << (ostream& os, Base const& b) {
return b.output(os);
}

struct Derived : Base { ...

V

[Roland Pibinger]

On 12 Jan 2006 11:25:27 -0800, "Randy" <ya***@ieee.org > wrote:

Since these operators can't be member functions, and since
friend functions can't be declared virtual, how do I make my
inserters and extractors polymorphic?

by operator overloading, eg.

ostream& operator<< (ostream& out, const Base& base);
ostream& operator<< (ostream& out, const Derived& derived);
....

Best wishes,
Roland Pibinger

[Randy]

I get it. Thanks Victor.

--Randy

[Randy]

Really? So if I did that and I had

class Base
{
...
friend ostream& operator<< (ostream& os, const Base& base);
}

and

class Derived : public Base
{
...
friend ostream& operator<< (ostream& os, const Base& base);
}

and then

int main(int argc, char* argv[])
{
Base* b;
b = new Derived;
cout << b;
return 0;
}

the Derived inserter would be used and not the Base inserter?

Thanks Roland.

--Randy

[TB]

Randy sade:

int main(int argc, char* argv[])
{
Base* b;
b = new Derived;
cout << b;
cout << *b;
return 0;
}

TB

[Roland Pibinger]

On 12 Jan 2006 12:20:22 -0800, "Randy" <ya***@ieee.org > wrote:

Really? So if I did that and I had

class Base
{
...
friend ostream& operator<< (ostream& os, const Base& base);
}

and

class Derived : public Base
{
...
friend ostream& operator<< (ostream& os, const Base& base);
friend ostream& operator<< (ostream& os, const Derived& derived);
}

and then

int main(int argc, char* argv[])
{
Base* b;
b = new Derived;
No need to 'new' anything. C++ objects can exist on the stack.
cout << b;
return 0;
}

the Derived inserter would be used and not the Base inserter?

It's just function overloading (like in Java or C#).

Best wishes,
Roland Pibinger

[Randy Yates]

rp*****@yahoo.c om (Roland Pibinger) writes:

On 12 Jan 2006 12:20:22 -0800, "Randy" <ya***@ieee.org > wrote:

Really? So if I did that and I had

class Base
{
...
friend ostream& operator<< (ostream& os, const Base& base);
}

and

class Derived : public Base
{
...
friend ostream& operator<< (ostream& os, const Base& base);

friend ostream& operator<< (ostream& os, const Derived& derived);

Right.

}

and then

int main(int argc, char* argv[])
{
Base* b;
b = new Derived;

No need to 'new' anything. C++ objects can exist on the stack.

cout << b;
return 0;
}

the Derived inserter would be used and not the Base inserter?

It's just function overloading (like in Java or C#).

I'm confused - how can it "just be function overloading?"
This is a run-time selection, not compile-time, right?

I thought the usual usage of the term "function overloading"
was reserved for compile-time overloading, while "polymorphi sm"
was used for run-time overloading. Am I mistaken?
--
% Randy Yates % "Watching all the days go by...
%% Fuquay-Varina, NC % Who are you and who am I?"
%%% 919-577-9882 % 'Mission (A World Record)',
%%%% <ya***@ieee.org > % *A New World Record*, ELO
http://home.earthlink.net/~yatescr

[Randy Yates]

rp*****@yahoo.c om (Roland Pibinger) writes:

[...]
On 12 Jan 2006 12:20:22 -0800, "Randy" <ya***@ieee.org > wrote:

int main(int argc, char* argv[])
{
Base* b;
b = new Derived;

No need to 'new' anything. C++ objects can exist on the stack.

True, but my point was to question run-time polymorphism, not
compile-time polymorphism.
--
% Randy Yates % "My Shangri-la has gone away, fading like
%% Fuquay-Varina, NC % the Beatles on 'Hey Jude'"
%%% 919-577-9882 %
%%%% <ya***@ieee.org > % 'Shangri-La', *A New World Record*, ELO
http://home.earthlink.net/~yatescr

[Jim Langston]

"Randy Yates" <ya***@ieee.org > wrote in message
news:bq******** **@ieee.org...

rp*****@yahoo.c om (Roland Pibinger) writes:

On 12 Jan 2006 12:20:22 -0800, "Randy" <ya***@ieee.org > wrote:

Really? So if I did that and I had

class Base
{
...
friend ostream& operator<< (ostream& os, const Base& base);
}

and

class Derived : public Base
{
...
friend ostream& operator<< (ostream& os, const Base& base);

friend ostream& operator<< (ostream& os, const Derived& derived);

Right.

}

and then

int main(int argc, char* argv[])
{
Base* b;
b = new Derived;

No need to 'new' anything. C++ objects can exist on the stack.

cout << b;
return 0;
}

the Derived inserter would be used and not the Base inserter?

It's just function overloading (like in Java or C#).

I'm confused - how can it "just be function overloading?"
This is a run-time selection, not compile-time, right?

I thought the usual usage of the term "function overloading"
was reserved for compile-time overloading, while "polymorphi sm"
was used for run-time overloading. Am I mistaken?

There is run time and compile time polymorphism AFAIK.