面向切片编程

最新推荐文章于 2024-08-28 04:00:08 发布

Snowball Snowball

最新推荐文章于 2024-08-28 04:00:08 发布

阅读量326

点赞数 3

分类专栏： C++工作实战笔记文章标签： linux c++ c语言

本文链接：https://blog.csdn.net/qq_42384310/article/details/140400755

版权

C++工作实战笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

探索C++中级编程：面向切片编程

在C++中，面向切片编程（AOP）是一种函数式编程的衍生范型，通过代理接口或预编译的方式来实现业务逻辑的解耦合。本文将详细介绍AOP的概念、作用及其实例。

一、面向切片编程的基本概念

AOP，即Aspect Oriented Programming，是面向切片（面）编程的一种方式。它通过纵向切片来增加功能模块，主要包括以下几个概念：

Aspect：类似于类，包含Pointcut和Advice。
Pointcut：一组Join Point，即Advice发生的地方。
Join Point：接口调用点。
Advice：Join Point的动作内容，例如Spring中的before, after等前后执行的代码。

二、面向切片编程的作用

面向切片编程注重抽象模块对象间的关系，特别是动作的关系，从而形成可共用的接口。其核心思想是实现软件设计和开发更符合原则，解耦合业务逻辑，提高代码的可维护性和复用性。

三、面向切片编程的实例

通过模板函数和RAII（资源获取即初始化）模式，抽象出时间计算函数，减少重复代码，实现面向切片编程。以下是一个具体的代码示例：

template <typename Fn, typename... Args> 
void TestTime(Fn &fn, Args... args) 
{
  struct timeval t1, t2;
  double timeuse;
  gettimeofday(&t1, NULL);

  fn(std::forward<Args>(args)...);

  gettimeofday(&t2, NULL);
  timeuse = t2.tv_sec - t1.tv_sec + (t2.tv_usec - t1.tv_usec) / 1000000.0;
  printf("Use Time:%f\n", timeuse);
}

通过进一步的抽象和代理类，可以更有效地实现面向切片编程：

#include <cstddef>
#include <stdio.h>
#include <sys/time.h>

class CaclTime {
public:
  CaclTime() { gettimeofday(&tStart_, NULL); };
  ~CaclTime() {
    gettimeofday(&tEnd_, NULL);
    timeuse_ = tEnd_.tv_sec - tStart_.tv_sec + (tEnd_.tv_usec - t1.tv_usec) / 1000000.0;
    printf("Use Time:%f\n", timeuse_);
  }

private:
  struct timeval tStart_;
  struct timeval tEnd_;
  double timeuse_ = 0.0;
};

template <typename Fn, typename... Args> 
void TestTime(Fn &fn, Args... args) 
{
  CaclTime();
  fn(std::forward<Args>(args)...);
}

再来看一个使用代理类的示例：

void Run(int num) {
  for (int i = 0; i < num; i++) {
    // todo
  }
}

template <typename T> struct TimeProxy {
public:
  template <typename F, typename... Args> static decltype(auto) Task(F f, Args &&...args) {
    T t;
    return f(std::forward<Args>(args)...);
  }
};

TimeProxy<CaclTime>::Task(Run, 100);

为了处理多个切片，可以抽象代理类：

template<typename ...Types>
class ProxyObjectTypes {
public:
  template<std::size_t ID>
  struct GetType {
    using Type = typename std::tuple_element<ID, std::tuple<Types...>>::type;
  };
};

template <typename... Types> struct ProxyTypes<ProxyObjectTypes<Types...>> {
  template <typename F, typename... Args> static decltype(auto) Process(F &&f, Args &&...args) {
    return Call(std::make_index_sequence<sizeof...(Types)>{}, std::forward<F>(f), std::forward<Args>(args)...);
  }

  template <std::size_t ID, typename F, typename... Args>
  static decltype(auto) Call(std::index_sequence<ID>, F &&f, Args &&...args) {
    using Tfunc = typename ProxyObjectTypes<Types...>::template GetType<ID>::Type;
    Tfunc tf;
    return std::forward<F>(f)(std::forward<Args>(args)...);
  }

  template <std::size_t ID, std::size_t... R, typename F, typename... Args>
  static decltype(auto) Call(std::index_sequence<ID, R...>, F &&f, Args &&...args) {
    using Tfunc = typename ProxyObjectTypes<Types...>::template GetType<ID>::Type;
    Tfunc tf;
    return Call(std::index_sequence<R...>{}, std::forward<F>(f), std::forward<Args>(args)...);
  }
};