多态策略模式设计与思考

本文详细记录了C++策略模式业务设计遇到的问题和思考,感觉获取到的重复信息比较多,因此决定整理出一篇文章以便后面复用;

C++ 17 static inline

因为策略模式多态多数要经过接口类管理,避免不了和静态变量、函数打交道,C++ 17 static inline能够方便地绕过ODR规则使得变量的声明和使用变得简洁,现代C++ inline和static的含义也再次拓展,不应该再把只写inline=内联,static=静态的书奉为圣经。

ODR规则

ODR(One Definition Rule, 单一定义规则)是许多编译器遵循的规则,表示:一个东西可以声明多次,但只能被定义一次,例如一般的变量、函数,在同一个编译单元,都应该只定义一次,当然在C++中也有例外,它们可以被多次定义,但是各处的定义必须保持一致:

类、结构体、inline函数、模板、枚举变量以及C++ 17后允许的inline变量;

变量的inline

C++ 唯一可能破坏封装性定义的只有两种变量,即全局变量和类静态变量,全局变量在面向对象编程中多数完全可以由普通成员变量替换,但是静态变量要求程序整个生命周期都要维护一个内存区专门存放静态变量,无论类对象是否析构;

因此,在类中定义静态变量使得每个类对象都会产生A::count,违反了ODR规则,因此在C++ 17以前要求:

静态变量必须类内声明、类外定义,而且定义必须放在.cpp文件中,否则静态变量被多个头文件互相包含,仍然违反ODR;

这当然带来不便,在一系列只有实现的cpp文件突然出现一个变量定义是很突兀的,而且许多head-only库也无法使用,因此在C++ 17中,类的静态变量能够直接在类内使用static inline定义和声明:

1
2
3
4
class A{
...
static inline int count = 0; // ok after C++ 17
};
此处的inline作用就不是内联了,而是告诉编译器,将每个翻译单元重复的A::count合成同一个实体(指向同一个地址),这就获取了ODR规则的豁免。

还有一种情况是命名空间内的全局变量声明和定义放一起时:

1
2
3
4
5
6
7
8
9
10
11
int a = 99;   //这种是全局命名空间,也算是,多个cpp文件包含会报错

//test.h
namespace Test {
int a = 99;
}

//a.cpp //error!
#include "test.h"
//b.cpp //error!
#include "test.h"
这个变量也应该是命名空间中独一份的,也不属于任何对象,因此,如果这个头文件被多个cpp文件包含会报错:multiple definition of Test::a',这也是ODR禁止的,在C++ 17以前,处理和静态变量类似:头文件声明,cpp文件定义,在头文件还需要使用extern修饰:
1
2
3
4
5
6
7
8
9
10
11
//test.h
namespace Test {
extern int a;
}
//test.cpp
int Test::a = 1;

//a.cpp //ok
#include "test.h"
//b.cpp //ok
#include "test.h"
同理,在C++ 17后,直接inline即可:
1
2
3
namespace Test {
inline int a = 22; //ok!
}

除了类静态变量和全局变量(全局或命名空间内),****其他变量都不允许被inline修饰**,如局部变量、局部静态变量和成员变量等;

函数的inline

注意,C++ 17的内容已经完了,就是引入了static inline解决上述的变量ODR问题;然后有人要黑人疑惑了,static inline我在20年前的嵌入式代码就写过了呀,咋可能C++ 2017年才引入?

因为这根本是两码事!

首先对于inline,对函数的唯一作用就是向编译器建议“内联”,而static在两种函数作用完全不一样,以下。

普通函数的static inline

在C语言中,static inline经常被用于头文件中定义函数,原因很简单,就是为了内联,减少函数调用开销,也避免部分函数未使用警告,然而一旦内联失败,就是产生ODR错误,因为将有多个.c翻译单元出现相同的定义,所以必须使用static将函数作用域限死在当前的.h和.cpp,其他.c文件如果引用该文件,会自动产生副本,避免undefined reference错误,所以翻看C语言等嵌入式库,清一色的static inline;

