int values[] = {1, 2, 3, 4, 5};

int a{10};
int b = {20};
double price{19.9};

int array1[5]{1, 2, 3, 4, 5};
int array2[5]{};  // 全部初始化为 0

std::vector<int> numbers{1, 2, 3, 4, 5};
std::map<std::string, int> scores{
    {"Alice", 90},
    {"Bob", 85}
};

int number{};          // 0
double ratio{};        // 0.0
int* pointer{};        // 空指针
bool finished{};       // false

int a = 3.14;   // 可以编译，但会丢失小数部分
// int b{3.14}; // 编译错误：窄化转换

double value = 1000.0;
// float f{value}; // 普通变量转换可能丢失精度

class Point
{
public:
    Point(int x, int y)
        : x_(x), y_(y)
    {
    }

private:
    int x_;
    int y_;
};

Point point{10, 20};

#include <initializer_list>
#include <vector>

class IntCollection
{
public:
    IntCollection(std::initializer_list<int> values)
        : data_(values)
    {
    }

private:
    std::vector<int> data_;
};

IntCollection collection{1, 2, 3, 4};

std::vector<int> a(5, 10); // 5 个元素，每个值为 10
std::vector<int> b{5, 10}; // 2 个元素：5 和 10

Widget object(); // 声明函数，不是创建对象
Widget object2{}; // 创建对象

void process(int);
void process(void*);

process(0); // 调用 process(int)

process(nullptr); // 调用 process(void*)

auto number = 10;        // int
auto price = 19.9;       // double
auto text = "hello";     // const char*
auto iterator = map.begin();

// auto value; // 错误：无法推导类型

const int value = 10;
const int& reference = value;

auto a = value;      // int
auto b = reference;  // int

auto& c = value;       // const int&
const auto& d = value; // const int&

int number = 10;
auto& alias = number;
alias = 20;

int values[3]{1, 2, 3};

auto pointer = values; // int*，数组发生退化
auto& array_ref = values; // int (&)[3]

auto result = calculate(); // 如果函数名不能说明类型和语义，阅读成本可能更高

int a = 10;
double b = 2.5;

decltype(a + b) result = 0; // double

int function();

decltype(function()) value = 0; // 推导返回类型，不调用 function

const int value = 10;
decltype(value) a = 20; // const int

int number = 10;

decltype(number) a = 20; // int
decltype((number)) b = number; // int&

template <class Left, class Right>
auto add(const Left& left, const Right& right)
    -> decltype(left + right)
{
    return left + right;
}

std::vector<int> numbers{1, 2, 3, 4, 5};

for (int value : numbers)
{
    std::cout << value << '\n';
}

for (auto value : numbers)
{
    value *= 2; // 不修改容器
}

for (auto& value : numbers)
{
    value *= 2;
}

for (const auto& item : items)
{
    std::cout << item.name() << '\n';
}

for (auto iterator = numbers.begin();
     iterator != numbers.end();
     ++iterator)
{
    auto value = *iterator;
}

// 危险：push_back 可能扩容，使范围 for 内部迭代器失效
for (int value : numbers)
{
    numbers.push_back(value);
}

class Base
{
public:
    virtual void print() const
    {
    }

    virtual ~Base() = default;
};

class Derived : public Base
{
public:
    void print() const override
    {
    }
};

class Wrong : public Base
{
public:
    // void print() override; // 缺少 const，不能重写
};

class Derived : public Base
{
public:
    void print() const final
    {
    }
};

class Utility final
{
};

// class Child : public Utility {}; // 错误

#include <memory>

std::unique_ptr<int> pointer(new int(10));

// auto copy = pointer; // 错误

auto other = std::move(pointer);

std::unique_ptr<int[]> array(new int[100]{});
array[0] = 10;

auto first = std::make_shared<std::string>("hello");
auto second = first;

std::cout << first.use_count() << '\n'; // 通常为 2

std::weak_ptr<std::string> observer = first;

if (auto locked = observer.lock())
{
    std::cout << *locked << '\n';
}

auto object = std::make_shared<MyType>(arg1, arg2);

#include <array>

std::array<int, 4> values{{1, 2, 3, 4}};

std::cout << values.size() << '\n';
std::cout << values.at(2) << '\n';

