Skip to content

Commit c7336bd

Browse files
chengxumiaodarenchengxumiaodaren
committed
add some test code
1 parent b1150ef commit c7336bd

8 files changed

Lines changed: 582 additions & 0 deletions

‎src/test_multi_array.cc‎

Lines changed: 75 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,75 @@
1+
#include <array>
2+
#include <iostream>
3+
4+
void test_two_dim_array() {
5+
int multi_array_native[3][4];
6+
std::array<std::array<int, 3>, 4> multi_array;
7+
///< 但其实它俩不相同，应该是
8+
std::array<std::array<int, 4>, 3> multi_arrays;
9+
}
10+
11+
template <typename T, size_t R, size_t C>
12+
using TwoDimMatrix = std::array<std::array<T, C>, R>;
13+
14+
void test_two_dim_matrix() {
15+
constexpr size_t row = 2;
16+
constexpr size_t col = 3;
17+
TwoDimMatrix<int, row, col> mat;
18+
int k = 0;
19+
for (int i = 0; i < row; ++i) {
20+
for (int j = 0; j < col; ++j) {
21+
mat[i][j] = ++k;
22+
}
23+
}
24+
25+
for (int i = 0; i < row; ++i) {
26+
for (int j = 0; j < col; ++j) {
27+
std::cout << mat[i][j] << " ";
28+
}
29+
}
30+
}
31+
32+
///< 利用模板元编程
33+
template <typename T, size_t R, size_t... C>
34+
struct Matrix {
35+
using Col = typename Matrix<T, C...>::type;
36+
using type = std::array<Col, R>;
37+
};
38+
39+
template <typename T, size_t R>
40+
struct Matrix<T, R> {
41+
using type = std::array<T, R>;
42+
};
43+
44+
void test_multi_array() {
45+
constexpr size_t a = 2;
46+
constexpr size_t b = 3;
47+
constexpr size_t c = 4;
48+
constexpr size_t d = 5;
49+
Matrix<int, a, b, c, d>::type mat;
50+
int u = 0;
51+
for (int i = 0; i < a; ++i) {
52+
for (int j = 0; j < b; ++j) {
53+
for (int k = 0; k < c; ++k) {
54+
for (int m = 0; m < d; ++m) {
55+
mat[i][j][k][m] = ++u;
56+
}
57+
}
58+
}
59+
}
60+
for (int i = 0; i < a; ++i) {
61+
for (int j = 0; j < b; ++j) {
62+
for (int k = 0; k < c; ++k) {
63+
for (int m = 0; m < d; ++m) {
64+
std::cout << mat[i][j][k][m] << " ";
65+
}
66+
}
67+
}
68+
}
69+
}
70+
71+
int main() {
72+
test_two_dim_matrix();
73+
std::cout << "\n";
74+
test_multi_array();
75+
}

‎src/test_shared_ptr.cc‎

