C static virtual members

Question

Is it possible in C   to have a member function that is both static and virtual  Apparently  there isn t a straightforward way to do it  static virtual member    is a compile error   but is there at least a way to achieve the same effect   I E   struct Object        struct TypeInformation        static virtual const TypeInformation  amp GetTypeInformation   const      struct SomeObject   public Object        static virtual const TypeInformation  amp GetTypeInformation   const       It makes sense to use GetTypeInformation   both on an instance  object- gt GetTypeInformation    and on a class  SomeObject  GetTypeInformation     which can be useful for comparisons and vital for templates   The only ways I can think of involves writing two functions   a function and a constant  per class  or use macros   Any other solutions

User · Answer

No  its not possible  since static members are bound at compile time  while virtual members are bound at runtime

User · Answer

I ran into this problem the other day  I had some classes full of static methods but I wanted to use inheritance and virtual methods and reduce code repetition  My solution was   Instead of using static methods  use a singleton with virtual methods   In other words  each class should contain a static method that you call to get a pointer to a single  shared instance of the class  You can make the true constructors private or protected so that outside code can t misuse it by creating additional instances   In practice  using a singleton is a lot like using static methods except that you can take advantage of inheritance and virtual methods

User · Answer

It s not possible  but that s just because an omission  It isn t something that  doesn t make sense  as a lot of people seem to claim  To be clear  I m talking about something like this   struct Base     static virtual void sayMyName         cout  lt  lt   Base n           struct Derived   public Base     static void sayMyName   override       cout  lt  lt   Derived n           void foo Base  b      b- gt sayMyName      Derived  sayMyName       Also would work      This is 100  something that could be implemented  it just hasn t   and I d argue something that is useful   Consider how normal virtual functions work  Remove the statics and add in some other stuff and we have   struct Base     virtual void sayMyName         cout  lt  lt   Base n         virtual void foo           int somedata      struct Derived   public Base     void sayMyName   override       cout  lt  lt   Derived n           void foo Base  b      b- gt sayMyName        This works fine and basically what happens is the compiler makes two tables  called VTables  and assigns indices to the virtual functions like this  enum Base Virtual Functions     sayMyName   0    foo   1      using VTable   void      const VTable Base VTable        amp Base  sayMyName     amp Base  foo     const VTable Derived VTable        amp Derived  sayMyName     amp Base  foo      Next each class with virtual functions is augmented with another field that points to its VTable  so the compiler basically changes them to be like this   struct Base     VTable  vtable    virtual void sayMyName         cout  lt  lt   Base n         virtual void foo           int somedata      struct Derived   public Base     VTable  vtable    void sayMyName   override       cout  lt  lt   Derived n            Then what actually happens when you call b- gt sayMyName    Basically this   b- gt vtable Base Virtual Functions  sayMyName  b      The first parameter becomes this    Ok fine  so how would it work with static virtual functions  Well what s the difference between static and non-static member functions  The only difference is that the latter get a this pointer   We can do exactly the same with static virtual functions - just remove the this pointer   b- gt vtable Base Virtual Functions  sayMyName       This could then support both syntaxes   b- gt sayMyName       Prints  Base  or  Derived     Base  sayMyName       Always prints  Base     So ignore all the naysayers  It does make sense  Why isn t it supported then  I think it s because it has very little benefit and could even be a little confusing   The only technical advantage over a normal virtual function is that you don t need to pass this to the function but I don t think that would make any measurable difference to performance   It does mean you don t have a separate static and non-static function for cases when you have an instance  and when you don t have an instance  but also it might be confusing that it s only really  virtual  when you use the instance call

User · Answer