#include <forward_list>

std::forward_list<int> list{1, 2, 3};
list.push_front(0);

class Number
{
public:
    Number() = default;

    explicit Number(int value)
        : value_(value)
    {
    }

private:
    int value_{};
};

class Data
{
public:
    Data& operator=(const Data&);
};

Data& Data::operator=(const Data&) = default;

class NonCopyable
{
public:
    NonCopyable() = default;
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
};

void print(int value);
void print(double) = delete;

print(10);
// print(3.14); // 编译错误

const int value = 10;

int value = 10;

value;                 // lvalue
value + 1;             // prvalue
std::move(value);      // xvalue

int global = 0;

int& get_global()
{
    return global;
}

get_global() = 100;

int value = 10;
int& reference = value;

// int& wrong = 10; // 非 const 左值引用不能绑定纯右值

const int& first = value;
const int& second = 10;

int&& first = 10;
int&& second = value + 1;

// int&& wrong = value; // 不能直接绑定左值

void use(int&);
void use(int&&);

int&& reference = 10;
use(reference);            // 调用 int&
use(std::move(reference)); // 调用 int&&

class Buffer
{
public:
    explicit Buffer(std::size_t size)
        : data_(new int[size]{}),
          size_(size)
    {
    }

    ~Buffer()
    {
        delete[] data_;
    }

    Buffer(const Buffer& other)
        : data_(new int[other.size_]),
          size_(other.size_)
    {
        std::copy(other.data_,
                  other.data_ + other.size_,
                  data_);
    }

    Buffer(Buffer&& other) noexcept
        : data_(other.data_),
          size_(other.size_)
    {
        other.data_ = nullptr;
        other.size_ = 0;
    }

private:
    int* data_{};
    std::size_t size_{};
};

other.data_ = nullptr;

Buffer(Buffer&& other) noexcept;

Buffer& operator=(Buffer&& other) noexcept
{
    if (this != &other)
    {
        delete[] data_;

        data_ = other.data_;
        size_ = other.size_;

        other.data_ = nullptr;
        other.size_ = 0;
    }

    return *this;
}

Buffer(Buffer&&) noexcept;
Buffer& operator=(Buffer&&) noexcept;

Buffer make_buffer()
{
    Buffer value(1000);
    return value;
}

Buffer result = make_buffer();

std::string source = "hello";
std::string target = std::move(source);

const std::string text = "hello";
std::string copy = std::move(text); // 通常拷贝

std::string source = "hello";
std::string target = std::move(source);

source = "new value"; // 合法

send(std::move(message));

// 不要再假设 message 仍保存原文本

std::string make_text()
{
    std::string result = "hello";
    return result;
}

return std::move(result);

void process(int&)
{
    std::cout << "lvalue\n";
}

void process(int&&)
{
    std::cout << "rvalue\n";
}

template <class T>
void wrapper(T&& value)
{
    process(value);
}

template <class T>
void wrapper(T&& value);

void function(std::string&& value); // 普通右值引用

template <class T>
class Box
{
public:
    void set(T&& value); // T 是类模板参数，不在此处推导
};

template <class T>
void wrapper(T&& value)
{
    process(std::forward<T>(value));
}

#include <iostream>
#include <utility>

void process(int&)
{
    std::cout << "lvalue\n";
}

void process(const int&)
{
    std::cout << "const lvalue\n";
}

void process(int&&)
{
    std::cout << "rvalue\n";
}

template <class T>
void wrapper(T&& value)
{
    process(std::forward<T>(value));
}

int main()
{
    int a = 10;
    const int b = 20;

    wrapper(a);
    wrapper(b);
    wrapper(30);
}

template <class... Args>
void function(Args... args)
{
}

#include <iostream>

void print()
{
    std::cout << '\n';
}

template <class First, class... Rest>
void print(const First& first, const Rest&... rest)
{
    std::cout << first;

    if (sizeof...(rest) != 0)
    {
        std::cout << ' ';
    }

    print(rest...);
}

template <class Type, class... Args>
std::unique_ptr<Type> make_unique_cpp11(Args&&... args)
{
    return std::unique_ptr<Type>(
        new Type(std::forward<Args>(args)...));
}

struct Goods
{
    std::string name;
    double price;
};

