小编man*_*ana的帖子

CppCoreGuidelines 声明应为所有模板参数指定概念。（参见：T.10：指定所有模板参数的概念）作为定义概念的实践，我尝试使用为哈希函数和键模板参数定义的概念构建一个哈希表。

我希望我的哈希表使用两个模板参数，HashFunc并且Key. HashFunc应该是一个函数对象并且Key应该是该函数对象的参数HashFunc。

也就是说，HashFunc(Key)应该返回一个可转换为的类型size_t。

在cppreference上，有一个定义概念的示例Hashable。我复制了下面的例子：

template<typename T>\nconcept Hashable = requires(T a) {\n    { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;\n};\n

这个Hashable概念对于许多用途来说都是有意义的。在这些情况下，类型对象上的哈希函数T是特化的std::hash<T>。然而，就我的目的而言，我不想假设哈希将是std::hash<Key>. 我希望用户能够提供不同的哈希函数。

由于HashFunc和 的Key联系如此紧密，我认为我无法为HashFunc和定义单独的概念Key。那是对的吗？所以我想定义一个概念HashConcept来处理HashFunc和Key。

所以我定义了一个 Hash可以同时处理这两者的概念。我尽力定义这个概念，使其符合此处的命名Hash 要求。那么目标是满足 4 …

我正在尝试将递归与可变参数模板一起使用。我希望基本情况具有零模板参数。在查看了以前问题的 stackoverflow 答案后，我发现了对这个问题的两种回应：

1. 你不应该专门化模板函数。赫伯·萨特 (Herb Sutter) 在这里写道：http : //www.gotw.ca/publications/mill17.htm
2. 您使用template <typename = void> 或template <typename T = void> 。例如，这里的第一个答案：如何编写可变参数模板递归函数？

我试图在我的问题中使用解决方案 (2)，但收到错误。这是一个最小的、可重现的示例：

#include <iostream>

template<typename = void> // base case
int NumArguments() {
    return 0;
}

template<typename FirstArg, typename... RemainingArgs>
int NumArguments() {
    return 1 + NumArguments<RemainingArgs...>();
}

class A {
public:
    A() {}
};

int main() {
    std::cout << NumArguments<A>();
    return 0;
}

在 Microsoft Visual C++20 中编译给出了错误：

 error C2668: 'NumArguments': ambiguous call to overloaded function …

我正在编写 LeetCode 问题“奇偶链表”的解决方案，可以在此处阅读。

我的代码未通过测试用例并出现错误

================================================================
==31==ERROR: AddressSanitizer: heap-use-after-free on address 0x6020000000d8 at pc 0x0000003d7f1d bp 0x7fff37cf9640 sp 0x7fff37cf9638
READ of size 8 at 0x6020000000d8 thread T0

但是，当我在 Visual Studio 中运行代码来诊断错误时，一切正常。LeetCode的解决方案在这里：

class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        
        if (!head){
            return head;
        }
        
        ListNode* odd_head = head;
        ListNode* even_head = odd_head->next;
        
        if (!even_head){
            return head;
        }
        
        ListNode* last_odd = odd_head;
        ListNode* last_even = even_head;
        ListNode* next_node = even_head->next;
        
        bool flag = true;
        
        while(true){
            if (!next_node){
                break;
            }
            if …

我有一个类B，它将类A作为模板参数。

template<typename T>
class B{
///...

每个T都有一个operator()()返回一个std::array<double, N>。我希望每个专业B<T>都能够在N没有额外要求的情况下推断Ts 并且无需调用operator()(). 我怎样才能做到这一点？

T下面是一个示例并标记为class A：

template <int N>
class A {
public:
    A() {}

    std::array<double, N> operator()() {
        std::array<double, N> the_integers;
        for (int i = 0; i < N; ++i) {
            the_integers[i] = i;
        }
        return the_integers;
    }
};