高端操作：不用继承我也能实现多态

2023-02-28

var cout std

本文转载自微信公众号「程序喵大人」，作者程序喵。转载本文请联系程序喵大人公众号。大家应该都知道C++17引入了variant，这篇文章我们来研究下它究竟有啥用。本期目录variant是什么?为什么要引入variant?如何确定variant中当前存放的数据类型?variant为什么要搭配monost

本文转载自微信公众号「程序喵大人」，作者程序喵。转载本文请联系程序喵大人公众号。

大家应该都知道C++17引入了variant，这篇文章我们来研究下它究竟有啥用。

本期目录

variant是什么?
为什么要引入variant?
如何确定variant中当前存放的数据类型?
variant为什么要搭配monostate?
如何用variant实现多态?

variant这货类似于union，可以存放多种类型的数据，但任何时刻最多只能存放其中一种类型。

这里大家可能有些疑问，既然有了union，那为啥还要引入variant呢?

那肯定是因为union有缺点呗。

看这段union的基本用法：

union MyUnion {
    int a;
    float b;
    double c;
};

void test_simple_union() {
    MyUnion u;
    u.a = 1;
    std::cout << u.a << "\n";

    u.b = 1.32f;
    std::cout << u.b << "\n";

    u.c = 2.32;
    std::cout << u.c << "\n";
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

union貌似也只能这么使用，没有其他方法。

这里有一个很重要的点，我没法获取当前存储的数据是什么类型，比如我当前存储的是float，但是却按int方式获取，这不就坏事了吗。

再看一段代码：

struct A {
    A() = default;
    A(int aa) : a{aa} { std::cout << "A() \n"; }
    ~A() { std::cout << "~A() \n"; }
    int a;
};

struct B {
    B() = default;
    B(float bb) : b{bb} { std::cout << "B() \n"; }
    ~B() { std::cout << "~B() \n"; }
    float b;
};

union MyStructUnion {
    A a;
    B b;
    /**
     * @brief 在析构函数中我要做什么？不知道当前类型究竟是A还是B
     * 那调用 a.~A() 还是 b.~B() ?
     */
    ~MyStructUnion() { std::cout << "~MyStructUnion() \n"; }
};

/**
 * @brief 需要手动调用析构函数
 *
 */
void test_struct_union() {
    MyStructUnion u;

    new (&u.a) A(1);
    std::cout << u.a.a << "\n";
    u.a.~A();

    u.b = B(2.3f);
    std::cout << u.b.b << "\n";
    u.b.~B();
}
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.

这里可以看到，union无法自动处理构造和析构等逻辑，它需要用户手动调用相关函数才行，这就导致使用它union存储自定义类型时特别麻烦。

所以，variant诞生：

struct C {
    C() = default;
    C(std::string cc) : c{cc} { std::cout << "C() \n"; }
    ~C() { std::cout << "~C() \n"; }
    std::string c;
};

/**
 * @brief 使用variant完全不需要手动调用构造和析构函数，它会自动处理好所有逻辑，非常方便
 *
 */
void test_variant() {
    std::variant<std::monostate, A, C> u; ///< 下面很快就会介绍monostate
    u = 1;
    std::cout << std::get<A>(u).a << "\n";
    u = std::string("dsd");
    std::cout << std::get<C>(u).c << "\n";
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

使用variant完全不需要手动调用构造和析构函数，它会自动处理好所有逻辑，非常方便。

这里还遗留个问题，即如何判断variant内部当前存储的数据是什么类型?别着急，后面会介绍。

在这之前还需要介绍个知识点：monostate。

首先，普通的variant使用方法如下：

void test_variant() {
    std::variant<int, float> var;
    var = 12;
    std::cout << std::get<int>(var) << "\n";
    var = 12.1f;
    std::cout << std::get<float>(var) << "\n";
}
1.
2.
3.
4.
5.
6.
7.

这也是常规的variant使用方法。那我如果存储个自定义类型呢?

struct S {
    S(int i) : value{i} {}
    int value;
};

void test_monostate2() {
    ///< 编译失败，S如果没有构造函数，需要加monostate
    std::variant<S> var;
    var = 12;
    std::cout << std::get<S>(var).value << "\n";
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

这里会编译失败，因为S没有无参默认构造函数，无法默认直接声明，所以这里需要加个monostate，表示默认情况下它的存储类型就是monostate。

然后可以这样使用：

struct S {
    S(int i) : value{i} {}
    int value;
};

void test_monostate() {
    std::variant<std::monostate, S> var;
    var = 12;
    std::cout << std::get<S>(var).value << "\n";
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

那如何获取variant内部存储的类型呢?

其实variant有一个index()方法可以做到。

看这段代码：

void test_index() {
    std::variant<std::monostate, int, float, std::string> var; ///< 默认index是0
    var = 1;
    std::cout << var.index() << "\n"; ///< 1
    var = 2.90f;
    std::cout << var.index() << "\n"; ///< 2
    var = std::string("hello world");
    std::cout << var.index() << "\n"; ///< 3
}
1.
2.
3.
4.
5.
6.
7.
8.
9.

在定义variant结束后，我们就会知道内部类型的index，然后在运行时我们就可以动态的获取当前var的index，进而确定内部数据的类型。

难道我们每次都要手动记录下variant内部数据类型的index吗?如果将来有一天我们要在中间新增数据类型，岂不是之前建立的index都错乱了。

这里可以使用可变参数模板+模板元编程的小技巧，看下面这段代码：

template <typename T, typename>
struct get_index;

template <size_t I, typename... Ts>
struct get_index_impl {};

template <size_t I, typename T, typename... Ts>
struct get_index_impl<I, T, T, Ts...> : std::integral_constant<size_t, I> {};

template <size_t I, typename T, typename U, typename... Ts>
struct get_index_impl<I, T, U, Ts...> : get_index_impl<I + 1, T, Ts...> {};

template <typename T, typename... Ts>
struct get_index<T, std::variant<Ts...>> : get_index_impl<0, T, Ts...> {};

template <typename T, typename... Ts>
constexpr auto get_index_v = get_index<T, Ts...>::value;

using variant_t = std::variant<std::monostate, int, float, std::string>;

constexpr static auto kPlaceholderIndex = get_index_v<std::monostate, variant_t>;
constexpr static auto kIntIndex = get_index_v<int, variant_t>;
constexpr static auto kFloatIndex = get_index_v<float, variant_t>;
constexpr static auto kStringIndex = get_index_v<std::string, variant_t>;
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.

通过get_index_v，我就可以知道数据类型在variant中的index，以后即使有改动也不需要担心，它都会自动处理。再贴一段它的测试代码：

void test_using_index() {
    std::cout << "kPlaceholderIndex " << kPlaceholderIndex << "\n";
    std::cout << "kIntIndex " << kIntIndex << "\n";
    std::cout << "kFloatIndex " << kFloatIndex << "\n";
    std::cout << "kStringIndex " << kStringIndex << "\n";

    auto custom_visitor = [](const auto& value) {
        switch (value.index()) {
            case kPlaceholderIndex:
                std::cout << "placehodler value "
                          << "\n";
                break;
            case kIntIndex:
                std::cout << "int value " << std::get<int>(value) << "\n";
                break;
            case kFloatIndex:
                std::cout << "float value " << std::get<float>(value) << "\n";
                break;
            case kStringIndex:
                std::cout << "string value " << std::get<std::string>(value) << "\n";
                break;
        }
    };
    variant_t var;
    custom_visitor(var);

    var = 1;
    custom_visitor(var);

    var = 2.90f;
    custom_visitor(var);

    var = std::string("hello world");
    custom_visitor(var);

    var = std::string("hello type");
}

int main() { test_using_index(); }
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.

结果在这：

kPlaceholderIndex 0
kIntIndex 1
kFloatIndex 2
kStringIndex 3
placehodler value
int value 1
float value 2.9
string value hello world
1.
2.
3.
4.
5.
6.
7.
8.

是不是很方便?

其实上面的代码，个人认为它也是一种多态，尽管它就是一个普通的switch-case，然而，我们可以使用std::visit稍微改装一下。

那std::visit怎么用?看这段代码：

struct Visitor {
    void operator()(int i) const { std::cout << "int " << i << "\n"; }

    void operator()(float f) const { std::cout << "float " << f << "\n"; }

    void operator()(std::string s) const { std::cout << "string " << s << "\n"; }
};

void test_visitor_functor() {
    std::variant<int, float, std::string> var;
    var = 1;
    std::visit(Visitor(), var);
    var = 2.90f;
    std::visit(Visitor(), var);
    var = std::string("hello world");
    std::visit(Visitor(), var);
}

// 输出
int 1
float 2.9
string hello world
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

visit内部会自动判断当前variant内部存储的类型，进而触发不同的行为。

上面是使用仿函数搭配的visit，其实使用lambda表达式更方便：

void test_visitor_lambda() {
    std::variant<int, float, std::string> var;
    var = 1;
    std::visit([](const auto& value) { std::cout << "value " << value << "\n"; }, var);
    var = 2.90f;
    std::visit([](const auto& value) { std::cout << "value " << value << "\n"; }, var);
    var = std::string("hello world");
    std::visit([](const auto& value) { std::cout << "value " << value << "\n"; }, var);
    var = std::string("hello type");
    std::visit(
        [](const auto& value) {
            using T = std::decay_t<decltype(value)>;
            if constexpr (std::is_same_v<T, int>) {
                std::cout << "int value " << value << "\n";
            } else if constexpr (std::is_same_v<T, float>) {
                std::cout << "float value " << value << "\n";
            } else if constexpr (std::is_same_v<T, std::string>) {
                std::cout << "string value " << value << "\n";
            }
        },
        var);
}

// 输出
value 1
value 2.9
value hello world
string value hello type
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.

看到这里大家应该也悟到了，可以使用std::visit搭配variant来实现多态。

下面是我写的几个variant的多态示例：

struct A {
    void func() const { std::cout << "func A \n"; }
};

struct B {
    void func() const { std::cout << "func B \n"; }
};

struct CallFunc {
    void operator()(const A& a) { a.func(); }
    void operator()(const B& b) { b.func(); }
};

void test_no_param_polymorphism() {
    std::variant<A, B> var;
    var = A();
    std::visit(CallFunc{}, var);
    var = B();
    std::visit(CallFunc{}, var);
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

上面的是没有参数的多态，那如果想为函数添加一些参数怎么办?

可以利用仿函数中的成员变量，即：

struct C {
    void func(int value) const { std::cout << "func C " << value << "\n"; }
};

struct D {
    void func(int value) const { std::cout << "func D " << value << "\n"; }
};

struct CallFuncParam {
    void operator()(const C& c) { c.func(value); }
    void operator()(const D& d) { d.func(value); }

    int value;
};

void test_param_polymorphism() {
    std::variant<C, D> var;
    var = C();
    std::visit(CallFuncParam{1}, var);
    var = D();
    std::visit(CallFuncParam{2}, var);
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

或者lambda表达式的捕获方式，即：

void test_param_lambda_polymorphism() {
    std::variant<C, D> var;
    int value = 1;
    auto caller = [&value](const auto& v) { v.func(value); };
    std::visit(caller, var);
    value = 2;
    std::visit(caller, var);
}
1.
2.
3.
4.
5.
6.
7.
8.