struct CompareByPrice
{
    bool operator()(const Goods& left,
                    const Goods& right) const
    {
        return left.price < right.price;
    }
};

std::sort(goods.begin(),
          goods.end(),
          [](const Goods& left, const Goods& right)
          {
              return left.price < right.price;
          });

int value = 10;

auto snapshot = [value]
{
    return value;
};

value = 20;
std::cout << snapshot() << '\n'; // 10

int value = 10;

auto modify = [&value]
{
    value += 5;
};

modify();
std::cout << value << '\n'; // 15

int value = 10;

auto function = [value]() mutable
{
    value += 5;
    return value;
};

auto add = [](int left, int right)
{
    return left + right;
};

auto divide = [](double left, double right) -> double
{
    return left / right;
};

auto first = [] { return 1; };
auto second = [] { return 1; };

// first = second; // 类型不同

int (*function_pointer)(int) =
    [](int value) { return value * 2; };

class Counter
{
public:
    std::function<int()> make_reader()
    {
        return [this]
        {
            return value_;
        };
    }

private:
    int value_{42};
};

#include <functional>

std::function<int(int, int)> operation;

operation = [](int a, int b)
{
    return a + b;
};

std::cout << operation(2, 3) << '\n';

#include <functional>

int add(int a, int b)
{
    return a + b;
}

auto add_ten =
    std::bind(add, 10, std::placeholders::_1);

std::cout << add_ten(5) << '\n'; // 15

auto add_ten = [](int value)
{
    return add(10, value);
};

#include <iostream>
#include <thread>

void task(int id)
{
    std::cout << "worker " << id << '\n';
}

int main()
{
    std::thread worker(task, 1);
    worker.join();
}

class Worker
{
public:
    void run(int count)
    {
        for (int i = 0; i < count; ++i)
        {
        }
    }
};

Worker object;
std::thread thread(&Worker::run, &object, 10);
thread.join();

std::thread first(task, 1);
std::thread second = std::move(first);

std::thread worker(task, 1);

if (worker.joinable())
{
    worker.join();
}

void function()
{
    std::thread worker(task, 1);
    // 离开作用域前既没有 join，也没有 detach
}

class ThreadGuard
{
public:
    explicit ThreadGuard(std::thread& thread)
        : thread_(thread)
    {
    }

    ~ThreadGuard()
    {
        if (thread_.joinable())
        {
            thread_.join();
        }
    }

    ThreadGuard(const ThreadGuard&) = delete;
    ThreadGuard& operator=(const ThreadGuard&) = delete;

private:
    std::thread& thread_;
};

std::thread worker(task, 1);
worker.detach();

void increment_copy(int value)
{
    ++value;
}

int number = 10;
std::thread thread(increment_copy, number);
thread.join();

// number 仍然是 10

#include <functional>
#include <thread>

void increment(int& value)
{
    ++value;
}

int number = 10;
std::thread thread(increment, std::ref(number));
thread.join();

// number 变为 11

std::thread thread(read_data, std::cref(data));

std::thread create_dangerous_thread()
{
    int local = 10;
    return std::thread(increment, std::ref(local));
}

long long counter = 0;

void increment()
{
    for (int i = 0; i < 100000; ++i)
    {
        ++counter; // 多线程同时执行时存在数据竞争
    }
}

#include <atomic>

std::atomic<long long> counter{0};

void increment()
{
    for (int i = 0; i < 100000; ++i)
    {
        counter.fetch_add(1);
    }
}

std::cout << std::boolalpha
          << counter.is_lock_free()
          << '\n';

std::atomic<int> first{10};
std::atomic<int> second{0};

// std::atomic<int> third(first); // 错误
// second = first;                // 错误

second.store(first.load());
second = 20;

counter.fetch_add(1, std::memory_order_relaxed);

#include <mutex>

std::mutex mutex;
int number = 0;

void update()
{
    mutex.lock();
    ++number;
    mutex.unlock();
}

void update()
{
    std::lock_guard<std::mutex> lock(mutex);
    ++number;
}

void update_conditionally(bool should_update)
{
    std::unique_lock<std::mutex> lock(
        mutex, std::defer_lock);

    if (should_update)
    {
        lock.lock();
        ++number;
        lock.unlock();
    }
}