Lines changed: 141 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,141 @@
1+
#include <atomic>
2+
#include <iostream>
3+
4+
class SharedCount {
5+
public:
6+
SharedCount() : count_{1} {}
7+
8+
void add() { ++count_; }
9+
10+
void minus() { --count_; }
11+
12+
int get() const { return count_; }
13+
14+
private:
15+
std::atomic<int> count_;
16+
};
17+
18+
template <typename T>
19+
class SharedPtr {
20+
public:
21+
template <typename U>
22+
friend class SharedPtr;
23+
24+
template <typename K, typename U>
25+
friend SharedPtr<K> static_pointer_cast(const SharedPtr<U>& p);
26+
27+
SharedPtr(T* ptr) : ptr_{ptr}, ref_count_{new SharedCount} {}
28+
29+
SharedPtr() : ptr_{nullptr}, ref_count_{new SharedCount} {}
30+
31+
~SharedPtr() { clean(); }
32+
33+
SharedPtr(const SharedPtr& p) {
34+
this->ptr_ = p.ptr_;
35+
this->ref_count_ = p.ref_count_;
36+
ref_count_->add();
37+
}
38+
39+
SharedPtr(SharedPtr&& p) {
40+
this->ptr_ = p.ptr_;
41+
this->ref_count_ = p.ref_count_;
42+
p.ptr_ = nullptr;
43+
p.ref_count_ = nullptr;
44+
}
45+
46+
SharedPtr& operator=(const SharedPtr& p) {
47+
clean();
48+
this->ptr_ = p.ptr_;
49+
this->ref_count_ = p.ref_count_;
50+
ref_count_->add();
51+
return *this;
52+
}
53+
54+
SharedPtr& operator=(SharedPtr&& p) {
55+
clean();
56+
this->ptr_ = p.ptr_;
57+
this->ref_count_ = p.ref_count_;
58+
p.ptr_ = nullptr;
59+
p.ref_count_ = nullptr;
60+
return *this;
61+
}
62+
63+
int use_count() { return ref_count_->get(); }
64+
65+
T* get() const { return ptr_; }
66+
67+
T* operator->() const { return ptr_; }
68+
69+
T& operator*() const { return *ptr_; }
70+
71+
operator bool() const { return ptr_; }
72+
73+
private:
74+
template <typename U>
75+
SharedPtr(const SharedPtr<U>& p, T* ptr) {
76+
this->ptr_ = ptr;
77+
this->ref_count_ = p.ref_count_;
78+
ref_count_->add();
79+
}
80+
81+
void clean() {
82+
if (ref_count_) {
83+
ref_count_->minus();
84+
if (ref_count_->get() == 0) {
85+
if (ptr_) delete ptr_;
86+
delete ref_count_;
87+
}
88+
}
89+
}
90+
91+
T* ptr_;
92+
SharedCount* ref_count_;
93+
};
94+
95+
template <typename T, typename U>
96+
SharedPtr<T> static_pointer_cast(const SharedPtr<U>& p) {
97+
T* ptr = static_cast<T*>(p.get());
98+
return SharedPtr<T>(p, ptr);
99+
}
100+
101+
struct A {
102+
A() { std::cout << "A() \n"; }
103+
~A() { std::cout << "~A() \n"; }
104+
};
105+
106+
struct B : A {
107+
B() { std::cout << "B() \n"; }
108+
~B() { std::cout << "~B() \n"; }
109+
};
110+
111+
void test_cast_shared() {
112+
B* a = new B;
113+
SharedPtr<B> ptr(a);
114+
{
115+
std::cout << ptr.use_count() << std::endl;
116+
SharedPtr<A> b = static_pointer_cast<A>(ptr);
117+
std::cout << ptr.use_count() << std::endl;
118+
SharedPtr<B> c = ptr;
119+
std::cout << ptr.use_count() << std::endl;
120+
SharedPtr<B> d = ptr;
121+
std::cout << ptr.use_count() << std::endl;
122+
}
123+
std::cout << ptr.use_count() << std::endl;
124+
}
125+
126+
void test_simple_shared() {
127+
A* a = new A;
128+
SharedPtr<A> ptr(a);
129+
{
130+
std::cout << ptr.use_count() << std::endl;
131+
SharedPtr<A> b = ptr;
132+
std::cout << ptr.use_count() << std::endl;
133+
SharedPtr<A> c = ptr;
134+
std::cout << ptr.use_count() << std::endl;
135+
SharedPtr<A> d = std::move(b);
136+
std::cout << ptr.use_count() << std::endl;
137+
}
138+
std::cout << ptr.use_count() << std::endl;
139+
}
140+
141+
int main() { test_simple_shared(); }

‎src/test_unique_ptr.cc‎

Lines changed: 52 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,52 @@
1+
#include <iostream>
2+
3+
template <typename T>
4+
class UniquePtr {
5+
public:
6+
UniquePtr(T* ptr) : ptr_{ptr} {}
7+
8+
UniquePtr() : ptr_{nullptr} {}
9+
10+
UniquePtr(const UniquePtr& p) = delete;
11+
UniquePtr& operator=(const UniquePtr& p) = delete;
12+
13+
UniquePtr(UniquePtr&& p) {
14+
this->ptr_ = p.ptr_;
15+
p.ptr_ = nullptr;
16+
}
17+
18+
UniquePtr& operator=(UniquePtr&& p) {
19+
clean();
20+
this->ptr_ = p.ptr_;
21+
p.ptr_ = nullptr;
22+
return *this;
23+
}
24+
25+
T* get() const { return ptr_; }
26+
27+
T* operator->() const { return ptr_; }
28+
29+
T& operator*() const { return *ptr_; }
30+
31+
operator bool() const { return ptr_; }
32+
33+
~UniquePtr() { clean(); }
34+
35+
private:
36+
void clean() {
37+
if (ptr_) delete ptr_;
38+
}
39+
40+
T* ptr_;
41+
};
42+
43+
struct A {
44+
A() { std::cout << "A() \n"; }
45+
~A() { std::cout << "~A() \n"; }
46+
};
47+
48+
int main() {
49+
A* a = new A;
50+
UniquePtr<A> ptr(a);
51+
UniquePtr<A> b(std::move(ptr));
52+
}

