CODEWITHSUNDEEP
c++c++11templatesvariadic-templates
MatthewL
MatthewL

Reputation: 65

Force template deduction from a function to produce const references where applicable

running through the following function using gdb in vscode tells me that the deduced argTypes for a function of the form T (*)(const int &, const int *, int &, int) are int const int * int & and int respectively. Is there any way to force the compiler to deduce const Type & when presented with a const Type & argument? Or is there some other means by which I can extract that type information in a useful way?

#include<typeinfo>

template<typename T, typename...argTypes>
void testfunc(T (*f)(argTypes...))
{
    const char *a[] = { typeid(argTypes).name()... };
    for(auto &av :a)
    {
        std::cout << av << std::endl;
    }
}

edit: A little more context: this function obviously does little to nothing, but the problem function that spawned it also takes in all the arguments to be run with f in a way that they are not deduced, but converted. This presents a problem for non-copyable objects to be used as const references.

An example of using testfunc is as follows:

#include "testfunc.h"

std::vector<bool> funcToTest(const int &a, const int *b, int &c, int d)
{
    std::vector<bool> out;
    out.push_back(&a == b);
    out.push_back(&c == b);
    out.push_back(&d == b);
    return out;
}

int main()
{
    // put a breakpoint here, and step in, you would see that 'a'
    // describes the situation as described above.
    testfunc(funcToTest);
}

Upvotes: 0

Views: 97

Answers (1)

NathanOliver
NathanOliver

Reputation: 180630

The issue here is with typeid, not template deduction. If you use

template<typename... Ts>
struct types;

template<typename T, typename...argTypes>
void testfunc(T (*f)(argTypes...))
{

    types<argTypes...>{};
}

You get an nice error message like

main.cpp: In instantiation of 'void testfunc(T (*)(argTypes ...)) [with T = std::vector<bool>; argTypes = {const int&, const int*, int&, int}]':
main.cpp:30:24:   required from here
main.cpp:12:5: error: invalid use of incomplete type 'struct types<const int&, const int*, int&, int>'
   12 |     types<argTypes...>{};
      |     ^~~~~
main.cpp:7:8: note: declaration of 'struct types<const int&, const int*, int&, int>'
    7 | struct types;
      |        ^~~~~

which shows you that the function parameter types are correctly deduced.

With typeid if the type is a reference, then it returns the referred to type. It also drops all cv-qualifactions on the types. That means

int main()
{
    std::cout << typeid(int).name() << "\n";
    std::cout << typeid(int&).name() << "\n";
    std::cout << typeid(const int).name() << "\n";
    std::cout << typeid(const int&).name() << "\n";
    std::cout << typeid(volatile int).name() << "\n";
    std::cout << typeid(volatile int&).name() << "\n";
    std::cout << typeid(const volatile int).name() << "\n";
    std::cout << typeid(const volatile int&).name() << "\n";
}

prints

i
i
i
i
i
i
i
i

Upvotes: 2

Related Questions