std::lock_guard<std::mutex> first(mutex,
                                  std::adopt_lock);

std::unique_lock<std::mutex> second(
    mutex, std::defer_lock);

std::unique_lock<std::mutex> third(
    mutex, std::try_to_lock);

std::lock(first_mutex, second_mutex);

std::lock_guard<std::mutex> first(
    first_mutex, std::adopt_lock);
std::lock_guard<std::mutex> second(
    second_mutex, std::adopt_lock);

Data local;

{
    std::lock_guard<std::mutex> lock(mutex);
    local = shared_data;
}

process(local); // 耗时工作放在锁外

while (queue.empty())
{
    // 不断检查，浪费 CPU
}

#include <condition_variable>
#include <mutex>
#include <queue>

std::mutex mutex;
std::condition_variable condition;
std::queue<int> tasks;
bool stopped = false;

int take_task()
{
    std::unique_lock<std::mutex> lock(mutex);

    condition.wait(lock, []
    {
        return !tasks.empty() || stopped;
    });

    if (tasks.empty())
    {
        return -1;
    }

    int task = tasks.front();
    tasks.pop();
    return task;
}

condition.wait(lock, predicate);

void add_task(int task)
{
    {
        std::lock_guard<std::mutex> lock(mutex);
        tasks.push(task);
    }

    condition.notify_one();
}

#include <future>

auto future = std::async(std::launch::async, []
{
    return 21 * 2;
});

std::cout << future.get() << '\n';

std::promise<int> promise;
std::future<int> future = promise.get_future();

std::thread worker(
    [](std::promise<int> result)
    {
        result.set_value(42);
    },
    std::move(promise));

std::cout << future.get() << '\n';
worker.join();

constexpr int square(int value)
{
    return value * value;
}

constexpr int result = square(5);

static_assert(sizeof(void*) >= 4,
              "pointer is unexpectedly small");

using StringMap =
    std::map<std::string, std::string>;

template <class T>
using Vector = std::vector<T>;

class User
{
public:
    User()
        : User("unknown", 0)
    {
    }

    User(std::string name, int age)
        : name_(std::move(name)),
          age_(age)
    {
    }

private:
    std::string name_;
    int age_;
};

enum class Color
{
    red,
    green,
    blue
};

Color color = Color::red;

#include <algorithm>
#include <atomic>
#include <cstddef>
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <thread>
#include <utility>
#include <vector>

class Task
{
public:
    Task(std::string name, int priority)
        : name_(std::move(name)),
          priority_(priority)
    {
    }

    virtual ~Task() = default;

    virtual void print() const
    {
        std::cout << name_
                  << ": "
                  << priority_
                  << '\n';
    }

    int priority() const
    {
        return priority_;
    }

private:
    std::string name_;
    int priority_;
};

class ImportantTask final : public Task
{
public:
    ImportantTask(std::string name, int priority)
        : Task(std::move(name), priority)
    {
    }

    void print() const override
    {
        std::cout << "[important] ";
        Task::print();
    }
};

static void accumulate_range(int first,
                             int last,
                             std::atomic<long long>& sum)
{
    long long local = 0;

    for (int value = first; value <= last; ++value)
    {
        local += value;
    }

    sum.fetch_add(local, std::memory_order_relaxed);
}

int main()
{
    std::vector<std::shared_ptr<Task>> tasks{
        std::make_shared<Task>("compile", 2),
        std::make_shared<ImportantTask>("deploy", 5),
        std::make_shared<Task>("test", 3)
    };

    std::sort(tasks.begin(),
              tasks.end(),
              [](const std::shared_ptr<Task>& left,
                 const std::shared_ptr<Task>& right)
              {
                  return left->priority() >
                         right->priority();
              });

    for (const auto& task : tasks)
    {
        task->print();
    }

    std::atomic<long long> sum{0};

    std::thread first(accumulate_range,
                      1,
                      50000,
                      std::ref(sum));
    std::thread second(accumulate_range,
                       50001,
                       100000,
                       std::ref(sum));

    first.join();
    second.join();

    std::cout << "sum = " << sum.load() << '\n';
    return 0;
}

std::vector<int> a(5, 10);
std::vector<int> b{5, 10};

for (auto item : large_objects)

for (const auto& item : large_objects)