C++ 编写一个自定义的 `std::function`：深入理解类型擦除

哈喽，各位好！今天我们要一起深入探讨一个C++中既强大又有点神秘的概念——类型擦除，并以此为基础，手撸一个自定义的std::function。准备好迎接一场烧脑但绝对有趣的旅程了吗？系好安全带，发车！

第一站：什么是类型擦除？为啥要擦？

想象一下，你有一个神奇的盒子，可以装任何东西：苹果、香蕉、甚至是你的袜子（别问我为什么）。这个盒子不在乎你往里面放什么，它只负责装东西和把东西拿出来。这就是类型擦除的核心思想：隐藏底层类型的信息，提供一个通用的接口。

为什么要擦除类型呢？原因有很多：

泛型编程： 编写可以处理多种类型的代码，而无需为每种类型都写一个函数或类。
解耦： 将接口与实现分离，降低依赖性，提高代码的灵活性和可维护性。
编译时多态： 实现类似运行时多态的效果，但避免虚函数的开销。

第二站：std::function，类型擦除的集大成者

std::function是C++标准库中类型擦除的经典案例。它可以封装任何可调用对象（函数、函数指针、lambda表达式、函数对象），只要它们的签名匹配。

让我们先回顾一下std::function的使用方法：

#include <iostream>
#include <functional>

int add(int a, int b) {
  return a + b;
}

int main() {
  std::function<int(int, int)> func; // 声明一个可以接受两个int参数并返回int的function

  func = add; // 赋值函数指针
  std::cout << func(2, 3) << std::endl; // 调用

  func = [](int a, int b) { return a * b; }; // 赋值lambda表达式
  std::cout << func(2, 3) << std::endl; // 调用

  struct MyFunctor {
    int operator()(int a, int b) { return a - b; }
  };
  MyFunctor functor;
  func = functor; // 赋值函数对象
  std::cout << func(2, 3) << std::endl; // 调用

  return 0;
}

这段代码展示了std::function的强大之处：它可以接受各种不同类型的可调用对象，并以统一的方式调用它们。但它是如何实现的呢？这就是类型擦除的魔法所在。

第三站：解剖std::function的内心世界

std::function的实现通常涉及以下几个关键组件：

类型无关的存储： 用于存储任何可调用对象。
类型特定的调用器： 用于以正确的方式调用存储的可调用对象。
类型特定的拷贝构造器和析构器： 用于正确地复制和销毁存储的可调用对象。

为了更好地理解，我们来定义一些接口：

class FunctionBase {
public:
  virtual ~FunctionBase() {}
  virtual FunctionBase* clone() const = 0;
  virtual void invoke(void* result, void* args) = 0;
};

这个FunctionBase类是一个抽象基类，定义了三个纯虚函数：

clone(): 用于创建对象的副本。
invoke(): 用于调用存储的可调用对象。
~FunctionBase(): 虚析构函数，保证多态的正确性。

接下来，我们需要一个模板类，用于封装特定类型的可调用对象：

template <typename Func, typename ReturnType, typename... Args>
class FunctionImpl : public FunctionBase {
public:
  FunctionImpl(Func f) : func_(f) {}
  FunctionImpl* clone() const override { return new FunctionImpl(*this); }
  void invoke(void* result, void* args) override {
    // 将 void* args 转换为实际的参数类型
    ReturnType actualResult = func_(*reinterpret_cast<Args*>(args)...);
    // 将结果拷贝到 void* result 指向的内存
    *reinterpret_cast<ReturnType*>(result) = actualResult;
  }
private:
  Func func_;
};

FunctionImpl类继承自FunctionBase，并存储一个特定类型的可调用对象func_。它实现了clone()和invoke()方法，用于复制和调用func_。注意，invoke()方法需要将void*类型的参数转换为实际的参数类型，并调用func_。

第四站：手撸一个简化版的MyFunction

现在，我们可以开始构建我们的自定义MyFunction类了：

template <typename ReturnType, typename... Args>
class MyFunction {
public:
  using FunctionType = ReturnType(Args...);

  MyFunction() : impl_(nullptr) {}

