Dog is Animal but list is not list. How to use it safely in a generic/polymorphic function?

Question

It is well-known that a Dog is an Animal but List<Dog> is not List<Animal> (SO question)

Anyway, if we have a function

void f(Animal a1, Animal a2); // Java

void f(Animal * a1, Animal * a2) // C++

We can safely use f() passing in objects of type Dog / Dog*

Now suppose, we want to generalize it as if it has many arguments of type Animal by using a List of them (and not specifically a multiple argument list ... ). The List is not going to be modified by the function, adding a Cat to a List<Dog> for instance.

This:

void fg (List<Animal>); // Java
void fg (List<Animal *>) // C++

is not going to allow a call passing in a List<Dog> / List<Dog*> value.

What is the way to go?

May be in Java

void fg (List<? extends Animal>)

and in C++

template<T>
void fg (List<T>)

Is that ok?
Are there other alternatives?

Thanks.

But, yes, `List extends Animal>` works for a consumer ([but the `List` is considered a producer](http://stackoverflow.com/questions/2723397/java-generics-what-is-pecs)). — Sotirios Delimanolis, Nov 18 '14 at 20:06
This is quite clearly 2 questions (how in Java and how in C++), not 1 question. Please post single questions at a time. — Yakk - Adam Nevraumont, Nov 18 '14 at 21:13
@cibercitizen1 no, it is not. There are things you can reasonably do in one language that cannot reasonably be done in the other. The superficial resemblance of generics and other syntax elements notwithstanding. On top of that, the set of experts in both Java and C++ is going to be small. — Yakk - Adam Nevraumont, Nov 19 '14 at 02:54

score 2 · Answer 1 · answered Nov 18 '14 at 20:25

The list is not going to be modified by the function [...]. What is the way to go?

In Java, declare a parameter of type List<? extends Animal>. This provides a wildcard bounded by Animal type argument to the List generic parameter. You can read that as a list of any unknown type that extends Animal. The fact that it is an unknown type means that the only type that can be used wherever a value of the List's type parameter T is expected is the null type, whose only value is null.

A List<Dog> is a type that fits that description, so is a List<Cat>.

You may use the interface `Iterable extends Animal>` to make it clear it is read only — Matias Cicero, Nov 18 '14 at 20:47

Dog is Animal but list is not list. How to use it safely in a generic/polymorphic function?

1 Answers1