First  the replies are correct that what the OP is requesting is a contradiction in terms  virtual methods depend on the run-time type of an instance  static functions specifically don t depend on an instance -- just on a type  That said  it makes sense to have static functions return something specific to a type  For example  I had a family of MouseTool classes for the State pattern and I started having each one have a static function returning the keyboard modifier that went with it  I used those static functions in the factory function that made the correct MouseTool instance  That function checked the mouse state against MouseToolA  keyboardModifier    MouseToolB  keyboardModifier    etc  and then instantiated the appropriate one  Of course later I wanted to check if the state was right so I wanted write something like  if  keyboardModifier    dynamic type  state   keyboardModifier      not real C   syntax   which is what this question is asking   So  if you find yourself wanting this  you may want to rething your solution  Still  I understand the desire to have static methods and then call them dynamically based on the dynamic type of an instance  I think the Visitor Pattern can give you what you want  It gives you what you want  It s a bit of extra code  but it could be useful for other visitors    See  http   en wikipedia org wiki Visitor pattern for background   struct ObjectVisitor   struct Object        struct TypeInformation        static TypeInformation GetTypeInformation         virtual void accept ObjectVisitor amp  v       struct SomeObject   public Object        static TypeInformation GetTypeInformation         virtual void accept ObjectVisitor amp  v  const      struct AnotherObject   public Object        static TypeInformation GetTypeInformation         virtual void accept ObjectVisitor amp  v  const       Then for each concrete Object   void SomeObject  accept ObjectVisitor amp  v  const       v visit  this      The compiler statically picks the visit method based on  this being a const SomeObject amp     void AnotherObject  accept ObjectVisitor amp  v  const       v visit  this      Here  this is a const AnotherObject amp  at compile time      and then define the base visitor   struct ObjectVisitor       virtual  ObjectVisitor          virtual void visit const SomeObject amp  o        Or   0  depending what you feel like      virtual void visit const AnotherObject amp  o        Or   0  depending what you feel like         More virtual void visit   methods for each Object class       Then the concrete visitor that selects the appropriate static function   struct ObjectVisitorGetTypeInfo       Object  TypeInformation result      virtual void visit const SomeObject amp  o            result   SomeObject  GetTypeInformation              virtual void visit const AnotherObject amp  o            result   AnotherObject  GetTypeInformation                 Again  an implementation for each concrete Object       finally  use it   void printInfo Object amp  o        ObjectVisitorGetTypeInfo getTypeInfo      Object  TypeInformation info   o accept getTypeInfo  result      std  cout  lt  lt  info  lt  lt  std  endl      Notes    Constness left as an exercise  You returned a reference from a static  Unless you have a singleton  that s questionable    If you want to avoid copy-paste errors where one of your visit methods calls the wrong static function  you could use a templated helper function  which can t itself be virtual  t your visitor with a template like this   struct ObjectVisitorGetTypeInfo       Object  TypeInformation result      virtual void visit const SomeObject amp  o    doVisit o         virtual void visit const AnotherObject amp  o    doVisit o            Again  an implementation for each concrete Object     private      template  lt typename T gt      void doVisit const T amp  o            result   T  GetTypeInformation

User · Answer

Many say it is not possible  I would go one step further and say it is not meaningfull   A static member is something that does not relate to any instance  only to the class   A virtual member is something that does not relate directly to any class  only to an instance   So a static virtual member would be something that does not relate to any instance or any class

User · Answer

No  Static member function can t be virtual  since virtual concept is resolved at run time with the help of vptr  and vptr is non static member of a class due to  that static member function can t acess vptr  so static member can t be virtual

User · Answer

Well   quite a late answer but it is possible using the curiously recurring template pattern  This wikipedia article has the info you need and also the example under static polymorphism is what you are asked for

User · Answer

No  there s no way to do it  since what would happen when you called Object  GetTypeInformation     It can t know which derived class version to call since there s no object associated with it   You ll have to make it a non-static virtual function to work properly  if you also want to be able to call a specific derived class s version non-virtually without an object instance  you ll have to provide a second redunduant static non-virtual version as well

User · Answer