  template <typename Func>
  MyFunction(Func f) : impl_(new FunctionImpl<Func, ReturnType, Args...>(f)) {}

  MyFunction(const MyFunction& other) : impl_(other.impl_ ? other.impl_->clone() : nullptr) {}

  MyFunction& operator=(const MyFunction& other) {
    if (this != &other) {
      delete impl_;
      impl_ = other.impl_ ? other.impl_->clone() : nullptr;
    }
    return *this;
  }

  ~MyFunction() { delete impl_; }

  ReturnType operator()(Args... args) {
    if (!impl_) {
      throw std::bad_function_call();
    }
    // 分配内存来存储参数
    alignas(std::max({sizeof(Args)...})) unsigned char argBuffer[sizeof...(Args) > 0 ? sizeof...(Args) * std::max({sizeof(Args)...}) : 1];
    // 将参数拷贝到 argBuffer
    std::tuple<Args...> argTuple(args...);
    std::size_t offset = 0;
    std::apply([&](auto&&... arg){
        ([&](auto&& a){
            std::memcpy(argBuffer + offset, &a, sizeof(a));
            offset += sizeof(a);
        }(arg), ...);
    }, argTuple);

    // 分配内存来存储返回值
    alignas(ReturnType) unsigned char resultBuffer[sizeof(ReturnType)];

    impl_->invoke(resultBuffer, argBuffer);
    return *reinterpret_cast<ReturnType*>(resultBuffer);
  }

private:
  FunctionBase* impl_;
};

这个MyFunction类包含以下几个部分：

构造函数： 接受一个可调用对象，并创建一个FunctionImpl对象来存储它。
拷贝构造函数和赋值运算符： 用于复制MyFunction对象。
析构函数： 用于释放FunctionImpl对象。
operator()： 用于调用存储的可调用对象。

operator()方法首先检查impl_是否为空，如果为空则抛出一个std::bad_function_call异常。然后，它分配一块内存来存储参数，并将参数拷贝到这块内存中。接着，它调用impl_->invoke()方法来调用存储的可调用对象，并将结果存储在另一块内存中。最后，它将结果返回。

第五站：代码示例，验证成果

让我们用一些代码来测试我们的MyFunction类：

#include <iostream>

// 包含 MyFunction 的定义

int main() {
  MyFunction<int, int, int> func;

  func = [](int a, int b) { return a + b; };
  std::cout << func(2, 3) << std::endl;

  struct MyFunctor {
    int operator()(int a, int b) { return a * b; }
  };
  MyFunctor functor;
  func = functor;
  std::cout << func(2, 3) << std::endl;

  return 0;
}

这段代码与我们之前使用std::function的例子非常相似。它创建了一个MyFunction对象，并分别赋值一个lambda表达式和一个函数对象。然后，它调用MyFunction对象，并打印结果。

第六站：性能考量与优化

虽然我们的MyFunction类已经可以工作了，但它还有一些可以改进的地方，特别是在性能方面：

动态内存分配： 每次调用operator()方法时，我们都需要分配内存来存储参数和返回值。这会带来一定的开销。
拷贝： 参数和返回值的拷贝也会带来额外的开销。

为了优化性能，我们可以考虑以下方法：

使用小对象优化（Small Object Optimization, SSO）： 如果可调用对象的大小小于某个阈值，我们可以直接将它存储在MyFunction对象内部，而无需动态内存分配。
完美转发： 使用完美转发可以避免参数的拷贝。
移动语义： 使用移动语义可以避免不必要的拷贝。

第七站：类型擦除的更多应用

类型擦除不仅仅可以用于实现std::function，它还可以应用于许多其他场景：

插件系统： 使用类型擦除可以实现一个灵活的插件系统，允许在运行时加载和卸载不同类型的插件。
事件处理： 使用类型擦除可以实现一个通用的事件处理机制，允许任何对象注册和接收事件。
GUI框架： 使用类型擦除可以实现一个可扩展的GUI框架，允许自定义控件和布局。

第八站：总结与展望

今天，我们一起深入探讨了类型擦除的概念，并手撸了一个简化版的MyFunction类。我们了解了类型擦除的原理、实现方法和应用场景。

