1
//初始化为空
2
std::optional<int> emptyInt;
3
std::optional<double> emptyDouble = std::nullopt;
4
//直接用有效值初始化
5
std::optional<int> intOpt{10};
6
std::optional intOptDeduced{10.0}; // auto deduced
7
//使用make_optional
8
auto doubleOpt = std::make_optional(10.0);
9
auto complexOpt = std::make_optional<std::complex<double>>(3.0, 4.0);
10
//使用in_place 后文会提到
11
std::optional<std::complex<double>> complexOpt{std::in_place, 3.0, 4.0};
12
std::optional<std::vector<int>> vectorOpt{std::in_place, {1, 2, 3}};
13
//使用其它optional对象构造
14
auto optCopied = vectorOpt;

1
std::optional<int> find_index(const std::vector<int>& data, int value) {
2
    auto iter = std::find(data.begin(), data.end(), value);
3
    if (iter != data.end()) {
4
        return std::distance(data.begin(), iter);
5
    }
6
    return std::nullopt; // 注意这个 也可以直接返回{}
7
    // std::nullopt 是 std::nullopt_t 类型的常量，用于指示 optional 不含值。
8
}
9
int main() {
10
    vector<int> myvec{1, 2, 3, 4, 5};
11
    auto s = find_index(myvec, 3);
12
    auto ss = find_index(myvec, 6);
13
    if (s) {                        // 判断是否有值方法1
14
        cout << s.value() << endl;  // 获取值方法1
15
        cout << *s << endl;         // 获取值方法2
16
    }
17
    if (s.has_value()) {  // 判断是否有值方法2
18
        cout << s.value() << endl;
19
        cout << *s << endl;
20
    }
21
}

1
std::optional<int> int1(1);
2
std::optional<int> int2(10);
3
std::optional<int> int3;
4

5
std::cout << std::boolalpha;
6
std::cout << (int1 < int2) << std::endl; // true
7
std::cout << (int2 > int1) << std::endl; // true
8
std::cout << (int3 == std::nullopt) << std::endl; // true
9
std::cout << (int3 < int1) << std::endl; // true

1
class myclass {
2
   public:
3
    myclass() : mInt(100) {}
4

5
    int mInt;
6
};
7
class myclass2 {
8
   public:
9
    myclass2(int x, int y) : mInt(x+y) {
10
        cout << "constructor" << endl;
11
    }
12
    myclass2(const myclass2& x) : mInt(x.mInt) {
13
        cout << "copy constructor" << endl;
14
    }
15
    myclass2(myclass2&& x) : mInt(x.mInt) {
16
        cout << "move constructor" << endl;
17
    }
18
    int mInt;
19
};
20
class myclass3 {
21
   public:
22
    myclass3(int x) : mInt(x) {
23
        cout << "constructor" << endl;
24
    }
25
    myclass3(const myclass3& x) : mInt(x.mInt) {
26
        cout << "copy constructor" << endl;
27
    }
28
    myclass3(myclass3&& x) : mInt(x.mInt) {
29
        cout << "move constructor" << endl;
30
    }
31
    int mInt;
32
};
33
int main() {
34
    std::optional<myclass> sample;
35
    std::optional<myclass> sample2{};
36

37
    cout << boolalpha;
38
    cout << sample.has_value() << endl; // false
39
    cout << sample2.has_value() << endl;// false
40
}

1
std::optional<myclass> sample3{myclass()};

1
std::optional<myclass> sample4{std::in_place};
2
cout << sample4.has_value() << endl; // true
3
cout << sample4->mInt << endl; // 100
4
std::optional<myclass> sample5(std::make_optional<myclass>());
5
cout << sample5.has_value() << endl;// true
6
cout << sample5->mInt << endl; // 100

1
std::optional<myclass2> sample6{std::in_place, 1,3}; //1 OK
2
std::optional<myclass2> sample7{1, 3}; //2 不OK
3
std::optional<myclass2> sample8{{1, 3}}; //3 OK 但是有拷贝
4

5

6
std::optional<myclass3> sample9{std::in_place, 1}; //4 OK
7
std::optional<myclass3> sample10{1}; //5 OK

1
myobj do_something() {
2
    std::optional<myobj> opt{2};
3
    cout << "--" << endl;
4
    return *opt; // 和opt.value()一样。不过现在会拷贝
5
}
6
myobj do_something2() {
7
    std::optional<myobj> opt{2};
8
    cout << "--" << endl;
9
    return std::move(opt.value());
10
}

1
void dummy(myobj obj) { cout << "dummy" << endl; }
2
void do_something3(bool input) {
3
    std::optional<myobj> opt{2};
4
    if (input) {
5
        dummy(std::move(opt.value())); // opt.value，也就是myobj本身是垃圾值了
6
    }
7
    cout << boolalpha << opt.has_value() << endl; // opt含值
8
    // 过了很久，插入一堆其他逻辑
9
    if (input) {
10
        dummy(std::move(opt.value())); // 出问题了，move了两次
11
    }
12
}

1
int a{1};
2
float b{2.3};
3
double c{3.2};
4
std::string d {"abc"};
5
auto t = std::tuple{a, b, c, d}; //c++17后可以不指定类模板参数
6
auto t2 = std::make_tuple(a, b, c, d);

1
template <typename T>
2
void func(T a) {
3
    cout << __PRETTY_FUNCTION__ << endl;
4
}
5

