类型安全的可变参数函数

Question

我想编写一个接受可变数量的字符串文字的函数。如果我用 C 语言编写，我将不得不编写如下内容：

void foo(const char *first, ...);

然后调用看起来像：

foo( "hello", "world", (const char*)NULL );

感觉应该可以在 C++ 中做得更好。我想出的最好的是：

template <typename... Args>
void foo(const char* first, Args... args) {
    foo(first);
    foo(args);
}

void foo(const char* first) { /* Do actual work */ }

称为：

foo("hello", "world");

但我担心，如果有人调用foo("bad", "argument", "next", 42)，递归性质以及我们在得到单个参数之前不进行任何类型检查的事实会使错误令人困惑。我想要写的是这样的：

void foo(const char* args...) {
    for (const char* arg : args) {
        // Real work
    }
}

有什么建议吗？

编辑：还有void fn(std::initializer_list<const char *> args) 的选项，但这使得我想避免调用foo({"hello", "world"});。

Answer 1

我想你可能想要这样的东西：

template<class... Args,
    std::enable_if_t<(std::is_same_v<const char*, Args> && ...), int> = 0>
void foo(Args... args ){
    for (const char* arg : {args...}) {
        std::cout << arg << "\n";
    }
}

int main() {
    foo("hello", "world");
}

Answer 2

注意：不可能只匹配字符串文字。最接近的方法是匹配 const char 数组。

要进行类型检查，请使用带有 const char 数组的函数模板。

要使用基于范围的for 循环它们，我们需要将其转换为initializer_list<const char*>。我们可以直接在基于范围的for 语句中使用大括号，因为数组会衰减为指针。

这是函数模板的样子（注意：这适用于零个或多个字符串文字。如果您想要一个或多个，请将函数签名更改为至少采用一个参数。）：

template<size_t N>
using cstring_literal_type = const char (&)[N];

template<size_t... Ns>
void foo(cstring_literal_type<Ns>... args)
{
    for (const char* arg : {args...})
    {
        // Real work
    }
}

Answer 3

虽然所有其他答案都可以解决问题，但您也可以执行以下操作：

namespace detail
{
    void foo(std::initializer_list<const char*> strings);
}

template<typename... Types>
void foo(const Types... strings)
{
    detail::foo({strings...});
}

这种方法似乎（至少在我看来）比使用 SFINAE 更具可读性，并且适用于 C++11。此外，它还允许您将 foo 的实现移动到 cpp 文件中，这也可能很有用。

编辑：至少对于 GCC 8.1，我的方法在使用非 const char* 参数调用时似乎会产生更好的错误消息：

foo("a", "b", 42, "c");

这个实现编译：

test.cpp: In instantiation of ‘void foo_1(const ArgTypes ...) [with ArgTypes = {const char*, int, const char*, const char*}]’:
test.cpp:17:29:   required from here
test.cpp:12:16: error: invalid conversion from ‘int’ to ‘const char*’ [-fpermissive]
 detail::foo({strings...});
 ~~~~~~~~~~~^~~~~~~~~~~~~~

虽然基于 SFINAE（liliscent 的实现）产生：

test2.cpp: In function ‘int main()’:
test2.cpp:14:29: error: no matching function for call to ‘foo(const char [6], const char [6], int)’
     foo("hello", "world", 42);
                         ^
