Inheritance, selective method execution - c++

Question

I watched a video that can be found at
https://www.youtube.com/watch?v=4F72VULWFvc and I really liked some of the concept for the cases that presented. But I am working with linked list and need selective method execution, for example:
#include <stdio.h>
class A {
public:
A() : next(0) {
if (head == 0) {
head = this;
} else {
A* step = head;
while (step->next != 0) {
step = step->next;
}
step->next = this;
}
}
virtual ~A() {
if (head == this) {
head = 0;
} else {
A* step = head;
while (step->next != this) {
step = step->next;
}
step->next = next;
}
}
virtual void foo() {
// Do nothing...
}
static A* head;
A* next;
};
class B : public A {
public:
B() {}
virtual ~B() {}
virtual void foo() {
printf("function foo\n");
}
};
A* A::head = 0;
int main() {
A a_cls;
B b_cls;
A* step = A::head;
while (step != 0) {
step->foo();
step = step->next;
}
return 0;
}
After instantiating all of the objects, the method foo() of objects of class B need to execute. To achieve this, virtual method foo() is added to class A, with empty body, virtual void foo() {}, and in class B, code is added to the method foo() body.
It works but I do not like it, in the main function it looks like you are doing something at each node, but you are not, it almost feels like a NULL pointer. Is there another creative solution for this?
Note: I am using C++03.

Answer 1

Check out dynamic_cast as a way to check for a particular derived type and only call foo on objects of class B (or a class derived from B):
int main() {
A a_cls;
B b_cls;
A* step = A::head;
B* step_b = 0;
while (step != 0) {
step_b = dynamic_cast<B *>(step);
if (step_b != 0) {
step_b->foo();
}
step = step->next;
}
return 0;
}
This way, there's no need to define an empty foo method on A. Try it out on ideone.

Answer 2

It works but I do not like it, in the main function it looks like you
are doing something at each node, but you are not
In fact you are doing something at each node. What you are doing is the decision to do nothing. Decisions are generally not free and you haven't told us enough about the application to justify the guess that it could be restructured in a way that the decision could be effectively free (made at compile time).
If the decision to do nothing can't be free, then implementing that decision as a call to a virtual function is nearly as low in cost as that decision could possibly be.

Answer 3

It works but I do not like it, in the main function it looks like you are doing something at each node, but you are not, it almost feels like a NULL pointer. Is there another creative solution for this?
Make sure that your base class is a pure abstract class. That way, every call to step->foo(); will most likely do something.
Here's a bare bones example of a heterogeneous list. List::Node is an abstract base class. List::Node::print() is a virtual member function that is implemented only in the concrete classes. List is able to use a generic algorithm to step through the Nodes without having explicit knowledge of the kinds of Nodes it contains.
#include <iostream>
#include <string>
class List
{
public:
class Node
{
public:
Node() : next(nullptr) {}
virtual ~Node() {}
virtual void print() = 0;
Node* next;
};
List() : head(nullptr), tail(nullptr) {}
~List()
{
Node* node = head;
Node* next = nullptr;
for ( ; node != nullptr; node = next )
{
next = node->next;
delete node;
}
}
void addNode(Node* node)
{
if (head == 0)
{
head = tail = node;
return;
}
if ( head == tail )
{
head->next = node;
}
tail->next = node;
tail = node;
}
void print()
{
Node* node = head;
for ( ; node != nullptr; node = node->next )
{
node->print();
std::cout << std::endl;
}
}
Node* head;
Node* tail;
};
class NodeA : public List::Node
{
public:
NodeA(int d) : data(d) {}
virtual ~NodeA() {}
virtual void print()
{
std::cout << "In NodeA::print(), Data: " << data;
}
private:
int data;
};
class NodeB : public List::Node
{
public:
NodeB(double d) : data(d) {}
virtual ~NodeB() {}
virtual void print()
{
std::cout << "In NodeB::print(), Data: " << data;
}
private:
double data;
};
class NodeC : public List::Node
{
public:
NodeC(std::string const& d) : data(d) {}
virtual ~NodeC() {}
virtual void print()
{
std::cout << "In NodeC::print(), Data: " << data;
}
private:
std::string data;
};
int main()
{
List list;
list.addNode(new NodeA(10));
list.addNode(new NodeB(23.45));
list.addNode(new NodeC("abcd"));
list.print();
return 0;
}

Answer 4

Although Austin's solution is perfectly fine, another approach (that I typically prefer) in such situations is to use interface classes and upcasting.
class FooFighter { public: virtual void foo() = 0; };
class A { ... };
class B1 : public A { ... };
class B2 : public A, public FooFighter { ... };
...
int main() {
std::vector<A *> v;
// fill up v
for (int i = 0; i < v.size(); ++i) {
FooFighter * ff = dynamic_cast<FooFighter *>(v[i]);
if (ff) ff.foo();
}
return 0;
}
This lets you keep whether or not a class has foo independent of the rest of your hierarchy. In particular, by examining the class hierarchy of any type you always know whether or not that type implements foo, because it has to inherit from FooFighter. When you use the downcasting approach, you could have multiple children of A that non-trivially implement foo in different ways. This approach also meshes extremely well with IDEs that let you easily examine and traverse the type hierarchies in your code.