Btukfyl

I'm building a C++/CLI DLL to be able to communicate a plain C++ DLL with a C# application. The plain C++ DLL is third party provided and I have no way to modify it.

That plain C++ DLL contains some member function templates, in the way:

1. 
   

   plain C++ DLL header file:

   
   
   

   class pureCPP
   
   {
   
       template<typename T>
   
       void usefulFunctionA(T &b, T const &a)
   
       {
   
           /* Implementation of the function */
   
       }
   
   }
   
   

   
   

So my idea would be to reflect that in the CLI DLL header file:

2. 
   

   CLI DLL header file:

   
   
   

   public ref class CLI_DLL
   
   {
   
       template<typename T>
   
       void usefulFunctionB(T &b, T const &a)
   
       {
   
           pureCppPtr->usefulFunctionA(b, a);
   
       }
   
   
   
       PureCPP *pureCppPtr;
   
   }
   
   

   
   

And then in the C# executable for example simply call:

CLI_DLL cliDLL = new CLI_DLL;

double a, b;

cliDLL.usefulFunctionB<double>(a, b);

Is this doable? Or am I forced to simply instantiate overloads for every possible type of the function template?

I've read C# has something called generics, could I use that technique to achieve something like this? So far, every article I've found refers either to class templates (not just methods within them) or suggests to do explicit instantiation in the CLI of the desired types, which is what I'd like to avoid if possible (suppose each function can be used by 1000 different types...I guess it wouldn't be so nice to replicate the 1000 different instantiations).

I'm a completely newbie to C#, but AFAIU, passing arguments (in this case, a type) from a generic function to a template wouldn't be doable since the former are resolved at runtime while the latter is done at compile time, in which case I'd be forced to change the previous implementation to something like this:

• 
  

  CLI DLL header file:

  
  
  

  public ref class CLI_DLL
  
  {
  
      /* Only define the template here */
  
      template<typename T>
  
      void usefulFunctionB(T &b, T const &a);
  
  
  
      PureCPP *pureCppPtr;
  
  }
  
  

  
  


• 
  

  CLI DLL source file:

  
  
  

  /* Explicitly instantiate the template in the source file */
  
  template<>CLI_DLL::usefulFunctionB<double>(double &A, double const &B)
  
  {
  
      pureCppPtr->usefulFunctionA<double>(b, a);
  
  }
  
  

  
  

on so on for every type I need. The other way (template to generic) seems to be possible though, right?

(BTW, and as a side question, is it really necessary to explicit the type being called, "double" in this case? I've never really understood why in some cases, Visual Studio is not able to automatically deduct types from templates, as CLang or GCC are).

Which is what I'd really, REALLY liked to avoid, and instead, I'd love to be able to do something like the first code I exposed.

Thanks a lot in advance.