c++ - 模板化成员函数和继承

Question

我在一个类中声明了一个模板成员函数，它根据类型调用正确的成员函数，并希望通过添加一个成员函数在子类中为其添加一些功能，如下面的 main.cpp 示例所示:

#include <iostream>

class A
{
public:
    template <typename T>
    void handleSocketData(const T& t)
    {
        handleData(t);
    }

    void handleData(int data)
    {
        std::cout << data << std::endl;
    }

};

class B: public A
{
public :
    void handleData(std::string data) const
    {
        std::cout << data << std::endl;
    }
};

int main(int argc, char *argv[])
{
    A a;
    B b;
    a.handleSocketData<int>(30);
    b.handleSocketData<std::string>("Hi");
    return 0;
}

我的问题是 b.handleSocketData<QString>("Hi");实际上确实在 A 类中生成了一个新的模板实例，如命令 /usr/bin/clang++ -DQT_CORE_LIB -isystem /usr/include/qt6/QtCore -isystem /usr/include/qt6 -isystem /usr/lib64/qt6/mkspecs/linux-g++ -g -std=gnu++17 -Xclang -ast-print -fsyntax-only main.cpp 的输出所示:

class A {
public:
    template <typename T> void handleSocketData(const T &t) {
        this->handleData(t);
    }
    template<> void handleSocketData<int>(const int &t) {
        this->handleData(t);
    }
    template<> void handleSocketData<std::basic_string<char>>(const std::basic_string<char> &t) {
        <recovery-expr>(this->handleData, t);
    }
    void handleData(int data) {
        std::cout << data << std::endl;
    }
};
class B : public A {
public:
    void handleData(std::string data) const {
        std::cout << data << std::endl;
    }
};
int main(int argc, char *argv[]) {
    A a;
    B b;
    a.handleSocketData<int>(30);
    b.handleSocketData<std::string>("Hi");
    return 0;
}

所以现在我有一个编译错误，说没有找到函数 handleData(const std::string& data)，这是正常的。

我们发现的解决方法是定义一个双参数模板，将子类作为参数(一种访问者模式):

#include <iostream>

class A
{
public:
    template <typename T, typename U>
    void handleSocketData(U& u, const T& t)
    {
        u.handleData(t);
    }

    void handleData(int data)
    {
        std::cout << data << std::endl;
    }

};

class B: public A
{
public :
    void handleData(std::string data)
    {
        std::cout << data << std::endl;
    }
};

int main(int argc, char *argv[])
{
    A a;
    B b;
    a.handleSocketData<int>(a, 30);
    b.handleSocketData<std::string>(b, "Hi");
    return 0;
}

你怎么看？有更清洁的方法吗？

Answer 1

这看起来像是 CRTP 的经典用例.你可以制作A派生类上的模板 Derived然后通过 static_cast 将函数调用分派(dispatch)给派生类.为此，任何派生类 Derived必须来自 A<Derived> .

因为你似乎想使用 A作为非抽象类，您必须添加一个默认派生类，将其标记为“最终”。在下面的代码中，空结构 FinalTag就是为了这个目的。

#include <iostream>

struct FinalTag;

template <typename Derived=FinalTag>
class A
{
public:
    template <typename T>
    void handleSocketData(const T& t)
    {
        cast().handleData(t);
    }

    void handleData(int data)
    {
        std::cout << data << std::endl;
    }

private:
    constexpr auto& cast() {
        return static_cast<Derived&>(*this);
    }

};

struct FinalTag : A<FinalTag> {};

class B: public A<B>
{
public :
    using Base = A<B>;
    using Base::handleData;

    void handleData(std::string data)
    {
        std::cout << data << std::endl;
    }
};

int main(int argc, char *argv[])
{
    A a;
    B b;
    a.handleSocketData(30);
    b.handleSocketData("Hi");

    // this only works if you bring in Base::handleData in the 
    // derived class
    b.handleSocketData(30);
    return 0;
}

在线代码:https://godbolt.org/z/ns9aPjG76

这是一个原型(prototype)。您可能希望将 const 版本添加到 cast方法为例。

编辑:

正如 Jarod42 在评论中指出的那样，C++23 通过“推导这个”真正简化了 CRTP:https://godbolt.org/z/cGzMrnEhc .不过，目前编译器并未广泛支持这一点。