模板化成员函数和继承

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. 为此，任何派生类都Derived必须派生自A<Derived>.

由于您似乎想用作A非抽象类，因此您必须添加一个默认的派生类，将其标记为“final”。在下面的代码中，空结构体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

这是一个原型。cast例如，您可能希望向该方法添加 const 版本。

编辑：

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