‎src/variant/test_variant_index.cc‎

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,78 @@
1+
#include <iostream>
2+
#include <string>
3+
#include <variant>
4+
5+
void test_index() {
6+
std::variant<std::monostate, int, float, std::string> var;
7+
var = 1;
8+
std::cout << var.index() << "\n";
9+
var = 2.90f;
10+
std::cout << var.index() << "\n";
11+
var = std::string("hello world");
12+
std::cout << var.index() << "\n";
13+
}
14+
15+
template <typename T, typename>
16+
struct get_index;
17+
18+
template <size_t I, typename... Ts>
19+
struct get_index_impl {};
20+
21+
template <size_t I, typename T, typename... Ts>
22+
struct get_index_impl<I, T, T, Ts...> : std::integral_constant<size_t, I> {};
23+
24+
template <size_t I, typename T, typename U, typename... Ts>
25+
struct get_index_impl<I, T, U, Ts...> : get_index_impl<I + 1, T, Ts...> {};
26+
27+
template <typename T, typename... Ts>
28+
struct get_index<T, std::variant<Ts...>> : get_index_impl<0, T, Ts...> {};
29+
30+
template <typename T, typename... Ts>
31+
constexpr auto get_index_v = get_index<T, Ts...>::value;
32+
33+
using variant_t = std::variant<std::monostate, int, float, std::string>;
34+
35+
constexpr static auto kPlaceholderIndex = get_index_v<std::monostate, variant_t>;
36+
constexpr static auto kIntIndex = get_index_v<int, variant_t>;
37+
constexpr static auto kFloatIndex = get_index_v<float, variant_t>;
38+
constexpr static auto kStringIndex = get_index_v<std::string, variant_t>;
39+
40+
void test_using_index() {
41+
std::cout << "kPlaceholderIndex " << kPlaceholderIndex << "\n";
42+
std::cout << "kIntIndex " << kIntIndex << "\n";
43+
std::cout << "kFloatIndex " << kFloatIndex << "\n";
44+
std::cout << "kStringIndex " << kStringIndex << "\n";
45+
46+
auto custom_visitor = [](const auto& value) {
47+
switch (value.index()) {
48+
case kPlaceholderIndex:
49+
std::cout << "placehodler value "
50+
<< "\n";
51+
break;
52+
case kIntIndex:
53+
std::cout << "int value " << std::get<int>(value) << "\n";
54+
break;
55+
case kFloatIndex:
56+
std::cout << "float value " << std::get<float>(value) << "\n";
57+
break;
58+
case kStringIndex:
59+
std::cout << "string value " << std::get<std::string>(value) << "\n";
60+
break;
61+
}
62+
};
63+
variant_t var;
64+
custom_visitor(var);
65+
66+
var = 1;
67+
custom_visitor(var);
68+
69+
var = 2.90f;
70+
custom_visitor(var);
71+
72+
var = std::string("hello world");
73+
custom_visitor(var);
74+
75+
var = std::string("hello type");
76+
}
77+
78+
int main() { test_using_index(); }

‎src/variant/test_variant_monostate.cc‎

Lines changed: 40 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
#include <iostream>
2+
#include <variant>
3+
4+
/**
5+
* @brief 为什么要使用monostate
6+
*
7+
*/
8+
9+
struct S {
10+
S(int i) : value{i} {}
11+
int value;
12+
};
13+
14+
void test_monostate() {
15+
std::variant<std::monostate, S> var;
16+
var = 12;
17+
std::cout << std::get<S>(var).value << "\n";
18+
}
19+
20+
/*
21+
void test_monostate2() {
22+
///< 编译失败，S如果没有构造函数，需要加monostate
23+
std::variant<S> var;
24+
var = 12;
25+
std::cout << std::get<S>(var).value << "\n";
26+
}
27+
*/
28+
29+
void test_variant() {
30+
std::variant<int, float> var;
31+
var = 12;
32+
std::cout << std::get<int>(var) << "\n";
33+
var = 12.1f;
34+
std::cout << std::get<float>(var) << "\n";
35+
}
36+
37+
int main() {
38+
test_monostate();
39+
test_variant();
40+
}

0 commit comments

Comments
 (0)