Mike said:
[...]
For now, if a virtual class name member function is one solution, as you
have indicated, then a version of the same idea using built-in support
is the typeid operator.
I just tried typeid. It appears that it doesn't know where I
would like to know: in the constructor.
What did you try?
I tried:
#include <typeinfo>
namespace {
template < typename B >
B unimplemented ( void );
}
template < typename B >
bool has_dynamic_type ( B const & b ) {
return ( typeid( unimplemented<B>() ) == typeid( b ) );
}
#include <iostream>
class Base {
protected:
Base ( void ) {
std::cout << has_dynamic_type< Base >( *this ) << '\n';
}
public:
bool is_base ( void ) const {
return ( has_dynamic_type< Base >( *this ) );
}
virtual
~Base ( void ) {}
static
Base* create ( void ) {
return new Base;
}
};
struct Derived : public Base {
protected:
Derived ( void ) {
std::cout << has_dynamic_type< Base >( *this ) << '\n';
}
public:
static
Derived* create ( void ) {
return new Derived;
}
};
int main ( void ) {
Base* b_ptr = Base::create();
Base* d_ptr = Derived::create();
std::cout << b_ptr->is_base() << '\n';
std::cout << d_ptr->is_base() << '\n';
}
a) I am not sure whether there is UB in the above.
b) A little bit of the code complexity is because I wanted something that
does not require default constructibilty.
c) On my machine, the output is:
1 // construction of *b_ptr
1 // construction of *d_ptr Base() part
0 // construction of *d_ptr Derived() part
1 // b_ptr->is_base();
0 // d_ptr->is_base();
FYI, the situation is a hierarchy of complex mathematical
operations, each one in its own class. Most of the classes
can function alone or in concert with others. The sequence
of events is controlled by ctor of the most inherited class.
The data for all classes are mostly the same type, voluminous,
and kept protected in a base class. Virtual inheritance is
used.
Could you provide a little example code that demonstrates the design?
The most inherited class must recognize itself in the ctor.
Note that when Base() is called, it truly constructs a Base object and
nothing else. The constructor has no way of telling how it is invoked.
Also, the other methods you mentioned in your first post have trouble in
this situation:
1. pass an appropriate bool in the ctor args;
In order to pass that bool, you would need to know already, won't you?
2. use a virtual method that returns, for
example, a siring containing the class name.
Virtual functions are not necessarily resolved the way you like in
constructors. I feel there might be some UB involved.
If you classes are just wrapping operations, then maybe you can move the
logic from the constructors to the destructors?
[snip]
Best
Kai-Uwe Bux
