如何使用mysql實現可重入的分散式鎖 目錄 什麼是分散式鎖？ 如何實現分散式鎖？ 定義分散式表結構 定義鎖統一介面 使用mysql來實現分散式鎖 ① 生成線程標記ID ② 加鎖 ③ 解鎖 ④ 重置鎖 寫在最後 1. 什麼是分散式鎖？ 百度百科：分散式鎖是控制分散式系統之間同步訪問共用資源的一種方式 ...
Generic Types of Ranges
類型萃取從字面意思上來說其實就是幫助我們挑選某個對象的類型，篩選特定的對象來做特定的事。可以先來回顧一下以前的寫法。
#include <vector>
#include <iterator>
int main() {
std::vector v{1, 2, 3};
using iterator_type = std::vector<int>::iterator;
using difference_type = std::iterator_traits<iterator_type>::difference_type;
using iterator_catogory = std::iterator_traits<iterator_type>::iterator_category;
using pointer = std::iterator_traits<iterator_type>::pointer;
using reference = std::iterator_traits<iterator_type>::reference;
using value_type = std::iterator_traits<iterator_type>::value_type;
}到了C++20，我們有了ranges，我們有了更多強大的工具，可以說它們是處理ranges的強大工具，我們來看看具體的內容。
通過上圖，很多內容都直觀明瞭，為了避免晦澀難懂的抽象話術，我們通過代碼來看看具體用法。
#include <vector>
#include <ranges>
#include <algorithm>
#include <iterator>
#include <type_traits>
int main() {
std::vector v{10, 20, 30};
static_assert(std::is_same_v<std::ranges::iterator_t<decltype(v)>::difference_type,
std::iterator_traits<decltype(v)::iterator>::difference_type>); // OK
static_assert(std::is_same_v<std::ranges::iterator_t<decltype(v)>::pointer,
std::iterator_traits<decltype(v)::iterator>::pointer>); // OK
static_assert(std::is_same_v<std::ranges::iterator_t<decltype(v)>::reference,
std::iterator_traits<decltype(v)::iterator>::reference>); // OK
static_assert(std::is_same_v<std::ranges::iterator_t<decltype(v)>::value_type,
std::iterator_traits<decltype(v)::iterator>::value_type>); // OK
static_assert(std::is_same_v<std::ranges::iterator_t<decltype(v)>::iterator_category,
std::iterator_traits<decltype(v)::iterator>::iterator_category>); // OK
// 可以明顯看到，比起傳統的迭代器萃取，C++20的處理方式更加簡潔，只用傳入ranges類型，而不用傳入迭代器類型，或許這就是ranges的魅力所在。
static_assert(std::is_same_v<std::ranges::sentinel_t<decltype(v)>,
decltype(end(v))>); // OK
// 獲取哨兵類型。
static_assert(std::is_same_v<std::ranges::range_reference_t<decltype(v)>,
decltype(v[0])>); // OK, both are int&
static_assert(std::is_same_v<std::ranges::range_reference_t<decltype(v)>,
std::remove_reference_t<decltype(v[0])>>); // Error, int& and int
static_assert(std::is_same_v<std::ranges::range_value_t<decltype(v)>,
std::remove_reference_t<decltype(v[0])>>); // OK, both are int
static_assert(std::is_same_v<std::ranges::range_value_t<decltype(v)>,
decltype(v[0])>); // Error, int and int&
static_assert(std::is_same_v<std::ranges::range_size_t<decltype(v)>,
std::size_t>); // OK
static_assert(std::is_same_v<std::ranges::range_difference_t<decltype(v)>,
std::ptrdiff_t>); // OK
static_assert(std::is_same_v<std::ranges::range_rvalue_reference_t<decltype(v)>,
decltype(std::move(v[0]))>); // OK
static_assert(std::is_same_v<std::ranges::borrowed_iterator_t<decltype(v)>,
std::ranges::dangling>); // OK
static_assert(std::is_same_v<std::ranges::borrowed_subrange_t<decltype(v)>,
std::ranges::dangling>); // OK
}
Generic Types of Iterators
回到迭代器這一話題，為了更好的支持新的迭代器類型特征，你應該用如下的方式來代替傳統的類型萃取。
#include <vector>
#include <ranges>
#include <type_traits>
#include <iterator>
int main() {
std::vector v{1, 2, 3};
using iterator_type = std::vector<int>::iterator;
static_assert(std::is_same_v<std::iter_value_t<std::ranges::iterator_t<decltype(v)>>, int>);
static_assert(std::is_same_v<std::iter_reference_t<std::ranges::iterator_t<decltype(v)>>, int&>);
static_assert(std::is_same_v<std::iter_rvalue_reference_t<std::ranges::iterator_t<decltype(v)>>, int&&>);
static_assert(std::is_same_v<std::iter_difference_t<std::ranges::iterator_t<decltype(v)>>, std::ptrdiff_t>);
using type1 = std::common_reference_t<int, int>; // int
using type2 = std::common_reference_t<int&, int>; // int
using type3 = std::common_reference_t<int&, int&>; // int&
using type4 = std::common_reference_t<int&, int&&>; // const int&
using type5 = std::common_reference_t<int&&, int&&>; // int&&
}common_reference_t過於複雜，暫且先跳過。可以看到，這也是萃取類型的一種方式，只不過寫法不同罷了。話說回來，std::ranges::range_value_t<Rg>其實就是std::iter_value_t<std::ranges::iterator_t<Rg>>的簡化。
New Functional Types
std::identity是一個函數對象，返回對象本身，可以搭配ranges的演算法一起使用。
#include <iostream>
#include <functional>
#include <vector>
#include <ranges>
#include <algorithm>
int main() {
std::vector v{1, 2, 3};
auto pos = std::ranges::find(v, 9, [](auto x) { return x * x; });
if (pos != end(v))
std::cout << "Exist\n";
auto pos2 = std::ranges::find(v, 3, std::identity{});
if (pos2 != end(v))
std::cout << "Exist\n";
auto pos3 = std::ranges::find(v, 3);
if (pos3 != end(v))
std::cout << "Exist\n";
}pos處傳入一個lambda表達式，對容器當中的每一個元素進行平方，然後返回對應的迭代器。pos2處傳入的正是std::identity，即對象自身，相當於不對原容器進行任何的具體操作，它跟pos3本質上是相同的。
std::compare_three_way也是一個函數對象，它與<=>這個運算符有關聯。這個運算符有個有意思的名字，叫宇宙飛船運算符，因為它的形狀長得像宇宙飛船。這是C++20比較有意思的一個特性。
#include <iostream>
#include <type_traits>
#include <functional>
int main() {
int a{3}, b{4};
auto result = (a <=> b);
if (result < 0)
std::cout << "a < b\n";
else if (result == 0)
std::cout << "a == b\n";
else
std::cout << "a > b\n";
}
Other New Types for Dealing with Iterators
C++20，還有更多的值得探索......
