Can a class member function template be virtual

Question

I have heard that C   class member function templates can t be virtual   Is this true    If they can be virtual  what is an example of a scenario in which one would use such a function

User · Answer

C   doesn t allow virtual template member functions right now  The most likely reason is the complexity of implementing it  Rajendra gives good reason why it can t be done right now but it could be possible with reasonable changes of the standard  Especially working out how many instantiations of a templated function actually exist and building up the vtable seems difficult if you consider the place of the virtual function call  Standards people just have a lot of other things to do right now and C  1x is a lot of work for the compiler writers as well   When would you need a templated member function  I once came across such a situation where I tried to refactor a hierarchy with a pure virtual base class  It was a poor style for implementing different strategies  I wanted to change the argument of one of the virtual functions to a numeric type and instead of overloading the member function and override every overload in all sub-classes I tried to use virtual template functions  and had to find out they don t exist

User · Answer

There is a workaround for  virtual template method  if set of types for the template method is known in advance   To show the idea  in the example below only two types are used  int and double    There  a  virtual  template method  Base  Method  calls corresponding virtual method  one of Base  VMethod  which  in turn  calls template method implementation  Impl  TMethod    One only needs to implement template method TMethod in derived implementations  AImpl  BImpl  and use Derived lt  Impl gt    class Base   public      virtual  Base                    template  lt typename T gt      T Method T t                return VMethod t          private      virtual int VMethod int t    0      virtual double VMethod double t    0      template  lt class Impl gt  class Derived   public Impl   public      template  lt class    TArgs gt      Derived TArgs amp  amp     args            Impl std  forward lt TArgs gt  args                   private      int VMethod int t  final               return Impl  TMethod t              double VMethod double t  final               return Impl  TMethod t             class AImpl   public Base   protected      AImpl int p            i p                   template  lt typename T gt      T TMethod T t                return t - i         private      int i      using A   Derived lt AImpl gt    class BImpl   public Base   protected      BImpl int p            i p                   template  lt typename T gt      T TMethod T t                return t   i         private      int i      using B   Derived lt BImpl gt    int main int argc  const char  argv          A a 1       B b 1       Base  base   nullptr       base    amp a      std  cout  lt  lt  base- gt Method 1   lt  lt  std  endl      std  cout  lt  lt  base- gt Method 2 0   lt  lt  std  endl       base    amp b      std  cout  lt  lt  base- gt Method 1   lt  lt  std  endl      std  cout  lt  lt  base- gt Method 2 0   lt  lt  std  endl      Output   0 1 2 3   NB  Base  Method is actually surplus for real code  VMethod can be made public and used directly   I added it so it looks like as an actual  virtual  template method

User · Answer

The following code can be compiled and runs properly  using MinGW G   3 4 5 on Window 7    include  lt iostream gt   include  lt string gt   using namespace std   template  lt typename T gt  class A  public      virtual void func1 const T amp  p                cout lt  lt  A   lt  lt p lt  lt endl            template  lt typename T gt  class B   public A lt T gt    public      virtual void func1 const T amp  p                cout lt  lt  A lt --B   lt  lt p lt  lt endl            int main int argc  char   argv        A lt string gt  a      B lt int gt  b      B lt string gt  c       A lt string gt   p    amp a      p- gt func1  A lt string gt  a        p   dynamic cast lt A lt string gt   gt   amp c       p- gt func1  B lt string gt  c        B lt int gt   q    amp b      q- gt func1 3       and the output is   A A lt string gt  a A lt --B B lt string gt  c A lt --B 3   And later I added a new class X   class X   public      template  lt typename T gt      virtual void func2 const T amp  p                cout lt  lt  C   lt  lt p lt  lt endl             When I tried to use class X in main   like this   X x  x func2 lt string gt   X x      g   report the following error   vtempl cpp 34  error  invalid use of  virtual  in template declaration of  virtu al void X  func2 const T amp      So it is obvious that    virtual member function can be used in a class template  It is easy for compiler to construct vtable It is impossible to define a class template member function as virtual  as you can see  it hard to determine function signature and allocate vtable entries

User · Answer

