Thread: Polymorphism - "pointers" or "references"?

Hi,
I have a little problem about "polymorphism" in c++.

Just for beginning:
=================================================
In "Java" language, there are all the objects (or types) accessed by pointers (we don't write them manually by hand but "they are there").
For example in Java, this code:

Code:

Shape shape;

means exactly the same as this code in c++:

Code:

Shape* shape;

=================================================



And when I was using polymorphism "feature" in Java, I wrote this:

Code:

Shape shape = new Circle();

which in c++ code would look like this:

Code:

Shape* shape = new Circle;

That's fine, all is great and I understand it.


But there is another thing (what is not in Java): "references".
I have read in various articles that I should prefer references before pointers (where it is possible) because it can improve efficiency and readability of the code (you can correct me if I am wrong).
So I have used to references and now I use them where it is possible.

But the problem is with polymorphism. If I want to use references also with polymorphism, I would write something like this:

Code:

Circle circle;
Shape& shape = circle;

But there another problem arises: "object slicing" (I don't want to explain this problem here, let's say that it is just a problem).


And after this long message, here is my question:
When I use polymorphism feature in c++, is it better to use pointers or references (or plain values) to achieve it (I think, the best thing would probably be to use pointers)?


Thanks in advance.

Java's implementation is almost a cross between pointers and references, if this makes it easier to think about it. In C++, references can't be NULL, but in Java they can be null. In C++, the programmer can force a pointer to point to garbage (even if this isn't supposed to be allowed in many cases), but in Java, you can only explicitly set your reference to a valid object or to null.

I wouldn't be worrying too badly about how to go about this. Use pointers in C++ where they make sense. Use references in C++ where they make sense.

Thanks for answers.
So the best solution for me is probably what "medievalelks" said:
"I usually store (smart) pointers to the base in containers, so I use pointers in that case. When passing to a function, I use references."

Originally Posted by Petike

So the best solution for me is probably what "medievalelks" said:
"I usually store (smart) pointers to the base in containers, so I use pointers in that case. When passing to a function, I use references."

Yes, but note that sometimes it makes sense to allow an argument to be "optional", in which case a (smart) pointer parameter would be more appropriate than a reference parameter so that a null pointer can be passed. (Of course, in terms of literally optional arguments, a default argument can still be provided for a const reference parameter.)

Originally Posted by Petike

But there another problem arises: "object slicing" (I don't want to explain this problem here, let's say that it is just a problem).

Slicing only occurs if you try to store (or pass) a copy of a polymorphic type.
If you store or pass the objects by reference or by pointer, no slicing will occur.
So you can safely pass objects via reference without worry of slicing.

Originally Posted by Elysia

Slicing only occurs if you try to store (or pass) a copy of a polymorphic type.
If you store or pass the objects by reference or by pointer, no slicing will occur.
So you can safely pass objects via reference without worry of slicing.

Wow,
so that is great, I thought that only in the case of "pointers" (as function arguments) the slicing doesn't occur.

Thus, if I understand it well, when using the reference technique...

Code:

class Shape {};
class Circle : public Shape {};

// Function argument as reference...
void polymorphicFunction(const Shape& shape)
{
    /* Some code */
}

int main()
{
    Circle circle;
    Shape& someShape = circle;

    // Pass the circle "as a shape" to the function
    polymorphicFunction(circle);
}

...no object slicing will occur?


Thanks.

No slicing will occur.
This will cause slicing:

Code:

class Shape {};
class Circle : public Shape {};

// Function argument as reference...
void polymorphicFunction(Shape shape)
{
    /* Some code */
}

int main()
{
    Circle circle;

    // Pass the circle "as a shape" to the function
    polymorphicFunction(circle);
}

Once more many thanks for answers.