I assume this is outright impossible, but what if. Is it possible to somehow get type of enclosing class in a static member function, in any version of C++?
class Impossible {
public:
static void Fun()
{
typedef Impossible EnclosingClass;
// now do something with EnclosingClass ...
}
}
Is there a way to get the type of the enclosing class (Impossible
in this case) without writing the name of the class in the function?
The reason why I'd like to do that is to avoid repeating the class name in the function. It could easily lead to a hard to find copy-paste bug, if something like this happened:
class SomeOther { // another class, with the same interface as Impossible
public:
static void Fun()
{
typedef Impossible EnclosingClass;
// whoops, copy-pasted, forgot to change "Impossible" to "SomeOther"
// now do something with EnclosingClass ...
}
}
Is there a good way to prevent this kind of thing happening? I could imagine touching something that was declared private in the enclosing class, but that would be forcing me to write extra code (as my current design doesn't contain any inherent private members, all is public).
Static functions in a class: Just like the static data members or static variables inside the class, static member functions also does not depend on object of class. We are allowed to invoke a static member function using the object and the '.
Static Function Members By declaring a function member as static, you make it independent of any particular object of the class. A static member function can be called even if no objects of the class exist and the static functions are accessed using only the class name and the scope resolution operator ::.
Must be defined and initialized outside of any function, like a global variable. It can be accessed by any member function of the class. Normally, it is accessed with the class scope operator. If it is private, use a static member function to read or write it.
Static member functions can also be defined outside of the class declaration. This works the same way as for normal member functions.
The problem is that C++ is lacking a self
keyword.
I typically write:
struct Foo
{
typedef Foo self;
static void bar()
{
self* ptr = nullptr;
}
};
I realise you still have to make sure the typedef
is correct, but at least this way you can have it at the top of the type definition where you'll notice it.
With hackery, though, you can make this entirely autonomous.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With