Virtual Function Tables  Let s begin with some background on virtual function tables and how they work  source        20 3  What s the difference between how virtual and non-virtual   member functions are called       Non-virtual member functions are resolved statically  That is  the   member function is selected statically  at compile-time  based on the   type of the pointer  or reference  to the object       In contrast  virtual member functions are resolved dynamically  at   run-time   That is  the member function is selected dynamically  at   run-time  based on the type of the object  not the type of the   pointer reference to that object  This is called  dynamic binding     Most compilers use some variant of the following technique  if the   object has one or more virtual functions  the compiler puts a hidden   pointer in the object called a  virtual-pointer  or  v-pointer   This   v-pointer points to a global table called the  virtual-table  or    v-table        The compiler creates a v-table for each class that has at least one   virtual function  For example  if class Circle has virtual functions   for draw   and move   and resize    there would be exactly one v-table   associated with class Circle  even if there were a gazillion Circle   objects  and the v-pointer of each of those Circle objects would point   to the Circle v-table  The v-table itself has pointers to each of the   virtual functions in the class  For example  the Circle v-table would   have three pointers  a pointer to Circle  draw    a pointer to   Circle  move    and a pointer to Circle  resize         During a dispatch of a virtual function  the run-time system follows   the object s v-pointer to the class s v-table  then follows the   appropriate slot in the v-table to the method code       The space-cost overhead of the above technique is nominal  an extra   pointer per object  but only for objects that will need to do dynamic   binding   plus an extra pointer per method  but only for virtual   methods   The time-cost overhead is also fairly nominal  compared to a   normal function call  a virtual function call requires two extra   fetches  one to get the value of the v-pointer  a second to get the   address of the method   None of this runtime activity happens with   non-virtual functions  since the compiler resolves non-virtual   functions exclusively at compile-time based on the type of the   pointer      My problem  or how I came here  I m attempting to use something like this now for a cubefile base class with templated optimized load functions which will be implemented differently for different types of cubes  some stored by pixel  some by image  etc    Some code   virtual void  LoadCube UtpBipCube lt float gt   amp Cube long LowerLeftRow 0 long LowerLeftColumn 0          long UpperRightRow -1 long UpperRightColumn -1 long LowerBand 0 long UpperBand -1    0  virtual void  LoadCube UtpBipCube lt short gt   amp Cube  long LowerLeftRow 0 long LowerLeftColumn 0          long UpperRightRow -1 long UpperRightColumn -1 long LowerBand 0 long UpperBand -1    0  virtual void  LoadCube UtpBipCube lt unsigned short gt   amp Cube  long LowerLeftRow 0 long LowerLeftColumn 0          long UpperRightRow -1 long UpperRightColumn -1 long LowerBand 0 long UpperBand -1    0    What I d like it to be  but it won t compile due to a virtual templated combo   template lt class T gt      virtual void  LoadCube UtpBipCube lt T gt   amp Cube long LowerLeftRow 0 long LowerLeftColumn 0              long UpperRightRow -1 long UpperRightColumn -1 long LowerBand 0 long UpperBand -1    0    I ended up moving the template declaration to the class level  This solution would have forced programs to know about specific types of data they would read before they read them  which is unacceptable   Solution  warning  this isn t very pretty but it allowed me to remove repetitive execution code  1  in the base class  virtual void  LoadCube UtpBipCube lt float gt   amp Cube long LowerLeftRow 0 long LowerLeftColumn 0              long UpperRightRow -1 long UpperRightColumn -1 long LowerBand 0 long UpperBand -1    0  virtual void  LoadCube UtpBipCube lt short gt   amp Cube  long LowerLeftRow 0 long LowerLeftColumn 0              long UpperRightRow -1 long UpperRightColumn -1 long LowerBand 0 long UpperBand -1    0  virtual void  LoadCube UtpBipCube lt unsigned short gt   amp Cube  long LowerLeftRow 0 long LowerLeftColumn 0              long UpperRightRow -1 long UpperRightColumn -1 long LowerBand 0 long UpperBand -1    0    2  and in the child classes  void  LoadCube UtpBipCube lt float gt   amp Cube  long LowerLeftRow 0 long LowerLeftColumn 0          long UpperRightRow -1 long UpperRightColumn -1 long LowerBand 0 long UpperBand -1    LoadAnyCube Cube LowerLeftRow LowerLeftColumn UpperRightRow UpperRightColumn LowerBand UpperBand      void  LoadCube UtpBipCube lt short gt   amp Cube  long LowerLeftRow 0 long LowerLeftColumn 0          long UpperRightRow -1 long UpperRightColumn -1 long LowerBand 0 long UpperBand -1    LoadAnyCube Cube LowerLeftRow LowerLeftColumn UpperRightRow UpperRightColumn LowerBand UpperBand      void  LoadCube UtpBipCube lt unsigned short gt   amp Cube  long LowerLeftRow 0 long LowerLeftColumn 0          long UpperRightRow -1 long UpperRightColumn -1 long LowerBand 0 long UpperBand -1    LoadAnyCube Cube LowerLeftRow LowerLeftColumn UpperRightRow UpperRightColumn LowerBand UpperBand      template lt class T gt  void  LoadAnyCube UtpBipCube lt T gt   amp Cube  long LowerLeftRow 0 long LowerLeftColumn 0          long UpperRightRow -1 long UpperRightColumn -1 long LowerBand 0 long UpperBand -1     Note that LoadAnyCube is not declared in the base class      Here s another stack overflow answer with a work around  need a virtual template member workaround

