Thread: [Newbie]How to implement type inheritance?

An Animal can be a Dog, Fish, Bird, etc

A Dog can be a Shepherd, Terrier, etc
A Fish can be a Guppy, Salmon, etc


getAnimal(InputStream) reads some input from the input stream and returns an object of type Animal.
A checking function repeatedly calls getAnimal and checks what kind of Animal is returned(Dog, Fish, etc), then checks the specific type of animal(Guppy, Salmon, etc), and does some computation.

How should the datatype Animal be implemented? An enum/struct/typedef/class? How then would I go about implementing the checking function? I was thinking of something like the following:

Code:

Animal a = getAnimal(inputStream);
switch (a) {
	case DOG:
		do something
		case SHEPERD:
			do something:
		case TERRIER:
			do something:
	case FISH:
		do something
		case GUPPY:
			do something:
		case SALMON:
			do something:
	....
}

The syntax and case construct is slightly broken but I hope you get the idea.

You're doing this completely wrong.

If you don't have enough input to construct an animal (or Dog or whatever), then don't construct one. Constructors aren't supposed to fail.

So either:
1. Write constructors that never fail.
2. Or throw an exception when they do fail.

For the other part of this question, dynamic binding can remove the problem of run time type identification in a number of cases. This is when you take a pointer of the parent type and cast it to the type you're working with.

Animal *pet = getAnimal(cin);
Dog *myDog = dynamic_cast<Dog *>(pet);

or

Fish *myFish = dynamic_cast<Fish *>(pet);

Naturally, dynamic_cast can fail and will fail if A* is not controvertible to B*, so you still need to make sure it works.

Originally Posted by King Mir

getAnimal is not a constructor. That not a problem here.

This undermines the entire purpose of making Dog and fish a subclass of animal. Don't use dynamic cast for something like this. If you think you need dynamic cast, think again, cause your probably wrong.

Uh huh but I think you are wrong, too. If animal is an abstract base class, then stack objects of it should not compile (because they're abstract). So your code doesn't work either. OTOH pointers to animal, being a different type than animal, are OK. But some type of cast is necessary between animal* and any of its' children, perhaps I picked the wrong one.

If dynamic_cast is really wrong here, please explain why. Anyone.

Originally Posted by whiteflags

But some type of cast is necessary between animal* and any of its' children, perhaps I picked the wrong one.

Why would a cast be necessary? The king at 12:28 gave a perfectly good example with no casting whatsoever. That's the point of virtual, after all, is to pick the right function based on type....

Originally Posted by laserlight

The problem is that King Mir's example is wrong, precisely because of the point that whiteflags raised: animal is of type Animal, which is an abstract base class, instead of type Animal& or (smart) pointer to Animal. Consequently, there will be a compile error, and if we change the type to a concrete base class, there would be no polymorphism.

Man man man. Of course that's what I wanted to see, so that's what I saw.

All right, try again. The OP says "getAnimal(InputStream) reads some input from the input stream and returns an object of type Animal." If that function returns an echte Animal object, then I think we're sunk no matter what if we try to be polymorphic, so we would have to store the type and have some unnecessary class variables (or, if we're feeling rambunctious, maybe a union). If that function returns by reference, then we can assign to a reference and everybody's happy (I think).