asimes's questions

是否存在允许method1在类之外定义的语法，或者这是否不符合 SFINAE 友好标准？

#include <type_traits>

template <int TClass>
struct SampleClass {
    // This definition compiles just fine
    template <int TMethod = TClass>
    typename std::enable_if<TMethod == 0, void>::type
    method0() {}

    // Declaration
    template <int TMethod = TClass>
    typename std::enable_if<TMethod == 1, void>::type
    method1();
};

// This does not compile
template <int TClass>
template <int TMethod = TClass>
typename std::enable_if<TMethod == 1, void>::type
SampleClass<TClass>::method1() {}

int main() { return 0; }

使用GCC 10.2.1，错误：

foo.cpp:20:30: error: default argument for template parameter for class enclosing 'typename std::enable_if<(TMethod == 1), void>::type SampleClass<TClass>::method1()'
   20 | SampleClass<TClass>::method1() {}
      |                              ^

#include <unistd.h>

#include <csignal>
#include <exception>
#include <functional>
#include <iostream>

std::function<void(int)> g_signalHandler;

void signalWrapper(const int a) { g_signalHandler(a); }

int main() {
    bool abort = false;
    g_signalHandler = [&abort](const int) {
        std::cout << "Abort" << std::endl;
        abort = true;
    };

    struct ::sigaction signalAction = {};
    signalAction.sa_handler = signalWrapper;

    if (
        ::sigaction(SIGHUP,  &signalAction, nullptr) != 0 ||
        ::sigaction(SIGINT,  &signalAction, nullptr) != 0 ||
        ::sigaction(SIGTERM, &signalAction, nullptr) != 0
    )
        throw std::exception();

    // Is it guaranteed that the new value of abort will be seen here without
    // the need of std::atomic<bool> or volatile bool?
    while (!abort)
        ::sleep(1);

    return 0;
}

假设一个单线程程序、C++17 和 Linux

据我所知，使用普通的bool就足够了，while (!abort)并且std::atomic<bool>/volatile bool不是必要的。我想确认这始终是正确的，并且我不必担心编译器优化读取值

我正在阅读其他人的代码，其中包含类似于boost::functionor 的自定义函数类std::function。他们通过不断的引用来传递这些函数类。在关键路径的一节中，他们选择使用函数指针，但仍然通过不断引用来提高效率

他们的代码中有类似的内容：

using FuncT = int(*)(int, int);

这是这样传递的：

const FuncT&

我认为const FuncT&传递的效率并不比它高，FuncT而且语法只是最初的自定义函数类的剩余部分。然而这让我想知道这是什么const FuncT意思

#include <iostream>

using FuncT = int(*)(int, int);

struct MyClass final {
    static int myMethod(int a_arg1, int a_arg2) {
        std::cout << a_arg1 << " " << a_arg2 << std::endl;
        return 0;
    }

    // Similar to what I found in someone's code
    void v1(const FuncT& a_func) { a_func(1, 1); }

    // A reference to a const function pointer seems meaningless, it should be
    // just as efficient to copy the pointer
    void v2(const FuncT  a_func) { a_func(2, 2); }
    //                 ^
    //                 Removed reference

    // I believe this is the syntax for a function pointer that cannot be
    // modified to point to a different function
    void v3(      int(* const a_func)(int, int)) { a_func(3, 3); }
    //                  ^
    //                  Added const not present in FuncT

    // This compiles but I don't know what the intended meaning of the extra
    // const would be
    void v4(const int(* const a_func)(int, int)) { a_func(4, 4); }
    //      ^
    //      Added const not present in v3
};

int main() {
    MyClass myClass;
    myClass.v1(&MyClass::myMethod);
    myClass.v2(&MyClass::myMethod);
    myClass.v3(&MyClass::myMethod);
    //myClass.v4(&MyClass::myMethod); // Doesn't compile
    return 0;
}

上面的代码v4可以编译，但是最左边的含义是什么const？

在我的真实代码中，我正在解析一系列作为连续消息的字节。消息头中的整数决定解释字节的适当方式

为了简化 SO 假设如下：

• 1意味着使用struct MsgA
• 2意味着使用struct MsgB
• 3意味着使用struct MsgC
• 任何其他值均无效

另外对于 SO 假设有一个类，NamePrinter负责：

• 接收类型（MsgA、MsgB、 或之一MsgC）
• 实例化该类型
• 调用该类型的一些方法（为了示例，仅在下面的代码中调用一个方法）

我知道如何为此编写代码。我还知道如何切换到NamePrinter另一个也对消息执行操作的类。我不知道该怎么做是选择NamePrinter在更一般的情况下调用（或另一个类）的哪个成员函数

#include <iostream>

// Some made up "message" structs
struct MsgA final {
    static constexpr int getId() { return 1; }
    const char* getName() const { return "MsgA"; }
    const char* getSomethingElse() const { return "SomethingElseA"; }
};
struct MsgB final {
    static constexpr int getId() { return 2; }
    const char* getName() const { return "MsgB"; }
    const char* getSomethingElse() const { return "SomethingElseB"; }
};
struct MsgC final {
    static constexpr int getId() { return 3; }
    const char* getName() const { return "MsgC"; }
    const char* getSomethingElse() const { return "SomethingElseC"; }
};

// A class that creates a "message" and performs and action on it
class NamePrinter final {
public:
    template <class T>
    void onMsgPrintName() const {
        T t;
        std::cout << t.getName() << std::endl;
    }

    template <class T>
    void onMsgPrintSomethingElse() const {
        T t;
        std::cout << t.getSomethingElse() << std::endl;
    }
};

// A function that can convert an integer into a "message" at compile time but
// is hardcoded to call onMsgPrintName
template <class T>
void intToPrintName(const T& a_caller, const int a_id) {
    switch (a_id) {
    case MsgA::getId(): a_caller.template onMsgPrintName<MsgA>(); break;
    case MsgB::getId(): a_caller.template onMsgPrintName<MsgB>(); break;
    case MsgC::getId(): a_caller.template onMsgPrintName<MsgC>(); break;
    default:
        std::cout << "Runtime error" << std::endl;
    }
}

// This is invalid but tries to convey that onMsgPrintName has been replaced
// with a template
//template <class F, class T>
//void intToFunc(const T& a_caller, const int a_id) {
//    switch (a_id) {
//    case MsgA::getId(): a_caller.template F<MsgA>(); break;
//    case MsgB::getId(): a_caller.template F<MsgB>(); break;
//    case MsgC::getId(): a_caller.template F<MsgC>(); break;
//    default:
//        std::cout << "Runtime error" << std::endl;
//    }
//}

int main(int argc, char** argv) {
    const NamePrinter np;

    // This will end up calling NamePrinter::onMsgPrintName
    intToPrintName(np, argc);

    // I want something like this that allows me to pick what is called
    //intToFunc<NamePrinter::onMsgPrintName         >(np, argc);
    //intToFunc<NamePrinter::onMsgPrintSomethingElse>(np, argc);

    return 0;
}

我想知道的是我是否可以用我选择的任意成员函数替换onMsgPrintName内部。intToPrintName注释掉的代码显示了执行此操作的尝试，但无法编译