Re: Slicing with ?: operator - expected?
On 7/6/2011 10:41 AM, Bart van Ingen Schenau wrote:
Victor Bazarov Wrote:
Hello All,
Here is the code:
class Foo {
public:
virtual void bar() const = 0;
};
#include<ostream>
#include<iostream>
class Foo1 : public Foo {
void bar() const { std::cout<< "Foo1::bar\n"; }
};
class Foo2 : public Foo {
void bar() const { std::cout<< "Foo2::bar\n"; }
};
void foo(const Foo* pFoo)
{
(pFoo ? *pFoo : Foo1()).bar(); // line 19 ************
}
void blah(const Foo& rFoo)
{
foo(&rFoo);
}
int main()
{
blah(Foo2());
}
Line 19 is the line in question. Could you please interpret it for me?
It seems to skip the virtual function dispatch, and attempt to call
the pure function. The common type of *pFoo and Foo1() is 'class
Foo', and the compiler seems to resolve the 'bar' statically, without
the use of virtual function mechanism, as if there is an instance of
class Foo /sliced/ from both original objects. Is that supposed to
happen?
Yes, that is supposed to happen.
The conditional operator (?:) is defined to only yield rvalues, and never a
reference.
I don't think it's correct. If both expressions after the '?' are
lvalues of the same type, the resulting expression should be an lvalue.
Consider:
int x, y; // zero-initialized
int& getx() { return x; }
int& gety() { return y; }
void increment(int& i) { ++i; }
int main(int argc, char **argv)
{
increment(argc % 2 ? getx() : gety());
}
Or do you think it shouldn't compile?
This means that objects of class-type indeed get sliced by the ?: operator.
Standard chapter and verse would be helpful.
The behaviour of the conditional operator is described in section 5.16
[expr.cond], where especially the last paragraph is of relevance here.
Thanks!
V
Bart v Ingen Schenau
V
--
I do not respond to top-posted replies, please don't ask