C变量模板返回类型

Question

我的函数使用一组给定的输入参数（变量）调用Python函数，并返回包含函数输出的元组（变量，因为输出随调用的函数而变化）。

我正在使用C 11通过MinGW-w64编译器的g端口在视窗10机器上编译。我声明了这个模板变量函数（并调用它）如下：

// Declaration (in PyInterface.h)
template <typename... Inputs, typename... Outputs>
const std::tuple<Outputs...>& callFunction(const std::string &modulePath, const std::string &funcName, Inputs&&... args) { 
    // Calls a Python function & packs output variables into a std::tuple... 
}

// Sample call (in main.cpp)
const std::tuple<std::string, std::string> output = pi.callFunction(myModulePath, myFuncName, inputArg1, inputArg2, inputArg3);

但是，会引发此错误（为了可读性，缩短为…）：

从“const std:：tuple”转换

据我所知，使用两个可变模板是合法的。此外，在我看来，返回类型是由变量（const std:：tuple）显式设置的

最初，我认为这个错误只是表明我没有适当地使用变量模板。我尝试使用嵌套模板参数（如图所示）来指定返回类型（即，const T

这个错误表明我的直觉是错误的，并且在我的原始函数中，编译器没有从输出的类型推断出所需的返回类型。

为什么我的直觉错了？如何正确使用变量模板来指定函数的返回类型？




Answer 1

与C编译器错误消息一样，您只需要查看第一个错误消息。我猜测（因为您没有提供代码）您正在创建一个tuple值，然后返回对它的const引用。在函数的末尾，元组被销毁，那么引用应该指什么？你应该只返回元组

我认为您可以通过交换输入和输出类型包来实现您想要的。此代码还说明了使用show功能在输入类型包上迭代。您可以做类似的事情来构建元组

#include <iostream>
#include <tuple>
#include <utility>

using namespace std;

template< typename Output > struct convert_t;
template<> struct convert_t< string >
{
    string operator()( const char *text ) const
    {
        return text;
    }

    string operator()( double val ) const
    {
        return to_string( val );
    }
};

inline void show()
{}

template< typename First, typename... Others >
inline void show( First &&first, Others&&... others )
{
    cout << first << "\n";
    show( forward< Others >( others )... );
}

template< typename... Outputs, typename... Inputs >
inline tuple< Outputs... > funkyfunc( Inputs&&... inputs )
{
    cout << "Inputs...\n";
    show( forward< Inputs >( inputs )... );
    return tuple< Outputs... >( convert_t< Outputs >()( inputs )... );
}

int main()
{
    auto t = funkyfunc< string, string >( "text", 123.0 );
    cout << "Outputs...\n";
    cout << get<0>( t ) << "\n";
    cout << get<1>( t ) << "\n";

    return 0;
}

Answer 2

如果您想根据函数范围内返回的对象的类型推断返回类型，如果您在C 14上，则可以使用auto作为返回类型。它很有魅力

template <typename... Inputs>
const auto& callFunction(
    const std::string &modulePath, 
    const std::string &funcName, 
    Inputs&&... args) { 

    return object;
}

与往常一样，要注意从这个函数返回一个const引用。

如果您使用的是C11，那么您可以使用尾随返回类型，例如

template <typename T>
auto identity_return(T& obj) -> decltype(obj) {
    return obj;
}

其中dectype（obj）是要返回的东西的类型。再次注意，在这种情况下，它再次是一个参考。

通常，尽管try和return值来自函数，但如果您不确定返回的内容是否比返回的时间长，则返回的引用可能会导致挂起引用。

另一个解决方案是只指定输出 类型列表，让编译器推断类型输入

template <typename... Outputs, typename... Inputs>
const std::tuple<Outputs...>& callFunction(
    const std::string &modulePath, 
    const std::string &funcName, 
    Inputs&&... args) { ... }

auto tup = callFunction<std::string, std::string>(modulePath, funcName, args);