6
int main() {
7
    int a{1};
8
    float b{2.3};
9
    double c{3.2};
10
    std::string d{"hello"};
11
    auto t = std::tuple{std::ref(a), std::ref(b), std::cref(c), std::cref(d)}; //c++17后可以不指定类模板参数
12
    auto t2 = std::make_tuple(std::ref(a), std::ref(b), std::cref(c), std::cref(d));
13
    func(t);
14
    func(t2);
15
}
16
/*
17
void func(T) [with T = std::tuple<std::reference_wrapper<int>, std::reference_wrapper<float>, std::reference_wrapper<const double>, std::reference_wrapper<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >]
18
void func(T) [with T = std::tuple<int&, float&, const double&, const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&>]
19
*/

1
add_library(some_interface_lib INTERFACE)
2
target_include_directories(some_interface_lib INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
3
target_compile_definitions(some_interface_lib INTERFACE SOME_DEFINE=1)

1
add_executable(some_executable main.cpp)
2
target_link_libraries(some_executable PRIVATE some_interface_lib)
3

4
add_library(some_other_lib some_other_source.cpp)
5
target_link_libraries(some_other_lib PUBLIC some_interface_lib)

1
#include <iostream>
2
#include <iterator>
3

4
class fibonacci_iterator {
5
    long long a = 0, b = 1;
6

7
   public:
8
    using iterator_category = std::input_iterator_tag;
9
    using value_type = long long;
10
    using difference_type = std::ptrdiff_t;
11
    using pointer = const long long*;
12
    using reference = const long long&;
13

14
    fibonacci_iterator& operator++() {
15
        // 注意这里写的是前置自增
16
        long long temp = a;
17
        a = b;
18
        b += temp;
19
        return *this;
20
    }
21

22
    long long operator*() const { return a; }
23

24
    // Always true for infinite sequences
25
    bool operator!=(const fibonacci_iterator&) const { return true; }
26
};
27

28
int main() {
29
    auto it = fibonacci_iterator();
30
    for (int i = 0; i < 10; ++i, ++it) {  // 前置自增
31
        std::cout << *it << " ";
32
    }
33
}

1
#include <iostream>
2
#include <vector>
3
#include <iterator>
4
#include <algorithm>
5

6
template <typename Iter, typename Func>
7
class transform_iterator {
8
    Iter it;
9
    Func func;
10

11
   public:
12
    using iterator_category = std::input_iterator_tag;
13
    using value_type = typename std::result_of<Func(
14
        typename std::iterator_traits<Iter>::value_type)>::type;  // 萃取一下函数调用的返回类型
15
    using difference_type = std::ptrdiff_t;
16
    using pointer = value_type*;
17
    using reference = value_type;
18

19
    transform_iterator(Iter iter, Func f) : it(iter), func(f) {}
20

21
    transform_iterator& operator++() {
22
        // 还是，前置自增
23
        ++it;
24
        return *this;
25
    }
26
    reference operator*() const {
27
        // 注意 这重载的是解引用操作符。不是乘法。乘法是二元，解引用是一元。
28
        // 这里的目的是搭配一些STL库的算法。比如copy是解引用赋值。
29
        // 返回reference类型的原因是解引用操作符希望返回一个引用，这样才能被赋值。
30
        return func(*it);
31
    }
32
    bool operator!=(const transform_iterator& other) const { return it != other.it; }
33
};
34

35
int main() {
36
    std::vector<int> numbers = {1, 2, 3, 4, 5};
37
    std::vector<int> squares{};
38
    auto square = [](int x) { return x * x; };
39
    auto begin = transform_iterator(numbers.begin(), square);
40
    auto end = transform_iterator(numbers.end(), square);
41

42
    std::copy(begin, end,
43
              std::back_inserter(
44
                  squares));  // 用back inserter往里面插。因为一开始没初始化，所以直接给迭代器
45
    for (auto i : squares) {
46
        std::cout << i << std::endl;
47
    }
48
}

1
#include <iostream>
2
#include <vector>
3

4
class filtering_iterator {
5
    using vec_it = std::vector<int>::iterator;  // 简化实现。实际上应该使用模板参数
6
    vec_it current, end;
7
    int threshold;
8

9
   public:
10
    filtering_iterator(vec_it begin, vec_it end, int th) : current(begin), end(end), threshold(th) {
11
        advance();
12
    }
13

14
    filtering_iterator& operator++() {
15
        current = current == end ? end : current + 1;  // 如果是end就返回end,不然就+1
16
        advance();
17
        return *this;
18
    }
19

20
    int operator*() const { return *current; }
21

22
    bool operator!=(const filtering_iterator& other) const { return current != other.current; }
23

24
   private:
25
    void advance() {
26
        while (current != end && *current < threshold) {
27
            current = current + 1;  // 跳过小于阈值的元素
28
            // 这里用 != 而不是 <是因为只有随机迭代器支持关系性比较
29
            // 另外只能+1，不然迭代器失效就炸了。如果要+n的话需要再套一个while
30
        }
31
    }
32
};
33

34
int main() {
35
    std::vector<int> data = {1, 5, 2, 8, 3, 10, 4};
36
    int threshold = 9;
37

38
    std::cout << "Filtered values: ";
39
    for (filtering_iterator it(data.begin(), data.end(), threshold);
40
         it != filtering_iterator(data.end(), data.end(), threshold); ++it) {
41
        // 注意一点，我们用迭代器一般都是在for循环语句内现场创建，而不是在外面创建再传进去
42
        std::cout << *it << " ";
43
    }
44
}