User · Answer

Templates are all about the compiler generating code at compile-time  Virtual functions are all about the run-time system figuring out which function to call at run-time    Once the run-time system figured out it would need to call a templatized virtual function  compilation is all done and the compiler cannot generate the appropriate instance anymore  Therefore you cannot have virtual member function templates    However  there are a few powerful and interesting techniques stemming from combining polymorphism and templates  notably so-called type erasure

User · Answer

At least with gcc 5 4 virtual functions could be template members but has to be templates themselves      include  lt iostream gt   include  lt string gt  class first   protected      virtual std  string  a1     return  a1         virtual std  string  mixt     return a1          class last   protected      virtual std  string a2     return  a2         template lt class T gt   class mix  first   T       public      virtual std  string mixt   override      template lt class T gt  std  string mix lt T gt   mixt        return a1     before   T  a2       class mix2  public mix lt last gt         virtual std  string a1   override   return  mix         int main         std  cout  lt  lt  mix2   mixt        return 0      Outputs  mix before a2 Process finished with exit code 0

User · Answer

No  template member functions cannot be virtual

User · Answer

From C   Templates The Complete Guide      Member function templates cannot be declared virtual  This constraint   is imposed because the usual implementation of the virtual function   call mechanism uses a fixed-size table with one entry per virtual   function  However  the number of instantiations of a member function   template is not fixed until the entire program has been translated    Hence  supporting virtual member function templates would require   support for a whole new kind of mechanism in C   compilers and   linkers  In contrast  the ordinary members of class templates can be   virtual because their number is fixed when a class is instantiated

User · Answer

While an older question that has been answered by many I believe a succinct method  not so different from the others posted  is to use a minor macro to help ease the duplication of class declarations      abstract h     Simply define the types that each concrete class will use  define IMPL RENDER         void render int a  char  b  override   render internal lt char gt  a  b             void render int a  short  b  override   render internal lt short gt  a  b                   class Renderable   public         Then  once for each on the abstract     virtual void render int a  char  a    0      virtual void render int a  short  b    0                  So now  to implement our subclass   class Box   public Renderable   public      IMPL RENDER      Builds the functions we want  private      template lt typename T gt      void render internal int a  T  b      One spot for our logic      The benefit here is that  when adding a newly supported type  it can all be done from the abstract header and forego possibly rectifying it in multiple source header files

User · Answer

To answer the second part of the question      If they can be virtual  what is an example of a scenario in which one would use such a function    This is not an unreasonable thing to want to do   For instance  Java  where every method is virtual  has no problems with generic methods   One example in C   of wanting a virtual function template is a member function that accepts a generic iterator   Or a member function that accepts a generic function object   The solution to this problem is to use type erasure with boost  any range and boost  function  which will allow you to accept a generic iterator or functor without the need to make your function a template

User · Answer

