C++ template usage based on selecting type dynamically

Question

I'm trying to find an efficient way to invoke a specific C++ template type based dynamic value of a variable. Currently I'm not clear on how to approach this, except by using large and ugly if/else selector for a large set of permutations as in the example below. As you can see this is not pretty.

Instead I'd like to invoke suitable template dynamically without huge if/else selector...

Any advise from the C++ template masters out there would be much appreciated.

// crude generic data converter template invoked based on dynamic in/out buffer type
template <class dstType, class srcType>
void ConvertCopy(unsigned char* dst, const unsigned char* src, int size)
{
    // requires same in/out buffer same dimensions
    if (typeid(srcType) != typeid(dstType)) 
    {
        dstType* c_dst = (dstType*)dst;
        srcType* c_src = (srcType*)src;
        for(int i=0;i<size;i++)
            c_dst[i] = (dstType)c_src[i];
    }
    else
        memcpy(dst, src, size * sizeof(srcType)); // Plain copy
}

void test()
{
    const int buffersize = 100;

    int inbuffer[buffersize];
    double outbuffer[buffersize];
    unsigned char* anyIn = (unsigned char*)inbuffer;
    unsigned char* anyOut = (unsigned char*)outbuffer;

    int my_in_type = 1;
    int my_out_type = 3;

    if(my_in_type == 1) { // int
        if(my_out_type == 1) ConvertCopy<int, int>(anyOut, anyIn, buffersize); // int -> int
        if(my_out_type == 2) ConvertCopy<float, int>(anyOut, anyIn, buffersize); // int -> float
        if(my_out_type == 3) ConvertCopy<double, int>(anyOut, anyIn, buffersize); // int -> double
        // ...
    }
    else if(my_in_type == 2) { // unsigned int
        if(my_out_type == 1) ConvertCopy<int, unsigned int>(anyOut, anyIn, buffersize); // unsigned int -> int
        if(my_out_type == 2) ConvertCopy<float, unsigned int>(anyOut, anyIn, buffersize); // unsignedint -> float
        if(my_out_type == 3) ConvertCopy<double, unsigned int>(anyOut, anyIn, buffersize); // unsigned int -> double
        // ...
    }
    else {}
    // ...
}

So you just need one if/else branch based on whether the types are the same or not? — songyuanyao
– songyuanyao, Commented Dec 4, 2019 at 1:04
Off-topic: int size? How meaningful are sizes like -1, -7, -10, -12, ...??? — Aconcagua
– Aconcagua, Commented Dec 4, 2019 at 1:23
memcpy can fail badly if applied on complex types like std::string. Better use std::copy instead, if templates are involved. — Aconcagua
– Aconcagua, Commented Dec 4, 2019 at 1:24
Templates and dynamic types are contradictory concepts. If you can, let template parameters get deduced: convertCopy(DstType* dst, SrcType const* src). If you cannot, a lookup table might be an option: void (*pointers[])(unsigned char*, unsigned char const*, size_t) = { convertCopy<int, int>, convertCopy<int, double>, ... };. Then you could calculate the appropriate index with outType * NumberOfTypes + inType. — Aconcagua
– Aconcagua, Commented Dec 4, 2019 at 1:37

Davis Herring · Accepted Answer · 2019-12-04 06:36:05Z

3

There’s no way (short of the very young JIT proposals) to avoid a branch or lookup table: it is a feature that different specializations of a function template can have unrelated types (with some restrictions on the parameter types, especially when supporting deduction), making it implausible to support a call with a dynamic template argument in the type system even if it were known to be drawn from a small set. (Yours all happen to be void(unsigned char*,const unsigned char*,int), but for consistency the rules do not consider that.)

That said, the boilerplate can be expressed efficiently in cases like this where the type doesn’t vary:

template<class D>
auto copier(int s) {
  switch(s) {
  case 1: return ConvertCopy<D,int>;
  case 2: return ConvertCopy<D,unsigned>;
  // …
  }
}
void test() {
  // …
  [](int d) {
    switch(d) {
    case 1: return copier<int>;
    case 2: return copier<float>;
    case 3: return copier<double>;
    // …
    }
  }(my_out_type)(my_in_type)(anyOut,anyIn,buffersize);
}

This approach reduces the verbosity to O(m+n) from O(mn). It may help if you think of the extra sets of parentheses as being separate because they are like “runtime template argument lists”.

It would of course be possible to generalize this to produce a value of any consistent type from a metafunction with (for practicality) a known range of interesting inputs.

answered Dec 4, 2019 at 6:36

Davis Herring

42.1k4 gold badges59 silver badges92 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

globbolg Over a year ago

thanks for clarifying the subject with limitations and available options.

Drake Johnson · Accepted Answer · 2019-12-04 06:43:31Z

0

MSVC compiles down to it's .NET code (oversimplification), which allows you to use elements from other Microsoft languages. In Visual C++, there is a keyword known as 'generic` and it works like a template but may allow for what you're wanting.

Microsoft has a few pages of documentation on this, but here is the link to the overview page.

answered Dec 4, 2019 at 6:43

Drake Johnson

6844 silver badges23 bronze badges

Collectives™ on Stack Overflow

C++ template usage based on selecting type dynamically

2 Answers 2

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related