C++ 按值比较可变参数

有没有办法比较每种类型的变量模板的值

template<typename... S>
class Signature {
    // this is not valid syntax
    S... values;

    bool equals(S... s) {
        // this is not either
        bool eq = true;
        eq &= s... &= values...;
        return eq;
    }
};

模板
类签名{
//这是无效的语法
价值观；
布尔等于（S…S）{
//这也不是
布尔均衡=真；
等式&=s…&=values。。。；
返回均衡器；
}
};

例如：

Signature<int, bool> s(5, true);
s.equals(5, true); // should result in 1

签名s（5，真）；
s、 等于（5，真）；//结果应该是1

在中，我们只需：

std::tuple<S...> values;
bool equals(S const&...s) const {
  return std::apply([&](S const&... values){
    return ((values==s)&&...);
  }, values);
}

并将其放入

名称空间notstd

。您还需要放置折叠：

return ((values==s)&&...);

与

---

在中，您需要用尾部返回类型替换

decltype（auto）

，并实现您自己的索引序列代码。

我看到的真正问题是。。。什么是

S ... values;

在你们班

这不是C++，据我所知，

我想您可以将值保存在

std:：tuple

std::tuple<S...> value;

在C++14中，不能像在C++17中那样使用折叠表达式，因此必须修改helper函数（

equalH（）

）；我提议如下：

   template <std::size_t ... Is>
   bool equalsH (std::index_sequence<Is...> const &, Ts const & ... ts)
    { 
      using unused = int[];

      bool ret { true };

      (void)unused { 0, (void(ret &= (ts == std::get<Is>(values))), 0) ... };

      return ret;
    }

这：

他身体不好。您不能有这样的包声明（很遗憾）。你必须把所有的值放在某个地方，比如：

std::tuple<S...> values;

---

c++11、c++14或c++17？没关系（，但c++11会更好）。哇，这很简单！为什么要命名变量

rhs

？我只是想引起兴趣。@Paul Programmernoob只是因为它在平等的右边。

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

template <typename ... Ts>
struct Signature
 {    
   std::tuple<Ts...> values;

   Signature (Ts && ... ts) : values { std::forward<Ts>(ts) ... }
    { }

   template <std::size_t ... Is>
   bool equalsH (std::index_sequence<Is...> const &, Ts const & ... ts)
    { return ((ts == std::get<Is>(values)) && ... ); }

   bool equals (Ts const & ... ts)
    { return equalsH(std::make_index_sequence<sizeof...(Ts)>{}, ts...); }
 };

int main ()
 {
   Signature<int, bool> s { 5, true };

   std::cout << s.equals(5, true) << std::endl;  // print 1
   std::cout << s.equals(5, false) << std::endl; // print 0
   std::cout << s.equals(6, false) << std::endl; // print 0
   std::cout << s.equals(6, true) << std::endl;  // print 0
 }

   template <std::size_t ... Is>
   bool equalsH (std::index_sequence<Is...> const &, Ts const & ... ts)
    { 
      using unused = int[];

      bool ret { true };

      (void)unused { 0, (void(ret &= (ts == std::get<Is>(values))), 0) ... };

      return ret;
    }

bool equals (Ts && ... ts)
 { return values == std::forward_as_tuple( std::forward<Ts>(ts) ... ); }

S... values;

std::tuple<S...> values;

template<typename... S>
struct Signature {
    std::tuple<S...> values;

    bool equals(Signature<S...> const& rhs) const {
        return values == rhs.values;
    }

    bool equals(S const&... rhs) const {
        // forward here to produce a tuple<S const&...> and avoid an unnecessary copy
        return values == std::forward_as_tuple(rhs...);
    }
};