test2.cpp:7:6: note: candidate: ‘template<class ... Args, typename std::enable_if<(is_same_v<const char*, Args> && ...), int>::type <anonymous> > void foo(Args ...)’
 void foo(Args... args ){
  ^~~
test2.cpp:7:6: note:   template argument deduction/substitution failed:
test2.cpp:6:73: error: no type named ‘type’ in ‘struct std::enable_if<false, int>’
     std::enable_if_t<(std::is_same_v<const char*, Args> && ...), int> = 0>

Answer 4

+1 用于 C++17 liliscent 的解决方案。

对于 C++11 解决方案，一种可能的方法是创建一个类型特征来生成多个值的“与”（类似于std::conjunction，不幸的是，它仅从 C++17 开始可用。 . 当你可以使用折叠并且不再需要 std::conjunction 时（感谢 liliscent）。

template <bool ... Bs>
struct multAnd;

template <>
struct multAnd<> : public std::true_type
 { };

template <bool ... Bs>
struct multAnd<true, Bs...> : public multAnd<Bs...>
 { };

template <bool ... Bs>
struct multAnd<false, Bs...> : public std::false_type
 { };

所以foo()可以写成

template <typename ... Args>
typename std::enable_if<
      multAnd<std::is_same<char const *, Args>::value ...>::value>::type
   foo (Args ... args )
 {
    for (const char* arg : {args...}) {
        std::cout << arg << "\n";
    }
 }

使用C++14，multAnd()可以写成constexpr函数

template <bool ... Bs>
constexpr bool multAnd ()
 {
   using unused = bool[];

   bool ret { true };

   (void)unused { true, ret &= Bs ... };

   return ret;
 }

所以foo()变成了

template <typename ... Args>
std::enable_if_t<multAnd<std::is_same<char const *, Args>::value ...>()>
   foo (Args ... args )
 {
    for (const char* arg : {args...}) {
        std::cout << arg << "\n";
    }
 }

--- 编辑---

Jarod42（谢谢！）提出了一种更好的方法来开发multAnd；像

template <typename T, T ...>
struct int_sequence
 { };

template <bool ... Bs>
struct all_of : public std::is_same<int_sequence<bool, true, Bs...>,
                                    int_sequence<bool, Bs..., true>>
 { };

从 C++14 开始可以使用std::integer_sequence 而不是模仿的（int_sequence）。

Answer 5

在逗号运算符上使用C++17 fold expressions，您可以简单地执行以下操作：

#include <iostream>
#include <string>
#include <utility>

template<typename OneType>
void foo_(OneType&& one)
{
    std::cout << one;
}

template<typename... ArgTypes>
void foo(ArgTypes&&... arguments)
{
    (foo_(std::forward<ArgTypes>(arguments)), ...);
}

int main()
{
    foo(42, 43., "Hello", std::string("Bla"));
}

Live demo here。注意我在模板中使用了foo_，因为我懒得写出4个重载。

---

如果您真的真的很想将其限制为字符串文字，请按照 Nevin 的回答建议更改函数签名：

#include <cstddef>
#include <iostream>
#include <string>
#include <utility>

template<std::size_t N>
using string_literal = const char(&)[N];

template<std::size_t N>
void foo(string_literal<N> literal)
{
    std::cout << literal;
}

template<std::size_t... Ns>
void foo(string_literal<Ns>... arguments)
{
    (foo(arguments), ...);
}

int main()
{
    foo("Hello", "Bla", "haha");
}

Live demo here.

请注意，这与 C++11 语法非常接近，以实现完全相同的目标。参见例如this question of mine.

Answer 6

好吧，你可以得到最接近的函数，它接受任意数量的const char*，但没有其他使用模板函数和转发：

void foo_impl(std::initializer_list<const char*> args)
{
    ...
}

template <class... ARGS>
auto foo(ARGS&&... args)
-> foo_impl({std::forward<ARGS>(args)...})
{
    foo_impl({std::forward<ARGS>(args)...});
}

微妙之处在于允许正常的隐式转换。

Answer 7

#include<type_traits>
#include<iostream>

auto function = [](auto... cstrings) {
    static_assert((std::is_same_v<decltype(cstrings), const char*> && ...));
    for (const char* string: {cstrings...}) {
        std::cout << string << std::endl;
    }
};

int main(){    
    const char b[]= "b2";
    const char* d = "d4";
    function("a1", b, "c3", d);
    //function(a, "b", "c",42); // ERROR
}

Answer 8

而现在……完全不同的东西……

你可以写一个类型包装结构如下

template <typename, typename T>
struct wrp
 { using type = T; };

template <typename U, typename T>
using wrp_t = typename wrp<U, T>::type;

而foo() 函数接收char const * 的可变参数列表就变成了

template <typename ... Args>
void foo (wrp_t<Args, char const *> ... args)
 {
   for ( char const * arg : {args...} )
      std::cout << "- " << arg << std::endl;
 }

问题是你不能随心所欲地调用它

foo("hello", "world");

因为编译器无法推断出Args... 类型。

显然你可以显式列出一个虚拟类型

 foo<void, void>("hello", "world");

但我知道这是一个糟糕的解决方案。

无论如何，如果你接受通过一个微不足道的模板函数

template <typename ... Args>
void bar (Args ... args)
 { foo<Args...>(args...); }

你可以打电话

bar("hello", "world");

以下是完整的 C++11 工作示例

#include <iostream>

template <typename, typename T>
struct wrp
 { using type = T; };

template <typename U, typename T>
using wrp_t = typename wrp<U, T>::type;

template <typename ... Args>
void foo (wrp_t<Args, char const *> ... args)
 {
   for ( char const * arg : {args...} )
      std::cout << "- " << arg << std::endl;
 }

template <typename ... Args>
void bar (Args ... args)
 { foo<Args...>(args...); }

int main ()
 {
   bar("hello", "world"); // compile

   // bar("hello", "world", 0);  // compilation error
 }

Answer 9

当然可以，这样编译运行你想要的（注意）

#include<iostream>
                                                                                          template<class... Char>
                                                                                          // hehe, here is the secret      
auto foo(const Char*... args )                                                            ->decltype((char const*)(*std::begin({args...})), (char const*)(*std::end({args...})), void(0))
{
    for (const char* arg : {args...}) {
        std::cout << arg << "\n";
    }
}

int main() {
    foo("no", "sense","of","humor");
}

这是@liliscent 解决方案，但加了更多糖，为了取悦@rubenvb，没有enable_if。 如果您认为额外的代码是注释（不是），请注意，您会看到您正在寻找的语法。

请注意，您只能提供可转换为 char const* 的同类事物列表，这似乎是您的目标之一。