This question is over a decade old  but it looks like it gets a good amount of traffic  so I wanted to post an alternative using modern C   features that I haven t seen anywhere else  This solution uses CRTP and SFINAE to perform static dispatching  That  in itself  is nothing new  but all such implementations I ve found lack strict signature checking for  quot overrides  quot  This implementation requires that the  quot overriding quot  method signature exactly matches that of the  quot overridden quot  method  This behavior more closely resembles that of virtual functions  while also allowing us to effectively overload and  quot override quot  a static method  Note that I put override in quotes because  strictly speaking  we re not technically overriding anything  Instead  we re calling a dispatch method X with signature Y that forwards all of its arguments to T  X  where T is to the first type among a list of types such that T  X exists with signature Y  This list of types considered for dispatching can be anything  but generally would include a default implementation class and the derived class  Implementation  include  lt experimental type traits gt   template  lt template  lt class    gt  class Op  class    Types gt  struct dispatcher   template  lt template  lt class    gt  class Op  class T gt  struct dispatcher lt Op  T gt    std  experimental  detected t lt Op  T gt       template  lt template  lt class    gt  class Op  class T  class    Types gt  struct dispatcher lt Op  T  Types    gt      std  experimental  detected or t lt      typename dispatcher lt Op  Types    gt   type  Op  T gt           Helper to convert a signature to a function pointer template  lt class Signature gt  struct function ptr   template  lt class R  class    Args gt  struct function ptr lt R Args     gt        using type   R     Args              Macro to simplify creation of the dispatcher    NOTE  This macro isn t smart enough to handle creating an overloaded          dispatcher because both dispatchers will try to use the same          integral constant type alias name  If you want to overload  do it          manually or make a smarter macro that can somehow put the signature in          the integral constant type alias name   define virtual static method name  signature                                        template  lt class VSM T gt                                                            using vsm   name   type   std  integral constant lt                                     function ptr lt signature gt   type   amp VSM T  name gt                                                                                                                   template  lt class    VSM Args gt                                                      static auto name VSM Args amp  amp     args                                                                                                                                   return dispatcher lt vsm   name   type    VA ARGS   gt   value                             std  forward lt VSM Args gt  args                                                 Example Usage  include  lt iostream gt   template  lt class T gt  struct Base          Define the default implementations     struct defaults           static std  string alpha     return  quot Base  alpha quot              static std  string bravo int    return  quot Base  bravo quot                    Create the dispatchers     virtual static method alpha  std  string void   T  defaults       virtual static method bravo  std  string int   T  defaults            static void where are the turtles             std  cout  lt  lt  alpha    lt  lt  std  endl      Derived  alpha         std  cout  lt  lt  bravo 1   lt  lt  std  endl     Base  bravo           struct Derived   Base lt Derived gt           Overrides Base  alpha     static std  string alpha    return  quot Derived  alpha quot             Does not override Base  bravo because signatures differ  even though        int is implicitly convertible to bool      static std  string bravo bool   return  quot Derived  bravo quot         int main         Derived  where are the turtles

User · Answer

It is possible  Make two functions  static and virtual  struct Object         struct TypeInformation    static  const TypeInformation  amp GetTypeInformationStatic   const             return GetTypeInformationMain1          virtual const TypeInformation  amp GetTypeInformation   const            return GetTypeInformationMain1        protected    static const TypeInformation  amp GetTypeInformationMain1       Main function     struct SomeObject   public Object          static  const TypeInformation  amp GetTypeInformationStatic   const             return GetTypeInformationMain2          virtual const TypeInformation  amp GetTypeInformation   const            return GetTypeInformationMain2        protected    static const TypeInformation  amp GetTypeInformationMain2       Main function

User · Answer

No  this is not possible  because static member functions lack a this pointer  And static members  both functions and variables  are not really class members per-se  They just happen to be invoked by ClassName  member  and adhere to the class access specifiers  Their storage is defined somewhere outside the class  storage is not created each time you instantiated an object of the class  Pointers to class members are special in semantics and syntax  A pointer to a static member is a normal pointer in all regards   virtual functions in a class needs the this pointer  and is very coupled to the class  hence they can t be static

User · Answer