My current solution is the following  with RTTI disabled - you could use std  type index  too    include  lt type traits gt   include  lt iostream gt   include  lt tuple gt   class Type       template lt typename T gt  class TypeImpl   public Type        template lt typename T gt  inline Type  typeOf         static Type  typePtr   new TypeImpl lt T gt         return typePtr        -------------     template lt      typename Calling       typename Result   void       typename From       typename Action  gt  inline Result DoComplexDispatch From  from  Action amp  amp  action    template lt typename Cls gt  class ChildClasses   public      using type   std  tuple lt  gt       template lt typename    Childs gt  class ChildClassesHelper   public      using type   std  tuple lt Childs    gt         --------------------------  class A  class B  class C  class D   template lt  gt  class ChildClasses lt A gt    public ChildClassesHelper lt B  C  D gt       template lt  gt  class ChildClasses lt B gt    public ChildClassesHelper lt C  D gt       template lt  gt  class ChildClasses lt C gt    public ChildClassesHelper lt D gt         -------------------------------------------  class A   public      virtual Type  GetType                 return typeOf lt A gt                template lt          typename T          bool checkType   true      gt            virtual  void DoVirtualGeneric                 if constexpr  checkType                        return DoComplexDispatch lt A gt  this    amp   auto  other  - gt  decltype auto                                        return other- gt template DoVirtualGeneric lt T  false gt                                           std  cout  lt  lt   quot A quot             class B   public A   public      virtual Type  GetType                 return typeOf lt B gt               template lt          typename T          bool checkType   true      gt        virtual  void DoVirtualGeneric     override                 if constexpr  checkType                        return DoComplexDispatch lt B gt  this    amp   auto  other  - gt  decltype auto                                        other- gt template DoVirtualGeneric lt T  false gt                                           std  cout  lt  lt   quot B quot             class C   public B   public      virtual Type  GetType             return typeOf lt C gt                template lt          typename T          bool checkType   true      gt        virtual  void DoVirtualGeneric     override                 if constexpr  checkType                        return DoComplexDispatch lt C gt  this    amp   auto  other  - gt  decltype auto                                        other- gt template DoVirtualGeneric lt T  false gt                                           std  cout  lt  lt   quot C quot             class D   public C   public      virtual Type  GetType             return typeOf lt D gt               int main         A  a   new A        a- gt DoVirtualGeneric lt int gt           --------------------------  template lt typename Tuple gt  class RestTuple      template lt      template lt typename    gt  typename Tuple      typename First      typename    Rest  gt  class RestTuple lt Tuple lt First  Rest    gt  gt    public      using type   Tuple lt Rest    gt          ------------- template lt      typename CandidatesTuple       typename Result       typename From       typename Action  gt  inline constexpr Result DoComplexDispatchInternal From  from  Action amp  amp  action  Type  fromType        using FirstCandidate   std  tuple element t lt 0  CandidatesTuple gt        if constexpr  std  tuple size v lt CandidatesTuple gt     1                return action static cast lt FirstCandidate  gt  from              else           if  fromType    typeOf lt FirstCandidate gt                           return action static cast lt FirstCandidate  gt  from                      else               return DoComplexDispatchInternal lt typename RestTuple lt CandidatesTuple gt   type  Result gt                   from  action  fromType                                   template lt      typename Calling       typename Result       typename From       typename Action  gt  inline Result DoComplexDispatch From  from  Action amp  amp  action        using ChildsOfCalling   typename ChildClasses lt Calling gt   type      if constexpr  std  tuple size v lt ChildsOfCalling gt     0                return action static cast lt Calling  gt  from              else           auto fromType   from- gt GetType            using Candidates   decltype std  tuple cat std  declval lt std  tuple lt Calling gt  gt     std  declval lt ChildsOfCalling gt               return DoComplexDispatchInternal lt Candidates  Result gt               from  std  forward lt Action gt  action   fromType                     The only thing I don t like is that you have to define register all child classes

User · Answer

In the other answers the proposed template function is a facade and doesn t offer any practical benefit    Template functions are useful for writing code only once using different types   Virtual functions are useful for having a common interface for different classes    The language doesn t allow virtual template functions but with a workaround it is possible to have both  e g  one template implementation for each class and a virtual common interface   It is however necessary to define for each template type combination a dummy virtual wrapper function    include  lt memory gt   include  lt iostream gt   include  lt iomanip gt     ---------------------------------------------    Abstract class with virtual functions class Geometry   public      virtual void getArea float  amp area    0      virtual void getArea long double  amp area    0        ---------------------------------------------    Square class Square   public Geometry   public      float size  1           virtual wrapper functions call template function for square     virtual void getArea float  amp area    getAreaT area         virtual void getArea long double  amp area    getAreaT area      private         Template function for squares     template  lt typename T gt      void getAreaT T  amp area            area   static cast lt T gt  size   size               ---------------------------------------------    Circle class Circle   public Geometry    public      float radius  1           virtual wrapper functions call template function for circle     virtual void getArea float  amp area    getAreaT area         virtual void getArea long double  amp area    getAreaT area      private         Template function for Circles     template  lt typename T gt      void getAreaT T  amp area            area   static cast lt T gt  radius   radius   3 1415926535897932385L                ---------------------------------------------    Main int main            get area of square using template based function T float     std  unique ptr lt Geometry gt  geometry   std  make unique lt Square gt         float areaSquare      geometry- gt getArea areaSquare           get area of circle using template based function T long double     geometry   std  make unique lt Circle gt         long double areaCircle      geometry- gt getArea areaCircle        std  cout  lt  lt  std  setprecision 20   lt  lt   Square area is    lt  lt  areaSquare  lt  lt     Circle area is    lt  lt  areaCircle  lt  lt  std  endl      return 0      Output       Square area is 1  Circle area is 3 1415926535897932385   Try it here

User · Answer

No they can t   But   template lt typename T gt  class Foo   public    template lt typename P gt    void f const P amp  p          T  this - gt f lt P gt  p           class Bar   public Foo lt Bar gt    public    template lt typename P gt    void f const P amp  p        std  cout  lt  lt  p  lt  lt  std  endl          int main       Bar bar     Bar  pbar    amp bar    pbar - gt  f 1      Foo lt Bar gt   pfoo    amp bar    pfoo - gt  f 1        has much the same effect if all you want to do is have a common interface and defer implementation to subclasses

[c++] Can a class member function template be virtual?

Examples related to c++

Examples related to templates

Examples related to virtual-functions

Examples related to function-templates

Examples related to c++-faq