How to use dynamic_cast in if statement

So I've got a simple task to do. There are 3 classes derived from one base class. They're quite simple and will be provided below.
What I need to do is create a new class called PolymorphicAnimal, that'll be able to behave just as any other animal derived from the Animal base class.
To be exact, all they need to do is display the right text after method SoundOff is called. I'm guessing I need to use dynamic_cast here. My question is, what's the right syntax for using dynamic_cast as an if statement, and do all the derived classes need to have at least one virtual method as well?

PolymorphicAnimal

animal

Animal

SoundOff

dynamic_cast

dynamic_cast

if

#include "stdafx.h"
#include <iostream>
#include <string>

class Animal {
public:
virtual std::string SoundOff() = 0;
};

class Dog : public Animal {
std::string SoundOff() override { return "Woof"; }
};

class Cat : public Animal {
std::string SoundOff() override { return "Meow"; }
};

class Cow : public Animal {
std::string SoundOff() override { return "Muu"; }
};

class PolymorphicAnimal : public Animal {
std::string sound;
public:
PolymorphicAnimal(const Animal &a) {
if(std::dynamic_cast<Cat*>(a))
}
};


The line if(std::dynamic_cast... generates compiler errors:

if(std::dynamic_cast...

syntax error '<', illegal token on the right side of :: and expected an identifier

syntax error '<', illegal token on the right side of ::

expected an identifier

if(std::dynamic_cast<Cat*>(a))

dynamic_cast

&

a

if(std::dynamic_cast<Cat*>(&a)

4 Answers
4

In C++ you can declare a variable in the conditional of an if, which is a powerful feature that you can exploit here. So,

if

if (auto kitty = dynamic_cast<const Cat*>(&a)){
// kitty is not nullptr
}


Notes:

dynamic_cast

std::

dynamic_cast

bool

const

const

const auto kitty

const Cat

<const Cat*>

dynamic_cast

dynamic_cast

const_cast

dynamic_cast is almost always a hack.

dynamic_cast

Why don't you add another virtual method to Animal, and then have Dog, Cat and Cow override it in the usual way? Or don't you control these classes?

Animal

Dog

Cat

Cow

dynamic_cast

Whereas virtual methods or visitor might be more appropriated, you might use something like:

PolymorphicAnimal(const Animal &a) {
if (const auto* cat = std::dynamic_cast<const Cat*>(&a)) {
// use cat
} else if (const auto* dog = std::dynamic_cast<const Dog*>(&a)) {
// use dog
} // ...
}


It is very unclear what exactly the PolymorphicAnimal should do. Somehow you need to tell PolymorphicAnimal how to behave, right? So, I'm guessing it's more like a Factory than a derived class.

Something like this:

class PolymorphicAnimal : Animal
{
private:
Animal *animal;
public:
PolymorphicAnimal(int type)
{
if (type == Type_Cat) // Type_Cat is an enum for example
{
animal = new Cat();
}
// ...add other types here
}
std::string SoundOff()
{
return animal->SoundOff();
}
}


Normally, you shouldn't need to do if (something dynamic_cast something) in a normal program.

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.