在C++头文件中则已经大不相同,不建议在头文件写static inline:

  1. 如上述规则,我们再放一次:

    类、结构体、inline函数、模板、枚举变量以及C++ 17后允许的inline变量;

    C++本身就允许inline函数存在头文件,就算内联失败也不会产生ODR错误!

  2. 头文件写static inline会有额外的问题, 多个cpp文件会产生副本函数,函数地址不同,而且互相独立:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    //// header.h
    static inline int nextId() {
    static int id = 0; // 危险!a.cpp 和 b.cpp 会各自计数!
    return ++id;
    }

    //a.cpp
    #include "header.h"
    nextId(); //独立计数!

    //b.cpp
    #include "header.h"
    nextId();//独立计数!
    本质是因为头文件的static产生了和C语言相同的内部链接效果,每个cpp文件都有独立的静态局部变量,再者,如果内联失败仍然会像上述一样独立计算;

匿名命名空间

在C++中,一般是在.cc/.cpp文件中才会定义static inline函数,此时static代表仅当前cpp文件能引用该函数,现代C++如果希望将函数定义限死在当前cpp文件,更经典的做法是使用匿名命名空间,因为不仅函数,结构体、枚举都能被当前cpp文件私有化:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
namespace{
struct State{
int status;
};

enum class ALHardwareType : uint8_t{
UNKNOWN,
NORMAL,
OTHER,
};

inline void printType(){ //此处inline可有可无,仅提供内联建议,cpp文件放匿名空间也没有ODR问题;
......
}
}

如果需要其他文件也能够引用,那就放在头文件中的非匿名空间并且通过inline来合成函数实体:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//*.h
namespace MyState{ //头文件要避免使用匿名命名空间,否则产生独立副本,和static inline一样存在割裂问题
struct State{
int status;
};

enum class ALHardwareType : uint8_t{ //各处头文件的命名空间枚举、结构体类型定义应该一致;
UNKNOWN,
NORMAL,
OTHER,
};

inline void printType(){ //此处必须inline
......
}
}

再次强调,以上说的是普通非成员函数。

成员函数static inline

成员函数的static和什么命名空间遮蔽就无关了,在类中声明static只有一个作用:声明静态函数,而且存在一些潜规则:

  1. 若头文件提供static函数定义,inline自动隐性生成,可以省略;

  2. 若头文件声明、cpp文件定义,则声明应该inline,或者留在定义处inline;

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    //A.h
    class A{
    public:
    static inline void foo() //1. inline可省略,自动inline
    {
    ....
    }

    static inline void foo1();
    }

    //A.cpp
    inline void foo1(){ //2. 声明inline,此处随便;声明无,此处需inline;static都不写
    ...
    }

不要把头文件命名成device.h等通用头文件

这是一个温馨提示:自定义实现和一些系统废弃头文件重名,继承体系下很容易造成循环引用和这类定义找不到、那也找不到的困境,命名头文件一定要出类拔萃,不能和系统头文件重名!

策略模式方案

以下旨在实现一种运行时多态,根据不同的运行条件/环境,能够执行不同的函数行为,若函数与多态对象对不上自动打印警告日志,还有以下特点:

  • 三层灵活抽象层复用结构,可继续向上构建抽象层;

  • 接口类仅充当静态接口类,通过局部静态引用获取底层信息;

  • 接口类的调用者来命名底层对象和管理底层对象生命周期;

  • 运行多态通过原子指针切换实现,未实现延迟初始化,适用于频繁切换场景;

相关抽象代码见:

Cmake依赖(此处boost和cv都是多余的,懒得删了):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
cmake_minimum_required(VERSION 3.20)
project(polymorphism)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

set(OpenCV_DIR "D:/open480_ffmpeg/opencv-480-c23/opencv-4.8.0/build/install") #设置install路径

set(BOOST_ROOT "D:/Documents/Desktop/boost_1_88_0/boost_1_88_0_c23/")
set(BOOST_LIBRARYDIR "D:/Documents/Desktop/boost_1_88_0/boost_1_88_0_c23/stage/lib")
#以下几个如果不指定,boost可能报错
set(Boost_USE_STATIC_LIBS ON)
set(Boost_USE_MULTITHREADED ON)
set(Boost_USE_DEBUG_LIBS ON)
set(Boost_COMPILER "-mgw14")
set(Boost_ARCHITECTURE "-x64")