类型擦除是一种强大的技术，它可以让我们编写更加通用、灵活和可维护的代码。虽然它有一定的复杂性，但只要掌握了核心思想，就可以轻松应对各种挑战。

希望今天的讲座对你有所帮助！下次再见！

附录：一些关键点的表格总结

特性/概念	描述
类型擦除	隐藏底层类型的信息，提供一个通用的接口。
`std::function`	C++标准库中类型擦除的经典案例，可以封装任何可调用对象。
`FunctionBase`	抽象基类，定义了`clone()`、`invoke()`和`~FunctionBase()`等纯虚函数。
`FunctionImpl`	模板类，继承自`FunctionBase`，用于封装特定类型的可调用对象。
`MyFunction`	自定义的`std::function`，使用类型擦除技术实现。
小对象优化 (SSO)	一种优化技术，如果可调用对象的大小小于某个阈值，可以直接将它存储在`MyFunction`对象内部，而无需动态内存分配。
完美转发	一种语言特性，可以避免参数的拷贝。
移动语义	一种语言特性，可以避免不必要的拷贝。
应用场景	插件系统、事件处理、GUI框架等。

代码完整示例：

#include <iostream>
#include <stdexcept>
#include <cstring>
#include <tuple>
#include <utility>

class FunctionBase {
public:
  virtual ~FunctionBase() {}
  virtual FunctionBase* clone() const = 0;
  virtual void invoke(void* result, void* args) = 0;
};

template <typename Func, typename ReturnType, typename... Args>
class FunctionImpl : public FunctionBase {
public:
  FunctionImpl(Func f) : func_(f) {}
  FunctionImpl* clone() const override { return new FunctionImpl(*this); }
  void invoke(void* result, void* args) override {
    // 将 void* args 转换为实际的参数类型
    ReturnType actualResult = func_(*reinterpret_cast<Args*>(args)...);
    // 将结果拷贝到 void* result 指向的内存
    *reinterpret_cast<ReturnType*>(result) = actualResult;
  }
private:
  Func func_;
};

template <typename ReturnType, typename... Args>
class MyFunction {
public:
  using FunctionType = ReturnType(Args...);

  MyFunction() : impl_(nullptr) {}

  template <typename Func>
  MyFunction(Func f) : impl_(new FunctionImpl<Func, ReturnType, Args...>(f)) {}

  MyFunction(const MyFunction& other) : impl_(other.impl_ ? other.impl_->clone() : nullptr) {}

  MyFunction& operator=(const MyFunction& other) {
    if (this != &other) {
      delete impl_;
      impl_ = other.impl_ ? other.impl_->clone() : nullptr;
    }
    return *this;
  }

  ~MyFunction() { delete impl_; }

  ReturnType operator()(Args... args) {
    if (!impl_) {
      throw std::bad_function_call();
    }
    // 分配内存来存储参数
    alignas(std::max({sizeof(Args)...})) unsigned char argBuffer[sizeof...(Args) > 0 ? sizeof...(Args) * std::max({sizeof(Args)...}) : 1];
    // 将参数拷贝到 argBuffer
    std::tuple<Args...> argTuple(args...);
    std::size_t offset = 0;
    std::apply([&](auto&&... arg){
        ([&](auto&& a){
            std::memcpy(argBuffer + offset, &a, sizeof(a));
            offset += sizeof(a);
        }(arg), ...);
    }, argTuple);

    // 分配内存来存储返回值
    alignas(ReturnType) unsigned char resultBuffer[sizeof(ReturnType)];

    impl_->invoke(resultBuffer, argBuffer);
    return *reinterpret_cast<ReturnType*>(resultBuffer);
  }

private:
  FunctionBase* impl_;
};

int main() {
  MyFunction<int, int, int> func;

  func = [](int a, int b) { return a + b; };
  std::cout << func(2, 3) << std::endl;

  struct MyFunctor {
    int operator()(int a, int b) { return a * b; }
  };
  MyFunctor functor;
  func = functor;
  std::cout << func(2, 3) << std::endl;

  MyFunction<void, int> func2 = [](int a){ std::cout << "Value: " << a << std::endl; };
  func2(10);

  return 0;
}

发表回复 取消回复

发表回复取消回复