ajax和axios用哪个（数据请求中AjaxFetch以及Axios的区别）
ajax和axios用哪个（数据请求中AjaxFetch以及Axios的区别）再看一段代码：这里有一个很重要的点，我没法获取当前存储的数据是什么类型，比如我当前存储的是float，但是却按int方式获取，这不就坏事了吗。那肯定是因为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";
作者：程序喵
大家应该都知道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 world1.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 world1.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 type1.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.
到这里已经介绍了variant实现多态的完整方案。
认为继承是个洪水猛兽的朋友，其实也可以考虑variant来实现多态的行为哈。
那同样是实现多态，是用继承好呢，还是用variant好呢?可以看这个图：
图片来源于这个链接：http://cpptruths.blogspot.com/2018/02/inheritance-vs-stdvariant-based.html。大家感兴趣的可以直接移步哈。
另外大家应该也比较感兴趣variant是如何实现的。关于如何实现variant，我找到了这篇文章，写的很不错，大家可以看看：https://www.cnblogs.com/qicosmos/p/3416432.html
下面是本文参考链接：
https://www.cppstories.com/2020/04/variant-virtual-polymorphism.html/
https://stackoverflow.com/questions/52296889/what-are-the-advantages-of-using-stdvariant-as-opposed-to-traditional-polymorp
https://www.cppstories.com/2018/06/variant/
http://cpptruths.blogspot.com/2018/02/inheritance-vs-stdvariant-based.html
打完收工。
完整代码见：
https://github.com/chengxumiaodaren/cpp-learning/tree/master/src/variant
来源： 程序喵大人
