Get pointer of derived class type without dynamic_cast

I'm in a situation where I am defining a C++ API representing an
interface such that different applications can use the interface, yet
there can be different libraries that implement the interface. The goal
is for the applications to be able to be run against a test library
implementing the interface as well as the real implementation library
itself.

The way I have approached the API design is to specify a bunch of
abstract base classes, and obviously only the types of these base
classes are known to the API. The applications do not need to know
anything about the implementation classes (I am maybe somewhat
overzealous about that). For various reasons, I want to avoid the Pimpl
idiom (one target for the application is embedded environments, and I
don't want a bunch of delegating member functions or to fragment the
construction of the objects). Also, for any given implementation, most
of the abstract base classes will only have exactly one implementation
subclass.

I have come up with a way to implement getting a pointer or reference
of the derived class type from a pointer of the base class type without
using a dynamic_cast, and I'm curious about (a) whether this method can
be improved and (b) whether I'm seriously deluded about doing this (i.e.
am I taking my anti-cast stance too far). One "justification" I have
for avoiding dynamic_cast here is that my approach here has a stronger
guarantee than can be provided by dynamic_cast because dynamic_cast has
the possibility of returning a null pointer because the types do not
match up.

So here is the general outline of how I implement this:

Interface.h:

namespace Interface
{

// I use a base class using the curiously recurring template pattern
// because I need each abstract class to have a unique nested class
// providing an anonymous type that I can use in return values.
template <typename T>
class Base
{
public:
     class I;
     virtual I &Get() = 0;
     virtual const I &Get() const = 0;
};

class Abstract : public Base<Abstract>
{
public:
     virtual void Foo() const = 0;
};

} // namespace Interface

Implementation.h:

namespace Implementation
{
     class Derived;
}

namespace Interface
{

template <>
class Base<Abstract>::I : public Abstract
{
public:
     // Accessors returning nested type which is undefined to the
     // interface, but visible to implementation
     virtual I &Get() { return *this; }
     virtual const I &Get() const { return *this; }

     // Conversion operators to get to the actual implementation
     // type.
     virtual operator Implementation::Derived &() = 0;
     virtual operator const Implementation::Derived &() const = 0;
};

} // namespace Interface

namespace Implementation
{

class Derived : public Interface::Base<Interface::Abstract>::I
{
public:
     // Only here do we know the actual implementation type
     virtual operator Derived &() { return *this; }
     virtual operator const Derived &() const { return *this; }
     virtual void Foo() const
     {
         std::cout << "Derived::Do" << std::endl;
     }
     void Impl() const
     {
         std::cout << "Derived::Impl" << std::endl;
     }
};

} //namespace Implementation

Implementation.cpp:

int main(int argc, char *argv[])
{
     Implementation::Derived d;
     Interface::Abstract *ap = &d;
     Implementation::Derived &rd = ap->Foo();
     rd.Do();
     rd.Impl();
     const Interface::Abstract *cap = ap;
     const Implementation::Derived &crd = cap->Foo();
     crd.Do();
     crd.Impl();
     return 0;
}

--
Bernie
I do not want email replies, please followup to the group.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]