I think what you re trying to do can be done through templates   I m trying to read between the lines here   What you re trying to do is to call a method from some code  where it calls a derived version but the caller doesn t specify which class   Example   class Foo   public      void M             class Bar   public Foo   public      void M             void Try         xxx  M       int main         Try        You want Try   to call the Bar version of M without specifying Bar   The way you do that for statics is to use a template   So change it like so   class Foo   public      void M             class Bar   public Foo   public      void M             template  lt class T gt  void Try         T  M       int main         Try lt Bar gt

User · Answer

While Alsk has already given a pretty detailed answer  I d like to add an alternative  since I think his enhanced implementation is overcomplicated   We start with an abstract base class  that provides the interface for all the object types   class Object   public      virtual char  GetClassName     0       Now we need an actual implementation  But to avoid having to write both the static and the virtual methods  we will have our actual object classes inherit the virtual methods  This does obviously only work  if the base class knows how to access the static member function  So we need to use a template and pass the actual objects class name to it   template lt class ObjectType gt  class ObjectImpl   public Object   public      virtual char  GetClassName                 return ObjectType  GetClassNameStatic               Finally we need to implement our real object s   Here we only need to implement the static member function  the virtual member functions will be inherited from the ObjectImpl template class  instantiated with the name of the derived class  so it will access it s static members   class MyObject   public ObjectImpl lt MyObject gt    public      static char  GetClassNameStatic                 return  MyObject             class YourObject   public ObjectImpl lt YourObject gt    public      static char  GetClassNameStatic                 return  YourObject              Let s add some code to test   char  GetObjectClassName Object  object        return object- gt GetClassName       int main         MyObject myObject      YourObject yourObject       printf   s n   MyObject  GetClassNameStatic         printf   s n   myObject GetClassName         printf   s n   GetObjectClassName  amp myObject        printf   s n   YourObject  GetClassNameStatic         printf   s n   yourObject GetClassName         printf   s n   GetObjectClassName  amp yourObject         return 0      Addendum  Jan 12th 2019    Instead of using the GetClassNameStatic   function  you can also define the the class name as a static member  even  inline   which IIRC works since C  11  don t get scared by all the modifiers       class MyObject   public ObjectImpl lt MyObject gt    public         Access this from the template class as  ObjectType  s ClassName       static inline const char  const s ClassName    MyObject

User · Answer