#find_package错误可能路径不对、版本和编译器版本、平台不兼容等;
find_package(OpenCV REQUIRED)
find_package(Boost REQUIRED COMPONENTS filesystem log_setup log json program_options serialization thread)

add_executable(${PROJECT_NAME})

target_sources(${PROJECT_NAME} PRIVATE
catImpl.h
catImpl.cpp
catInterface.h
catInterface.cpp
catDevice.h
main.cpp
)

target_include_directories(${PROJECT_NAME} PRIVATE ${OpenCV_INCLUDE_DIRS}) #设置头文件
target_include_directories(${PROJECT_NAME} PRIVATE ${Boost_INCLUDE_DIRS}) #设置头文件

target_include_directories(${PROJECT_NAME} PRIVATE ${${CMAKE_SOURCE_DIR}})

target_link_libraries(${PROJECT_NAME} PRIVATE #设置库文件
${OpenCV_LIBS}
${Boost_LIBRARIES}
)

catImpl底层行为层

底层实现层的.h和.cpp,实现具体模块业务:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//catImpl.h
#pragma once

#include "catInterface.h"
#include <iostream>

namespace MoyaoCat {

class CatShop;
class CheapCatImpl : public CatInterface{
public:
CheapCatImpl(uint8_t component, CatShop* catshop);
~CheapCatImpl() = default;

void same_declare() override;

void cheapCount() override;
};

class ExpensiveCatImpl: public CatInterface
{
public:
ExpensiveCatImpl(uint8_t component, CatShop* catshop);
~ExpensiveCatImpl() = default;

void same_declare() override;

void expensiveRise() override;
};

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//catImpl.cpp
#include "catImpl.h"

namespace MoyaoCat {

/**********************Cheap Cat Impl***********************/
CheapCatImpl::CheapCatImpl(uint8_t component, CatShop* catshop):CatInterface(component, catshop){}

void CheapCatImpl::same_declare(){
std::cout << "I sell chep cat" << std::endl;
}

void CheapCatImpl::cheapCount(){
std::cout << "Friday, Nine count" << std::endl;
}


/**********************Expensive Cat Impl***********************/
ExpensiveCatImpl::ExpensiveCatImpl(uint8_t component, CatShop* catshop):CatInterface(component, catshop){}

void ExpensiveCatImpl::same_declare()
{
std::cout << "I sell Expensive cat" << std::endl;
}

void ExpensiveCatImpl::expensiveRise()
{
std::cout << "Friday, I rise 10 percent of the price" << std::endl;
}

}

catInterface接口管理层

中间接口层实现接口的切换和切换对象的类别管理:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
//catInterface.h
#include <ostream>

namespace MoyaoCat{

//要动态多态的类类型
enum class CatType : uint8_t{
UNKNOW,
CHEAP,
EXPENSIVE,
};

//强类型enum class的自定义打印
inline std::ostream& operator<<(std::ostream& os, const CatType& c_type){
switch (c_type)
{
case CatType::CHEAP:
os << "Cheap Cat";
break;
case CatType::EXPENSIVE:
os << "Expensive Cat";
break;
default:
os << "Unknow Cat";
break;
}
return os;
}

//模板类:为了让所有的商店提供相同的对外接口
template<typename T>
class ShopInMarket{
public:
ShopInMarket(uint8_t component, T* shop):mShopNumber(component),mShop(shop){}

///...统一接口,什么商店交租、商店到期日期查询等等;
private:
T* mShop;
uint8_t mShopNumber;
};


class CatShop;
//接口类:实现猫商店的运行动态切换
class CatInterface : public ShopInMarket<CatShop>{
public:
explicit CatInterface(uint8_t component, CatShop* shop);
virtual ~CatInterface();

CatInterface(const CatInterface&) = delete;
CatInterface& operator=(const CatInterface&) = delete;

//提前初始化猫猫商店切换指针
static void init(uint8_t component_cheap, uint8_t component_expensive, CatShop* shop);
static void shutdown();

//实现运行多态切换
static CatInterface& getInstance();
static void SwitchCatType(CatType type);
static int getCatType();

// /***************以下放业务函数*****************/
//所有猫猫商店都会提供介绍,必须重写
virtual void same_declare() = 0;

/***************Cheap Cat Interface*****************/
//Cheap猫猫才会打折
virtual void cheapCount();

/***************Cheap Cat Interface*****************/
//Expensive猫猫才会升价
virtual void expensiveRise();

static inline int closed = false;

};
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
//catInterface.cpp
#include "catImpl.h"
#include "catInterface.h"
#include <iterator>
#include <memory>
#include <atomic>
#include <thread>

namespace MoyaoCat {
namespace{
struct State{ //匿名命名空间,存储一个全局存在的切换指针
std::unique_ptr<CheapCatImpl> cheap_cat_ptr;
std::unique_ptr<ExpensiveCatImpl> expensive_cat_ptr;
std::atomic<CatInterface*> current_cat_ptr{nullptr};
std::atomic<CatType> current_cat_type{CatType::UNKNOW};
};

State& getStateInst(){
static State s;
return s;
}

}
CatInterface::CatInterface(uint8_t component, CatShop* shop):ShopInMarket(component, shop){
std::cout << "conn" << std::endl;
}

CatInterface::~CatInterface(){}

//提前初始化猫猫商店切换指针
void CatInterface::init(uint8_t component_cheap, uint8_t component_expensive, CatShop* shop){
auto& s = getStateInst();
s.cheap_cat_ptr = std::make_unique<CheapCatImpl>(component_cheap, shop);
s.expensive_cat_ptr = std::make_unique<ExpensiveCatImpl>(component_expensive, shop);
s.current_cat_ptr.store(s.cheap_cat_ptr.get(), std::memory_order_release);
s.current_cat_type.store(CatType::CHEAP, std::memory_order_release);
}

void CatInterface::shutdown(){
auto& s = getStateInst();
s.cheap_cat_ptr.reset();
s.expensive_cat_ptr.reset();
s.cheap_cat_ptr = nullptr;
s.expensive_cat_ptr = nullptr;
s.current_cat_ptr.store(nullptr, std::memory_order_release);
s.current_cat_type.store(CatType::UNKNOW, std::memory_order_release);
std::cout << "shutdown done" << std::endl;
}

//实现运行多态切换
CatInterface& CatInterface::getInstance(){
auto& s = getStateInst();
CatInterface* p = s.current_cat_ptr.load(std::memory_order_acquire);
if(p == nullptr)
{
std::cout << "get CatInterImpl ptr failed";
}
return *p;
}

void CatInterface::SwitchCatType(CatType type){
auto& s = getStateInst();
CatInterface* p = nullptr;
switch(type){
case CatType::EXPENSIVE:
p = s.expensive_cat_ptr.get();
break;
default:
p = s.cheap_cat_ptr.get();
break;
}
if(p == nullptr){
std::cerr << "Invalid Cat Type Switch" << std::endl;
}
else
{
s.current_cat_ptr.store(p, std::memory_order_release);
s.current_cat_type.store(type, std::memory_order_release);
std::cout << "CatShop Type SWitch to: " << type << std::endl;
}
}

int CatInterface::getCatType(){
auto& s = getStateInst();
return static_cast<int>(s.current_cat_type.load(std::memory_order_acquire));
}

/***************以下放业务函数默认实现*****************/
#define NOT_IMPLEMENTED() \
auto& s = getStateInst(); \
std::cout << s.current_cat_type.load(std::memory_order_acquire) \
<< " Has not Implemented " << __func__ \
<< " (" << __FILE__ << ":" << __LINE__ << ")\n"

// /***************Cheap Cat Interface*****************/
//Cheap猫猫才会打折
void CatInterface::cheapCount(){
NOT_IMPLEMENTED();
}


/***************Cheap Cat Interface*****************/
//Expensive猫猫才会升价
void CatInterface::expensiveRise(){
NOT_IMPLEMENTED();
}
}

catInterface顶层业务层

顶层调用类任何类都可以获取CatInterface的动态多态对象实现不同目的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//catDevice.h
#pragma once

#include "catInterface.h"

namespace MoyaoCat {

//处理商店的共同底层交互问题
class CatShop{
public:
CatShop() = default;
~CatShop(){
CatInterface::shutdown();
}

CatInterface* getCatPtr()
{
return &(CatInterface::getInstance());
}

void init(uint8_t component_cheap, uint8_t component_expensive)
{
CatInterface::init(component_cheap, component_expensive, this);
}

void SwitchCatType(CatType type){
CatInterface::SwitchCatType(type);
}
};
}

测试代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//main.cpp
#include <iostream>
#include "catDevice.h"

using namespace std;

int main(){
MoyaoCat::CatShop csp;
csp.init(0x01, 0x02);
csp.getCatPtr()->same_declare(); //I sell chep cat
csp.getCatPtr()->cheapCount(); //Friday, Nine count
csp.getCatPtr()->expensiveRise(); //Cheap Cat Has not Implemented expensiveRise (D:\Documents\Desktop\cmake_muti\catInterface.cpp:106)

//动态多态
csp.SwitchCatType(MoyaoCat::CatType::EXPENSIVE); //CatShop Type SWitch to: Expensive Cat
csp.getCatPtr()->same_declare(); //I sell Expensive cat
csp.getCatPtr()->cheapCount(); //Expensive Cat Has not Implemented cheapCount (D:\Documents\Desktop\cmake_muti\catInterface.cpp:99)
csp.getCatPtr()->expensiveRise(); //Friday, I rise 10 percent of the price

cout << "done" << endl;
return 0;
}

一些失败的尝试

上述方案并不是实现动态切换的唯一手段,在此前有许多版本的尝试,但都失败了,例如:

  1. 尝试让接口指针成为顶层业务类的一个成员?
    1
    static inline std::atomic<CatInterface*> cat_current_ptr{nullptr};
    但是这很困难,首先,抽象类不允许直接实例化对象,因此你必须提供cheap cat或者expensive cat的默认Impl实例:
    1
    2
    3
    4
    5
    6
    7
    static CatInterface& getDefaultInstance(){
    static CheapCatImpl cheapCat;
    return static_cast<CatInterface&>(cheapCat);
    }

    //外部成员:
    static inline CatInterface& mCatInterface = getDefaultInstance();
    然而,绑定引用存在两个致命问题:
  • mCatInterface引用一旦绑定,无法换绑,也就无法切换至另一种Impl对象;

  • 静态函数难以获取成员函数。此处,因为业务架构原因,CheapCatImpl链式继承了CatInterface和ShopInMarket,Impl需要透传参数构造父类CatInterface和ShopInMarket,所以无法根据构造类延迟初始化,再通过getInstance返回指针对象:

    1
    2
    3
    4
    5
    6
    CheapCatImpl::CheapCatImpl(uint8_t component, CatShop* catshop):CatInterface(component, catshop){}  //带参构造
    ......
    static CatInterface& getDefaultInstance(){
    static CheapCatImpl cheapCat(); //需要参数
    return static_cast<CatInterface&>(cheapCat);
    }
    如果使用getInstance传入参数,那也太冗余了,对顶层调用带来不便;

    基于此,上述初始化存入、接口管理对象的方法会显得更加优雅;

  1. 动态多态的CRTP模式?

    单独的CRTP是无法实现动态多态的,因为返回的Base<CheapCat>和Base<ExpensiveCat>本身不是一个类型,也无法用单个父类指针对象完成切换,因此必须使用std::variant、std::visit等动态分发方法,但在策略模式中不值得:虚函数本身的访问速度很快(几纳秒),CRTP提高性能的关键是实现内联,但std::variant和std::visit在不同编译器的性能表现不一致,而且并不算优秀。