├── README.md
├── doc
├── C++20新特性.png
├── C++入门知识点.png
├── C++必备知识点.png
├── C++的坑.png
├── MoreCppIdioms.pdf
├── c++学习路线图.png
├── profiling_tools.pdf
└── 程序喵大人学习宝典第一版.pdf
├── img
├── cxmdr.jpg
└── wechat.jpg
└── src
├── test_multi_array.cc
├── test_shared_ptr.cc
├── test_unique_ptr.cc
└── variant
├── test_variant_index.cc
├── test_variant_monostate.cc
├── test_variant_polymorphism.cc
├── test_variant_visit.cc
└── test_why_variant.cc
/README.md:
--------------------------------------------------------------------------------
1 | # C++学习
2 |
3 | 致力于搭建一个最好的C++学习平台。
4 |
5 | **很多人不知道是否应该入坑C++**
6 | **很多人不知道如何准备C++面试**
7 | **很多人不知道如何入门C++**
8 | **很多人不知道如何进阶C++**
9 |
10 |
11 | 这些人可以来这里看看！**如果大家有学习资源推荐，欢迎提MR**。
12 |
13 | **欢迎大家的批评指正，但不接受喷子，感谢支持，如果大家觉得不错，求给个star！**
14 |
15 | **如果阅读时，发现错误，或者其它任何问题可以提issue**
16 |
17 | 另外大家也可以关注我的**公众号：程序喵大人**，以后所有文章都会首发在公众号上，下面是公众号二维码，谢谢大家支持。
18 | 
(var).value << "\n";
18 | }
19 |
20 | /*
21 | void test_monostate2() {
22 | ///< 编译失败，S如果没有构造函数，需要加monostate
23 | std::variant var;
24 | var = 12;
25 | std::cout << std::get(var).value << "\n";
26 | }
27 | */
28 |
29 | void test_variant() {
30 | std::variant var;
31 | var = 12;
32 | std::cout << std::get(var) << "\n";
33 | var = 12.1f;
34 | std::cout << std::get(var) << "\n";
35 | }
36 |
37 | int main() {
38 | test_monostate();
39 | test_variant();
40 | }
41 |
--------------------------------------------------------------------------------
/src/variant/test_variant_polymorphism.cc:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | struct A {
6 | void func() const { std::cout << "func A \n"; }
7 | };
8 |
9 | struct B {
10 | void func() const { std::cout << "func B \n"; }
11 | };
12 |
13 | struct CallFunc {
14 | void operator()(const A& a) { a.func(); }
15 | void operator()(const B& b) { b.func(); }
16 | };
17 |
18 | void test_no_param_polymorphism() {
19 | std::variant var;
20 | var = A();
21 | std::visit(CallFunc{}, var);
22 | var = B();
23 | std::visit(CallFunc{}, var);
24 | }
25 |
26 | struct C {
27 | void func(int value) const { std::cout << "func C " << value << "\n"; }
28 | };
29 |
30 | struct D {
31 | void func(int value) const { std::cout << "func D " << value << "\n"; }
32 | };
33 |
34 | struct CallFuncParam {
35 | void operator()(const C& c) { c.func(value); }
36 | void operator()(const D& d) { d.func(value); }
37 |
38 | int value;
39 | };
40 |
41 | void test_param_polymorphism() {
42 | std::variant var;
43 | var = C();
44 | std::visit(CallFuncParam{1}, var);
45 | var = D();
46 | std::visit(CallFuncParam{2}, var);
47 | }
48 |
49 | void test_param_lambda_polymorphism() {
50 | std::variant var;
51 | int value = 1;
52 | auto caller = [&value](const auto& v) { v.func(value); };
53 | std::visit(caller, var);
54 | value = 2;
55 | std::visit(caller, var);
56 | }
57 |
58 | int main() {
59 | test_no_param_polymorphism();
60 | std::cout << " ====== \n";
61 | test_param_polymorphism();
62 | std::cout << " ====== \n";
63 | test_param_lambda_polymorphism();
64 | }
65 |
--------------------------------------------------------------------------------
/src/variant/test_variant_visit.cc:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | struct Visitor {
6 | void operator()(int i) const { std::cout << "int " << i << "\n"; }
7 |
8 | void operator()(float f) const { std::cout << "float " << f << "\n"; }
9 |
10 | void operator()(std::string s) const { std::cout << "string " << s << "\n"; }
11 | };
12 |
13 | void test_visitor_functor() {
14 | std::variant var;
15 | var = 1;
16 | std::visit(Visitor(), var);
17 | var = 2.90f;
18 | std::visit(Visitor(), var);
19 | var = std::string("hello world");
20 | std::visit(Visitor(), var);
21 | }
22 |
23 | void test_visitor_lambda() {
24 | std::variant var;
25 | var = 1;
26 | std::visit([](const auto& value) { std::cout << "value " << value << "\n"; }, var);
27 | var = 2.90f;
28 | std::visit([](const auto& value) { std::cout << "value " << value << "\n"; }, var);
29 | var = std::string("hello world");
30 | std::visit([](const auto& value) { std::cout << "value " << value << "\n"; }, var);
31 | var = std::string("hello type");
32 | std::visit(
33 | [](const auto& value) {
34 | using T = std::decay_t;
35 | if constexpr (std::is_same_v) {
36 | std::cout << "int value " << value << "\n";
37 | } else if constexpr (std::is_same_v) {
38 | std::cout << "float value " << value << "\n";
39 | } else if constexpr (std::is_same_v) {
40 | std::cout << "string value " << value << "\n";
41 | }
42 | },
43 | var);
44 | }
45 |
46 | int main() {
47 | test_visitor_functor();
48 | std::cout << "=========== \n";
49 | test_visitor_lambda();
50 | }
51 |
--------------------------------------------------------------------------------
/src/variant/test_why_variant.cc:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | union MyUnion {
6 | int a;
7 | float b;
8 | double c;
9 | };
10 |
11 | void test_simple_union() {
12 | MyUnion u;
13 | u.a = 1;
14 | std::cout << u.a << "\n";
15 |
16 | u.b = 1.32f;
17 | std::cout << u.b << "\n";
18 |
19 | u.c = 2.32;
20 | std::cout << u.c << "\n";
21 | }
22 |
23 | struct A {
24 | A() = default;
25 | A(int aa) : a{aa} { std::cout << "A() \n"; }
26 | ~A() { std::cout << "~A() \n"; }
27 | int a;
28 | };
29 |
30 | struct B {
31 | B() = default;
32 | B(float bb) : b{bb} { std::cout << "B() \n"; }
33 | ~B() { std::cout << "~B() \n"; }
34 | float b;
35 | };
36 |
37 | union MyStructUnion {
38 | A a;
39 | B b;
40 | /**
41 | * @brief 在析构函数中我要做什么？不知道当前类型究竟是A还是B
42 | * 那调用 a.~A() 还是 b.~B() ?
43 | */
44 | ~MyStructUnion() { std::cout << "~MyStructUnion() \n"; }
45 | };
46 |
47 | /**
48 | * @brief 需要手动调用析构函数
49 | *
50 | */
51 | void test_struct_union() {
52 | MyStructUnion u;
53 |
54 | new (&u.a) A(1);
55 | std::cout << u.a.a << "\n";
56 | u.a.~A();
57 |
58 | u.b = B(2.3f);
59 | std::cout << u.b.b << "\n";
60 | u.b.~B();
61 | }
62 |
63 | struct C {
64 | C() = default;
65 | C(std::string cc) : c{cc} { std::cout << "C() \n"; }
66 | ~C() { std::cout << "~C() \n"; }
67 | std::string c;
68 | };
69 |
70 | /**
71 | * @brief 使用variant完全不需要手动调用构造和析构函数，它会自动处理好所有逻辑，非常方便
72 | *
73 | */
74 | void test_variant() {
75 | std::variant u;
76 | u = 1;
77 | std::cout << std::get(u).a << "\n";
78 | u = std::string("dsd");
79 | std::cout << std::get(u).c << "\n";
80 | }
81 |
82 | int main() { test_variant(); }
83 |
--------------------------------------------------------------------------------