Narrowing subclasses of pointer member in derived class - c++

Question

I have a class hierarchy that is broken in two - high level objects, and low-level and swappable connection interfaces. The connection objects form a class hierarchy, where each adds more features to the connection. Similarly, the high-level class hierarchy needs progressively better connections.
The connection objects look like the following:
class BaseConnection {
virtual void a() = 0;
};
class BetterConnection : public BaseConnection {
virtual void b() = 0;
}
class BestConnection : public BetterConnection {
virtual void c() = 0;
}
Here's my attempt at writing the high level objects
struct Base {
protected:
// This type is correct for `Base`, but `Better` and `Best` need access to a more derived type.
unique_ptr<BaseConnection> const m_conn;
public:
Base(unique_ptr<BaseConnection> conn) : m_conn(std::move(conn));
void do_a_twice() {
auto& conn = *m_conn;
conn.a(); conn.a();
}
};
struct Better : public Base {
Better(unique_ptr<BetterConnection> conn) : Base(std::move(conn));
void do_b_twice() {
auto& conn = dynamic_cast<BetterConnection&>(*m_conn);
conn.b(); conn.b();
}
};
struct Best : public Better {
unique_ptr<BetterConnection> conn;
Better(unique_ptr<BetterConnection> conn) : Better(std::move(conn));
void do_c_twice() {
auto& conn = dynamic_cast<BestConnection&>(*m_conn);
conn.b(); conn.b();
}
};
So, my questions:
Is there a way to achieve this without dynamic_cast?
Am I right in thinking this incurs a runtime overhead of using runtime-type-information?
Is it safe to use reinterpret_cast here?

Answer 1

It seems to me that the abstractions around your Connection types are making things more difficult (whereas abstraction is supposed to simplify things).
Why do the Connection types have different members? If the derived Connection classes instead overrode the BaseConnection, you can rely on virtual function dispatch to do the right thing at runtime. For example
struct BaseConnection {
virtual void connect() {
cout << "BaseConnection::connect" << endl;
}
};
struct BetterConnection : public BaseConnection {
void connect() override {
cout << "BetterConnection::connect" << endl;
}
};
struct BestConnection : public BetterConnection {
void connect() override {
cout << "BestConnection::connect" << endl;
}
};
class X {
public:
X(std::unique_ptr<BaseConnection> connection)
: connection_(std::move(connection))
{
connection_->connect();
}
private:
std::unique_ptr<BaseConnection> connection_;
};
int main() {
X(std::make_unique<BaseConnection>());
X(std::make_unique<BetterConnection>());
X(std::make_unique<BestConnection>());
}
If the Connection types have different methods because they truly are performing different actions, then it begs the question if inheritance was the right abstraction to use.
Perhaps you could add a virtual method that you override to 'do the right thing' for each derived Connection. Then the higher-level class only needs to call this one method, and it can be done without casting.
In general, if you find yourself having to use dynamic_cast to perform type inspection at runtime, it probably means the interfaces were not designed for polymorphism in mind. I would rethink the interfaces between your objects and try to see if there is a way to get what you want without having to upcast.
Edit: Using type traits
Based on your comments, it seems like you may require more customization of your higher-level objects than my original answer provided. In essence, I think what you're trying to do is case on what underlying Connection type you're managing, and provide different implementations of higher level functions.
A common way to do this (and how the STL does this) is via operator overloading with type traits. To illustrate, begin with a few types that describe traits of the underlying connection objects.
struct base_connection_tag {};
struct better_connection_tag : public base_connection_tag {};
struct best_connection_tag : public better_connection_tag {};
And then we can add them to the Connection classes.
struct BaseConnection {
virtual void a() {
cout << "BaseConnection::a()" << endl;
}
using connection_category = base_connection_tag;
};
struct BetterConnection : public BaseConnection {
virtual void b() {
cout << "BetterConnection::b()" << endl;
}
using connection_category = better_connection_tag;
};
struct BestConnection : public BetterConnection {
virtual void c() {
cout << "BestConnection::c" << endl;
}
using connection_category = best_connection_tag;
};
By convention, connection_traits echos the Connection class's nested typedef
template <typename ConnectionT>
struct connection_traits {
using connection_category = typename ConnectionT::connection_category;
};
Finally, we can use operator overloading to decide which implementation to call in some higher level class (or classes) using a pattern like this:
template <typename T>
class Dispatch
{
public:
Dispatch(std::unique_ptr<T> connection)
: connection_(std::move(connection))
{}
void operator()() {
connect(typename connection_traits<T>::connection_category());
}
private:
void connect(base_connection_tag) {
connection_->a();
}
void connect(better_connection_tag) {
connection_->b();
}
void connect(best_connection_tag) {
connection_->c();
}
std::unique_ptr<T> connection_;
};
When the () operator is called, the Dispatch class calls one of the connect methods using the connection_traits of the underlying Connection.
Since all the types are known at compile time, the Dispatch class knows which base method to call during compilation. No dynamic_cast is needed to determine which type is held.
Although I only used a single template class to implement higher order functionality, you could feasibly use multiple non-template classes to do the same thing, using connection_traits and function argument overloading in each to enable/disable functionality.