It is possible   But what exactly is possible  let s narrow down  People often want some kind of  static virtual function  because of duplication of code needed for being able to call the same function through static call  SomeDerivedClass  myfunction    and polymorphic call  base class pointer- myfunction      Legal  method for allowing such functionality is duplication of function definitions   class Object   public      static string getTypeInformationStatic     return  base class        virtual string getTypeInformation     return getTypeInformationStatic          class Foo  public Object   public      static string getTypeInformationStatic     return  derived class        virtual string getTypeInformation     return getTypeInformationStatic           What if base class has a great number of static functions and derived class has to override every of them and one forgot to provide a duplicating definition for virtual function  Right  we ll get some strange error during runtime which is hard to track down  Cause duplication of code is a bad thing  The following tries to resolve this problem  and I want to tell beforehand that it is completely type-safe and doesn t contain any black magic like typeid s or dynamic cast s     So  we want to provide only one definition of getTypeInformation   per derived class and it is obvious that it has to be a definition of static function because it is not possible to call  SomeDerivedClass  getTypeInformation    if getTypeInformation   is virtual  How can we call static function of derived class through pointer to base class  It is not possible with vtable because vtable stores pointers only to virtual functions and since we decided not to use virtual functions  we cannot modify vtable for our benefit  Then  to be able to access static function for derived class through pointer to base class we have to store somehow the type of an object within its base class  One approach is to make base class templatized using  curiously recurring  template pattern  but it is not appropriate here and we ll use a technique called  type erasure    class TypeKeeper   public      virtual string getTypeInformation     0     template lt class T gt  class TypeKeeperImpl  public TypeKeeper   public      virtual string getTypeInformation     return T  getTypeInformationStatic           Now we can store the type of an object within base class  Object  with a variable  keeper    class Object   public      Object         boost  scoped ptr lt TypeKeeper gt  keeper         not virtual     string getTypeInformation   const        return keeper  keeper- gt getTypeInformation    string  base class            In a derived class keeper must be initialized during construction   class Foo  public Object   public      Foo     keeper reset new TypeKeeperImpl lt Foo gt              note the name of the function     static string getTypeInformationStatic          return  class for proving static virtual functions concept          Let s add syntactic sugar   template lt class T gt  void override static functions T  t    t- gt keeper reset new TypeKeeperImpl lt T gt         define OVERRIDE STATIC FUNCTIONS override static functions this    Now declarations of descendants look like   class Foo  public Object   public      Foo     OVERRIDE STATIC FUNCTIONS        static string getTypeInformationStatic          return  class for proving static virtual functions concept         class Bar  public Foo   public      Bar     OVERRIDE STATIC FUNCTIONS        static string getTypeInformationStatic          return  another class for the same reason          usage   Object  obj   new Foo    cout  lt  lt  obj- gt getTypeInformation    lt  lt  endl     calls Foo  getTypeInformationStatic   obj   new Bar    cout  lt  lt  obj- gt getTypeInformation    lt  lt  endl     calls Bar  getTypeInformationStatic   Foo  foo   new Bar    cout  lt  lt  foo- gt getTypeInformation    lt  lt  endl    calls Bar  getTypeInformationStatic   Foo  getTypeInformation      compile-time error Foo  getTypeInformationStatic      calls Foo  getTypeInformationStatic   Bar  getTypeInformationStatic      calls Bar  getTypeInformationStatic     Advantages    less duplication of code  but we have to call OVERRIDE STATIC FUNCTIONS in every constructor    Disadvantages    OVERRIDE STATIC FUNCTIONS in every constructor memory and performance     overhead increased complexity   Open issues   1  there are different names for static and virtual functions    how to solve ambiguity here   class Foo   public      static void f bool f true    cout  lt  lt   static        virtual void f     cout  lt  lt   virtual         somewhere Foo  f      calls static f    no ambiguity ptr to foo- gt f      ambiguity   2  how to implicitly call OVERRIDE STATIC FUNCTIONS inside every constructor

User · Answer

Like others have said  there are 2 important pieces of information    there is no this pointer when making a static function call and  the this pointer points to the structure where the virtual table  or thunk  are used to look up which runtime method to call    A static function is determined at compile time   I showed this code example in C   static members in class  it shows that you can call a static method given a null pointer   struct Foo       static int boo     return 2        int  tmain int argc   TCHAR  argv          Foo  pFoo   NULL      int b   pFoo- gt boo       b will now have the value 2     return 0

User · Answer

Maybe you can try my solution below   class Base   public      Base void       virtual  Base void    public      virtual void MyVirtualFun void    0      static void  MyStaticFun void    assert  mSelf    NULL   mSelf- gt MyVirtualFun      private      static Base  mSelf      Base  mSelf   NULL   Base  Base void        mSelf   this     Base   Base void           please never delete mSelf or reset the Value of mSelf in any deconstructors    class DerivedClass   public Base   public      DerivedClass void    Base           DerivedClass void     public      virtual void MyVirtualFun void    cout lt  lt  Hello  it is DerivedClass   lt  lt endl        int main         DerivedClass testCls      testCls MyStaticFun      correct way to invoke this kind of static fun     DerivedClass  MyStaticFun      wrong way     return 0

User · Answer

With c   you can use static inheritance with the crt method  For the example  it is used widely on window template atl  amp  wtl   See https   en wikipedia org wiki Curiously recurring template pattern  To be simple  you have a class that is templated from itself like class myclass   public myancestor  From this point the myancestor class can now call your static T  YourImpl function

[c++] C++ static virtual members?

Examples related to c++

Examples related to static

Examples related to virtual