website: update dependencies

book: revise preface (#197 )
book: revise release acquire semantics
2025-12-19 05:34:38 +03:00 · 2021-08-11 13:20:31 +02:00 · 2021-08-11 13:16:56 +02:00 · 2021-08-11 13:10:34 +02:00 · 2021-08-11 12:41:48 +02:00 · 2021-08-11 12:41:16 +02:00
65 changed files with 3696 additions and 3956 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1,12 @@
 # These are supported funding model platforms
 github: [changkun] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 patreon: # Replace with a single Patreon username
 open_collective: # Replace with a single Open Collective username
 ko_fi: # Replace with a single Ko-fi username
 tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 liberapay: # Replace with a single Liberapay username
 issuehunt: # Replace with a single IssueHunt username
 otechie: # Replace with a single Otechie username
 custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
--- a/.github/workflows/website.yml
+++ b/.github/workflows/website.yml
@@ -0,0 +1,29 @@
 name: Website
 on:
  push:
    branches: [ master ]
 jobs:
  build:
    name: Website
    runs-on: ubuntu-latest
    timeout-minutes: 60
    steps:
      - uses: actions/checkout@v2
      - name: build
        env:
          USER: ${{ secrets.SERVER_USER }}
          TARGET: ${{ secrets.SERVER_PATH }}
          KEY: ${{ secrets.SERVER_KEY }}
          DOMAIN: ${{ secrets.SERVER_DOMAIN }}
        run: |
          make build
          mkdir ~/.ssh
          echo "$KEY" | tr -d '\r' > ~/.ssh/id_ed25519
          chmod 400 ~/.ssh/id_ed25519
          eval "$(ssh-agent -s)"
          ssh-add ~/.ssh/id_ed25519
          ssh-keyscan -H $DOMAIN >> ~/.ssh/known_hosts
          scp -r website/public/modern-cpp/* $USER@$DOMAIN:$TARGET
--- a/.gitignore
+++ b/.gitignore
@@ -42,5 +42,4 @@ website/src/modern-cpp/exercises
 website/src/modern-cpp/code
 website/src/modern-cpp/assets/cover-2nd-en.png
 website/src/modern-cpp/assets/cover-2nd.png
 website/src/modern-cpp/assets/qq-group.png
 website/src/modern-cpp/assets/figures/*
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,18 +0,0 @@
 services:
  - docker
 before_install:
 - openssl aes-256-cbc -K $encrypted_9157553ce13c_key -iv $encrypted_9157553ce13c_iv -in .travis/travis.enc -out ~/.ssh/id_rsa -d
 - chmod 600 ~/.ssh/id_rsa
 - git config --global user.name "Changkun Ou"
 - git config --global user.email "hi@changkun.us"
 addons:
  ssh_known_hosts:
  - changkun.de
 script:
  - make build
 after_success:
  scp -r website/public/modern-cpp/* $encrypted_server_user@changkun.de:$encrypted_server_path
--- a/.travis/travis.enc
+++ b/.travis/travis.enc
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,32 +4,32 @@
 C++ 11/14/17 issue is used to track the principle description error, `typo` error, and the questions to the author of the book.
- Usually, you may encounter typos, semantic errors, grammatical errors, and etc. These are all `typo` errors. If an error has caused some obstacles to your reading and you strongly believe that the `typo` will also affect others reading. Then you are very welcome to [submit issue](https://github.com/changkun/modern-cpp-tutorial/issues) to report the `typo` error.
+- Usually, you may encounter typos, semantic errors, grammatical errors, and etc. These are all `typo` errors. If an error has caused some obstacles to your reading and you strongly believe that the `typo` will also affect others reading, then you are very welcome to [submit issue](https://github.com/changkun/modern-cpp-tutorial/issues) to report the `typo` error.
- Do not hasitate to submit a principle error because it prevent wrong knowledge being propagation.
+- Do not hesitate to submit a `principle` error because it will prevent wrong knowledge being spread.
-Report the error immediately by [submitting issue](https://github.com/changkun/modern-cpp-tutorial/issues) to avoid the spread of wrong knowledge.
+Report the error immediately by [submitting issue](https://github.com/changkun/modern-cpp-tutorial/issues) to avoid the propogation of wrong knowledge.
- If you found some part of the book is confusing, you are very welcome to [submit an issue](https://github.com/changkun/modern-cpp-tutorial/issues) for asking questions.
+- If you found some part of the book confusing, you are very welcome to [submit an issue](https://github.com/changkun/modern-cpp-tutorial/issues) for asking questions.
- The book cannot cover the entire C++ of course, however, you are very welcome to [submit an issue](https://github.com/changkun/modern-cpp-tutorial/issues) for a suggestion if you found some important feature is missing in the book.
+- The book cannot cover the entirety C++ of course, however, you are very welcome to [submit an issue](https://github.com/changkun/modern-cpp-tutorial/issues) with a suggestion if you find some important feature is missing in the book.
 ## Pull Request
-"C++ 11/14/17 On the Fly" is open source so that everyone can contribute to contribute to PR. However, it is required read the following instructions carefully before submitting your pull request:
+"C++ 11/14/17 On the Fly" is open source so that everyone can contribute to contribute via a PR. However, it is required to read the following instructions carefully before submitting your pull request:
 - Before you submit your pull request, make sure that the [issue list](https://github.com/changkun/modern-cpp-tutorial/issues) already contains the problem you want to solve. If not, please refer to the **Submit Issue** section.
- Make sure your PR has improved the `typo` error of more than 50 words, otherwise please do not submit a PR.
+- Make sure your PR has improved more than 50 `typo` errors, otherwise please do not submit a PR.
- For a PR that fixes principled errors, please don't hesitate, all readers of the book are very grateful for your contribution!
+- For a PR that fixes principled errors, please don't hesitate, all of the readers of the book are very grateful for your contribution!
 - If you would like to be a co-author of this book, please send an email to ask: `hi at changkun dot us`.
 Since this repository provides a variety of reading approaches, thus make sure you have checked all items in the following checklist:
 - [ ] If you only making changes to the main part of the book (i.e. the `book` folder), and no changes to the code snippet, then you are good to go;
- [ ] If you also change the code snippet in the main body of the book, then you need to synchronize the corresponding code snippet in the `code` folder;
+- [ ] If you also changed the code snippet in the main body of the book, then you need to synchronize the corresponding code snippet in the `code` folder;
- [ ] If you changes also involve the exercises, you also need to synchronize the contents of the `exercises` folder.
+- [ ] If your changes also involve the exercises, you also need to synchronize the contents of the `exercises` folder.
 # 如何参与贡献
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 MIT License
-Copyright (c) 2016 - 2019 Changkun Ou <hi@changkun.us>
+Copyright (c) 2016 - 2020 Changkun Ou <hi@changkun.de>
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/19
+++ b/19
@@ -1,22 +1,25 @@
-DOCKER_ENV=changkun/modern-cpp-tutorial:build-env
+NAME=modern-cpp-tutorial
 DOCKER_ENV=changkun/$(NAME):build-env
 TARGET = pdf epub
 LANGS = zh-cn en-us
-ALL_BUILDS = website pdf
+ALL_BUILDS = website $(TARGET)
 # dep
 all: $(ALL_BUILDS)
-pdf: $(LANGS)
+$(TARGET): $(LANGS)
-$(LANGS):
+	mkdir -p website/public/modern-cpp/$@/
-	cd pdf/$@ && make && make clean
+	for lang in $^ ; do \
-	mkdir -p website/public/modern-cpp/pdf
+		cd $@/$${lang} && make && make clean && cd ../..; \
-	mv pdf/$@/modern-cpp-tutorial.pdf website/public/modern-cpp/pdf/modern-cpp-tutorial-$@.pdf
+		mv $@/$${lang}/$(NAME).$@ website/public/modern-cpp/$@/$(NAME)-$${lang}.$@; \
 	done
 website:
 	cd website && make
 build:
-	docker run --rm -v `pwd`:/modern-cpp-tutorial -it $(DOCKER_ENV) make 
+	docker run --rm -v `pwd`:/$(NAME) $(DOCKER_ENV) make 
 # dev
--- a/README-zh-cn.md
+++ b/README-zh-cn.md
@@ -2,7 +2,7 @@
 # 现代 C++ 教程：高速上手 C++11/14/17/20
-[![](https://img.shields.io/badge/language-English-blue.svg?style=flat-square)](./README.md) [![](https://img.shields.io/badge/language-简体中文-red.svg?style=flat-square)](./README-zh-cn.md) [![](https://img.shields.io/badge/€-donate-ff69b4.svg?style=flat-square)](./assets/donate.md) [![](https://img.shields.io/badge/chat-community-667ed5.svg?style=flat-square)](./assets/community.md)
+![](https://img.shields.io/travis/changkun/modern-cpp-tutorial/master?style=flat-square) [![](https://img.shields.io/badge/language-English-blue.svg?style=flat-square)](./README.md) [![](https://img.shields.io/badge/language-简体中文-red.svg?style=flat-square)](./README-zh-cn.md) [![](https://img.shields.io/badge/€-donate-ff69b4.svg?style=flat-square)](./assets/donate.md)
 ## 本书目的
@@ -22,8 +22,9 @@
 你可以选择以下几种阅读方式：
 1. [GitHub 在线](./book/zh-cn/toc.md)
-2. [PDF 文档](https://changkun.de/modern-cpp/modern-cpp-tutorial-zh-cn.pdf)
+2. [PDF 文档](https://changkun.de/modern-cpp/pdf/modern-cpp-tutorial-zh-cn.pdf)
-3. [网站](https://changkun.de/modern-cpp/)
+3. [EPUB 文档](https://changkun.de/modern-cpp/epub/modern-cpp-tutorial-zh-cn.epub)
 4. [网站](https://changkun.de/modern-cpp/)
 ## 相关代码
@@ -49,6 +50,13 @@ $ make build
 笔者时间和水平有限，如果读者发现书中内容的错误，欢迎提 [Issue](https://github.com/changkun/modern-cpp-tutorial/issues)，或者直接提 [Pull request](https://github.com/changkun/modern-cpp-tutorial/pulls)。详细贡献指南请参考[如何参与贡献](CONTRIBUTING.md)，由衷感谢每一位指出本书中出现错误的读者，包括但不限于 [Contributors](https://github.com/changkun/modern-cpp-tutorial/graphs/contributors)。
 <p>本项目还由以下产品提供赞助支持：</p>
 <p>
  <a href="https://www.digitalocean.com/?refcode=834a3bbc951b&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=CopyPaste">
    <img src="https://opensource.nyc3.cdn.digitaloceanspaces.com/attribution/assets/SVG/DO_Logo_horizontal_blue.svg" width="201px">
  </a>
 </p>
 ## 许可
 <a rel="license" href="http://creativecommons.org/licenses/by-nc-nd/4.0/"><img alt="知识共享许可协议" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-nd/4.0/80x15.png" /></a>
--- a/README.md
+++ b/README.md
@@ -2,23 +2,22 @@
 # Modern C++ Tutorial: C++11/14/17/20 On the Fly
-[![](https://img.shields.io/badge/language-English-blue.svg?style=flat-square)](./README.md) [![](https://img.shields.io/badge/language-简体中文-red.svg?style=flat-square)](./README-zh-cn.md) [![](https://img.shields.io/badge/€-donate-ff69b4.svg?style=flat-square)](./assets/donate.md) [![](https://img.shields.io/badge/chat-community-667ed5.svg?style=flat-square)](./assets/community.md)
+![](https://img.shields.io/travis/changkun/modern-cpp-tutorial/master?style=flat-square) [![](https://img.shields.io/badge/language-English-blue.svg?style=flat-square)](./README.md) [![](https://img.shields.io/badge/language-简体中文-red.svg?style=flat-square)](./README-zh-cn.md) [![](https://img.shields.io/badge/€-donate-ff69b4.svg?style=flat-square)](./assets/donate.md)
 ## Purpose
-The book claims "On the Fly". Its intent is to provide a comprehensive introduction to the relevant features regarding modern C++ (before 2020s).
+The book claims to be "On the Fly". Its intent is to provide a comprehensive introduction to the relevant features regarding modern C++ (before 2020s).
 Readers can choose interesting content according to the following table of content to learn and quickly familiarize the new features you would like to learn.
-Readers should aware that all of these features are not required. It should be leart when you really need it.
+Readers should be aware that not all of these features are required. Instead, it should be learned when you really need it.
-At the same time, instead of grammar-only, the book introduces the historical background as simple as possible of its technical requirements, which provides great help in understanding why these features comes out.
+At the same time, instead of coding-only, the book introduces the historical background of its technical requirements (as simple as possible), which provides great help in understanding why these features came out.
-In addition, The author would like to encourage that readers should be able to use modern C++ directly in their new projects and  migrate their old projects to modern C++ gradually after read the book.
+In addition, the author would like to encourage readers to use modern C++ directly in their new projects and  migrate their old projects to modern C++ gradually after reading the book.
 ## Targets
- This book assumes that readers are already familiar with traditional C++ (i.e. C++98 or earlier), at least they do not have any difficulty in reading traditional C++ code. In other words, those who have long experience in traditional C++ and people who desire to quickly understand the features of modern C++ in a short period of time are well suited to read the book;
+- This book assumes that readers are already familiar with traditional C++ (i.e. C++98 or earlier), or at least that they do not have any difficulty in reading traditional C++ code. In other words, those who have long experience in traditional C++ and people who desire to quickly understand the features of modern C++ in a short period of time are well suited to read the book.
- This book introduces to a certain extent of the dark magic of modern C++. However, these magics are very limited, they are not suitable for readers who want to learn advanced C++. The purpose of this book is offering a quick start for modern C++. Of course, advanced readers can also use this book to review and examine themselves on modern C++.
+- This book introduces, to a certain extent, the dark magic of modern C++. However, these magic tricks are very limited, they are not suitable for readers who want to learn advanced C++. The purpose of this book is offering a quick start for modern C++. Of course, advanced readers can also use this book to review and examine themselves on modern C++.
 ## Start
@@ -26,23 +25,24 @@ You can choose from the following reading methods:
 - [GitHub Online](./book/en-us/toc.md)
 - [PDF document](https://changkun.de/modern-cpp/pdf/modern-cpp-tutorial-en-us.pdf)
 - [EPUB document](https://changkun.de/modern-cpp/epub/modern-cpp-tutorial-en-us.epub)
 - [Website](https://changkun.de/modern-cpp)
 ## Code
-Each chapter of this book has a lot of code. If you encounter problems when writing your own code with the introductory features of the book, you might as well read the source code attached to the book. You can find the book [here](./code). All the code organized by chapter, the folder name is the chapter number.
+Each chapter of this book contains a lot of code. If you encounter problems while writing your own code with the introductory features of the book, reading the source code attached to the book might be of help. You can find the book [here](./code). All the code is organized by chapter, the folder name is the chapter number.
 ## Exercises
-There are few exercises At the end of each chapter of the book. It is for testing whether you can use the knowledge points in the current chapter. You can find the possible answer to the problem from [here](./exercises). The folder name is the chapter number.
+There are few exercises at the end of each chapter of the book. These are meant to test whether you have mastered the knowledge in the current chapter. You can find the possible answer to the problem [here](./exercises). Again, the folder name is the chapter number.
 ## Website
-The source code of the [website](https://changkun.de/modern-cpp) of this book can be found [here](./website), which is built by [hexo](https://hexo.io) and [vuejs](https://vuejs.org). The website provides you another way of reading the book, it is also adapts to mobile.
+The source code of the [website](https://changkun.de/modern-cpp) of this book can be found [here](./website), which is built by [hexo](https://hexo.io) and [vuejs](https://vuejs.org). The website provides you another way of reading the book, it also adapts to mobile browsers.
 ## Build
-If you are interested in build everything locally, it is recommended using [Docker](https://docs.docker.com/install/). To build, simply run:
+If you are interested in building everything locally, it is recommended using [Docker](https://docs.docker.com/install/). To build, simply run:
 ```bash
 $ make build
@@ -52,9 +52,16 @@ $ make build
 This book was originally written in Chinese by [Changkun Ou](https://changkun.de).
-The author has limited time and language skills. If readers find any mistakes of the book or any language improvements, please feel free to open an [Issue](https://github.com/changkun/modern-cpp-tutorial/issues) or start a [Pull request](https://github.com/changkun/modern-cpp-tutorial/pulls). For detailed guidelines and checklist, please refer to [How to contribute](CONTRIBUTING.md).
+The author has limited time and language skills. If readers find any mistakes in the book or any language improvements, please feel free to open an [Issue](https://github.com/changkun/modern-cpp-tutorial/issues) or start a [Pull request](https://github.com/changkun/modern-cpp-tutorial/pulls). For detailed guidelines and checklist, please refer to [How to contribute](CONTRIBUTING.md).
-The author would be grateful to all contributors, including but not limited to [Contributors](https://github.com/changkun/modern-cpp-tutorial/graphs/contributors).
+The author is grateful to all contributors, including but not limited to [Contributors](https://github.com/changkun/modern-cpp-tutorial/graphs/contributors).
 <p>This project is also supported by:</p>
 <p>
  <a href="https://www.digitalocean.com/?refcode=834a3bbc951b&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=CopyPaste">
    <img src="https://opensource.nyc3.cdn.digitaloceanspaces.com/attribution/assets/SVG/DO_Logo_horizontal_blue.svg" width="201px">
  </a>
 </p>
 ## Licenses
--- a/assets/community.md
+++ b/assets/community.md
@@ -1,19 +0,0 @@
 ---
 title: 社区
 type: about
 order: 2
 ---
 ## Community
 The book offers a telegram chat group, feel free to join if you are interested:
 [![](https://img.shields.io/badge/chat-telegram-blue.svg?style=popout-square&logo=telegram)](https://t.me/joinchat/FEeulBM5OVYzuDI4phQ9Mg)
 ## 交流
 本书有以下读者 QQ 交流群，有兴趣的读者可以加入，加群需正确回答加群密码：
 ![](../assets/qq-group.png)
 > 提示: `bW9kZXJuLWNwcC10dXRvcmlhbC1naXRodWI=`
--- a/assets/cover-2nd-en-logo.png
+++ b/assets/cover-2nd-en-logo.png
--- a/assets/cover-2nd-logo.png
+++ b/assets/cover-2nd-logo.png
--- a/assets/figures/pointers1_en.png
+++ b/assets/figures/pointers1_en.png
--- a/assets/qq-group.png
+++ b/assets/qq-group.png
--- a/book/en-us/00-preface.md
+++ b/book/en-us/00-preface.md
@@ -10,36 +10,36 @@ order: 0
 ## Introduction
-C++ user group is a fairly large. From the advent of C++98 to the official finalization of C++11, it has accumulated over a decade. C++14/17 is an important complement and optimization for C++11, and C++20 brings this language to the door of modernization. The extended features of all these new standards are given to the C++ language. Infused with new vitality.
+The C++ programming language owns a fairly large user group. From the advent of C++98 to the official finalization of C++11, it has continued to stay relevant. C++14/17 is an important complement and optimization for C++11, and C++20 brings this language to the door of modernization. The extended features of all these new standards are integrated into the C++ language and infuse it with new vitality.
-C++ programmers, who are still using **traditional C++** (this book refers to C++98 and its previous C++ standards as traditional C++), may even amzed by the fact that they are not using the same language while reading modern C++ code.
+C++ programmers who are still using **traditional C++** (this book refers to C++98 and its previous standards as traditional C++) may even amazed by the fact that they are not using the same language while reading modern C++ code.
-**Modern C++** (this book refers to C++11/14/17/20) introduces a lot of features into traditional C++, which makes the whole C++ become language that modernized. Modern C++ not only enhances the usability of the C++ language itself, but the modification of the `auto` keyword semantics gives us more confidence in manipulating extremely complex template types. At the same time, a lot of enhancements have been made to the language runtime. The emergence of Lambda expressions has made C++ have the "closure" feature of "anonymous functions", which is almost in modern programming languages (such as Python/Swift/.. It has become commonplace, and the emergence of rvalue references has solved the problem of temporary object efficiency that C++ has long been criticized.
+**Modern C++** (this book refers to C++11/14/17/20) introduces many features into traditional C++ which bring the entire language to a new level of modernization. Modern C++ not only enhances the usability of the C++ language itself, but the modification of the `auto` keyword semantics gives us more confidence in manipulating extremely complex template types. At the same time, a lot of enhancements have been made to the language runtime. The emergence of Lambda expressions has given C++ the "closure" feature of "anonymous functions", which are  in almost all modern programming languages (such as Python, Swift, etc). It has become commonplace, and the emergence of rvalue references has solved the problem of temporary object efficiency that C++ has long been criticized for.
 C++17 is the direction that has been promoted by the C++ community in the past three years. It also points out an important development direction of **modern C++** programming. Although it does not appear as much as C++11, it contains a large number of small and beautiful languages and features (such as structured binding), and the appearance of these features once again corrects our programming paradigm in C++.
-Modern C++ also adds a lot of tools and methods to its own standard library, such as `std::thread` at the level of the language itself, which supports concurrent programming and no longer depends on the underlying system on different platforms. The API implements cross-platform support at the language level; `std::regex` provides full regular expression support and more. C++98 has been proven to be a very successful "paradigm", and the emergence of modern C++ further promotes this paradigm, making C++ a better language for system programming and library development. Concepts provide verification on the compile-time of template parameters, further enhancing the usability of the language.
+Modern C++ also adds a lot of tools and methods to its standard library such as `std::thread` at the level of the language itself, which supports concurrent programming and no longer depends on the underlying system on different platforms. The API implements cross-platform support at the language level; `std::regex` provides full regular expression support and more. C++98 has been proven to be a very successful "paradigm", and the emergence of modern C++ further promotes this paradigm, making C++ a better language for system programming and library development. Concepts verify the compile-time of template parameters, further enhancing the usability of the language.
 In conclusion, as an advocate and practitioner of C++, we always maintain an open mind to accept new things, and we can promote the development of C++ faster, making this old and novel language more vibrant.
 ## Targets
- This book assumes that readers are already familiar with traditional C++ (i.e. C++98 or earlier), at least they do not have any difficulty in reading traditional C++ code. In other words, those who have long experience in traditional C++ and people who desire to quickly understand the features of modern C++ in a short period of time are well suited to read the book;
+- This book assumes that readers are already familiar with traditional C++ (i.e. C++98 or earlier), at least they do not have any difficulty in reading traditional C++ code. In other words, those who have long experience in traditional C++ and people who desire to quickly understand the features of modern C++ in a short period are well suited to read the book;
- This book introduces to a certain extent of the dark magic of modern C++. However, these magics are very limited, they are not suitable for readers who want to learn advanced C++. The purpose of this book is offering a quick start for modern C++. Of course, advanced readers can also use this book to review and examine themselves on modern C++.
+- This book introduces to a certain extent of the dark magic of modern C++. However, these magics are very limited, they are not suitable for readers who want to learn advanced C++. The purpose of this book is to offer a quick start for modern C++. Of course, advanced readers can also use this book to review and examine themselves on modern C++.
 ## Purpose
-The book claims "On the Fly". Its intent is to provide a comprehensive introduction to the relevant features regarding modern C++ (before 2020s).
+The book claims "On the Fly". It intends to provide a comprehensive introduction to the relevant features regarding modern C++ (before the 2020s).
-Readers can choose interesting content according to the following table of content to learn and quickly familiarize the new features you would like to learn.
+Readers can choose interesting content according to the following table of contents to learn and quickly familiarize themselves with the new features that are available.
-Readers should aware that all of these features are not required. It should be leart when you really need it.
+Readers should aware that all of these features are not required. It should be learned when you need it.
-At the same time, instead of grammar-only, the book introduces the historical background as simple as possible of its technical requirements, which provides great help in understanding why these features comes out.
+At the same time, instead of grammar-only, the book introduces the historical background as simple as possible of its technical requirements, which provides great help in understanding why these features come out.
-In addition, The author would like to encourage that readers should be able to use modern C++ directly in their new projects and  migrate their old projects to modern C++ gradually after read the book.
+Also, the author would like to encourage that readers should be able to use modern C++ directly in their new projects and migrate their old projects to modern C++ gradually after reading the book.
 ## Code
-Each chapter of this book has a lot of code. If you encounter problems when writing your own code with the introductory features of the book, you might as well read the source code attached to the book. You can find the book [here](../../code). All the code organized by chapter, the folder name is the chapter number.
+Each chapter of this book has a lot of code. If you encounter problems when writing your own code with the introductory features of the book, you might as well read the source code attached to the book. You can find the book [here](../../code). All the code is organized by chapter, the folder name is the chapter number.
 ## Exercises
--- a/book/en-us/01-intro.md
+++ b/book/en-us/01-intro.md
@@ -21,11 +21,12 @@ InstalledDir: /Library/Developer/CommandLineTools/usr/bin
 ## 1.1 Deprecated Features
-Before learning modern C++, let's take a look at the main features that have been deprecated since C++11:
+Before learning modern C++, let's take a look at the main features that have deprecated since C++11:
-> **Note**: Deprecation is not completely unusable, it is only intended to imply that programmers will disappear from future standards and should be avoided. However, the deprecated features are still part of the standard library, and most of the features are actually "permanently" reserved for compatibility reasons.
+> **Note**: Deprecation is not completely unusable, it is only intended to imply that features will disappear from future standards and should be avoided. But, the deprecated features are still part of the standard library, and most of the features are actually "permanently" reserved for compatibility reasons.
 - **The string literal constant is no longer allowed to be assigned to a `char *`. If you need to assign and initialize a `char *` with a string literal constant, you should use `const char *` or `auto`.**
  ```cpp
  char *str = "hello world!"; // A deprecation warning will appear
  ```
@@ -46,15 +47,15 @@ Before learning modern C++, let's take a look at the main features that have bee
 - ... and many more
-There are also other features such as parameter binding (C++11 provides `std::bind` and `std::function`), `export`, and etc. are also deprecated. These features mentioned above **If you have never used or heard of it, please don't try to understand them. You should move closer to the new standard and learn new features directly**. After all, technology is moving forward.
+There are also other features such as parameter binding (C++11 provides `std::bind` and `std::function`), `export` etc. are also deprecated. These features mentioned above **If you have never used or heard of it, please don't try to understand them. You should move closer to the new standard and learn new features directly**. After all, technology is moving forward.
 ## 1.2 Compatibilities with C
-For some force majeure and historical reasons, we had to use some C code (even old C code) in C++, for example, Linux system calls. Before the advent of modern C++, most people talked about "what is the difference between C and C++". Generally speaking, in addition to answering the object-oriented class features and the template features of generic programming, there is no other opinion, or even a direct answer. "Almost" is also a lot of people. The Wayne diagram in Figure 1.2 roughly answers the C and C++ related compatibility.
+For some force majeure and historical reasons, we had to use some C code (even old C code) in C++, for example, Linux system calls. Before the advent of modern C++, most people talked about "what is the difference between C and C++". Generally speaking, in addition to answering the object-oriented class features and the template features of generic programming, there is no other opinion or even a direct answer. "Almost" is also a lot of people. The Venn diagram in Figure 1.2 roughly answers the C and C++ related compatibility.
 ![Figure 1.2: Compatabilities between ISO C and ISO C++](../../assets/figures/comparison.png)
-From now on, you should have the idea that "C++ is **not** a superset of C" in your mind (and not from the beginning, later [References for further reading] (# further reading references) The difference between C++98 and C99 is given). When writing C++, you should also avoid using program styles such as `void*` whenever possible. When you have to use C, you should pay attention to the use of `extern "C"`, separate the C language code from the C++ code, and then unify the link, for instance:
+From now on, you should have the idea that "C++ is **not** a superset of C" in your mind (and not from the beginning, later [References for further reading](#further-readings) The difference between C++98 and C99 is given). When writing C++, you should also avoid using program styles such as `void*` whenever possible. When you have to use C, you should pay attention to the use of `extern "C"`, separate the C language code from the C++ code, and then unify the link, for instance:
 ```cpp
 // foo.h
@@ -92,7 +93,7 @@ You should first compile the C code with `gcc`:
 gcc -c foo.c
 ```
-Comple and output the `foo.o` file, and link the C++ code to the `.o` file using `clang++` (or both compile to `.o` and then unlink them together):
+Compile and output the `foo.o` file, and link the C++ code to the `.o` file using `clang++` (or both compile to `.o` and then link them together):
 ```bash
 clang++ 1.1.cpp foo.o -std=c++2a -o 1.1
@@ -115,11 +116,12 @@ LDFLAGS_COMMON = -std=c++2a
 all:
 	$(C) -c $(SOURCE_C)
 	$(CXX) $(SOURCE_CXX) $(OBJECTS_C) $(LDFLAGS_COMMON) -o $(TARGET)
 clean:
 	rm -rf *.o $(TARGET)
 ```
-> Note: Indentation in `Makefile` is a tab instead of a space character. If you copy this code directly into your editor, the tab may be automatically replaced. Please ensure the indentation in the `Makefile`. It is done by tabs.
+> **Note**: Indentation in `Makefile` is a tab instead of a space character. If you copy this code directly into your editor, the tab may be automatically replaced. Please ensure the indentation in the `Makefile` is done by tabs.
 >
 > If you don't know the use of `Makefile`, it doesn't matter. In this tutorial, you won't build code that is written too complicated. You can also read this book by simply using `clang++ -std=c++2a` on the command line.
@@ -138,7 +140,7 @@ Don't worry at the moment, we will come to meet them in our later chapters.
 ## Further Readings
 - [A Tour of C++ (2nd Edition) Bjarne Stroustrup](https://www.amazon.com/dp/0134997832/ref=cm_sw_em_r_mt_dp_U_GogjDbHE2H53B)
- [C++ History](http://en.cppreference.com/w/cpp/language/history)
+  [History of C++](http://en.cppreference.com/w/cpp/language/history)
 - [C++ compiler support](https://en.cppreference.com/w/cpp/compiler_support)
 - [Incompatibilities Between ISO C and ISO C++](http://david.tribble.com/text/cdiffs.htm#C99-vs-CPP98)
--- a/book/en-us/02-usability.md
+++ b/book/en-us/02-usability.md
@@ -61,7 +61,7 @@ int main() {
        std::cout << "NULL == nullptr" << std::endl;
    foo(0);          // will call foo(int)
-    // foo(NULL);    // doen't compile
+    // foo(NULL);    // doesn't compile
    foo(nullptr);    // will call foo(char*)
    return 0;
 }
@@ -87,18 +87,16 @@ So, develop the habit of using `nullptr` directly.
 In addition, in the above code, we used `decltype` and
 `std::is_same` which are modern C++ syntax.
 In simple terms, `decltype` is used for type derivation,
-and `std::is_same` is used. 
+and `std::is_same` is used to compare the equality of the two types.
-To compare the equality of the two types, 
+We will discuss them in detail later in the [decltype](#decltype) section.
 we will discuss them in detail later in the [decltype](#decltype) section.
 ### constexpr
-C++ itself already has the concept of constant expressions, 
+C++ itself already has the concept of constant expressions, such as 1+2,
-such as 1+2, 3*4. Such expressions always produce the same result 
+3\*4. Such expressions always produce the same result without any side effects.
-without any side effects. If the compiler can directly optimize 
+If the compiler can directly optimize and embed these expressions into the program at
-and embed these expressions into the program at compile time, 
+compile-time, it will increase the performance of the program. A very obvious example
-it will increase the performance of the program. 
+is in the definition phase of an array:
 A very obvious example is in the definition phase of an array:
 ```cpp
 #include <iostream>
@@ -143,19 +141,19 @@ In the above example, `char arr_4[len_2]` may be confusing because `len_2` has b
 Why is `char arr_4[len_2]` still illegal?
 This is because the length of the array in the C++ standard must be a constant expression,
 and for `len_2`, this is a `const` constant, not a constant expression,
-so even if this behavior is in most compilers Both support, but) it is an illegal behavior, 
+so even if this behavior is supported by most compilers, but it is an illegal behavior,
 we need to use the `constexpr` feature introduced in C++11, which will be introduced next,
 to solve this problem; for `arr_5`, before C++98 The compiler cannot know that `len_foo()`
 actually returns a constant at runtime, which causes illegal production.
-> Note that most compilers now have their own compiler optimizations. 
+> Note that most compilers now have their compiler optimizations.
 > Many illegal behaviors become legal under the compiler's optimization.
 > If you need to reproduce the error, you need to use the old version of the compiler.
 C++11 provides `constexpr` to let the user explicitly declare that the function or
 object constructor will become a constant expression at compile time.
 This keyword explicitly tells the compiler that it should verify that `len_foo`
-should be a compile time. Constant expression.
+should be a compile-time constant expression. Constant expression.
 In addition, the function of `constexpr` can use recursion:
@@ -204,7 +202,7 @@ E.g:
 int main() {
    std::vector<int> vec = {1, 2, 3, 4};
-    // after c++17, can be simplefied by using `auto`
+    // since c++17, can be simplified by using `auto`
    const std::vector<int>::iterator itr = std::find(vec.begin(), vec.end(), 2);
    if (itr != vec.end()) {
        *itr = 3;
@@ -215,15 +213,15 @@ int main() {
        *itr = 4;
    }
-    // should output: 1, 4, 3, 4. can be simplefied using `auto`
+    // should output: 1, 4, 3, 4. can be simplified using `auto`
    for (std::vector<int>::iterator element = vec.begin(); element != vec.end(); ++element)
        std::cout << *element << std::endl;
 }
 ```
 In the above code, we can see that the `itr` variable is defined in the scope of
-the entire `main()`, which causes us to rename the other when we need to traverse 
+the entire `main()`, which causes us to rename the other when a variable need to traverse
-the entire `std::vectors` again. A variable. C++17 eliminates this limitation so that 
+the entire `std::vectors` again. C++17 eliminates this limitation so that
 we can do this in if(or switch):
 ```cpp
@@ -241,7 +239,7 @@ Initialization is a very important language feature,
 the most common one is when the object is initialized.
 In traditional C++, different objects have different initialization methods,
 such as ordinary arrays, PODs (**P**lain **O**ld **D**ata,
-ie classes without constructs, destructors, and virtual functions) 
+i.e. classes without constructs, destructors, and virtual functions)
 Or struct type can be initialized with `{}`,
 which is what we call the initialization list.
 For the initialization of the class object,
@@ -280,12 +278,13 @@ To solve this problem,
 C++11 first binds the concept of the initialization list to the type
 and calls it `std::initializer_list`,
 allowing the constructor or other function to use the initialization list
-like a parameter, which is The initialization of class objects provides 
+like a parameter, which is the initialization of class objects provides
 a unified bridge between normal arrays and POD initialization methods,
 such as:
 ```cpp
 #include <initializer_list>
 #include <vector>
 class MagicFoo {
 public:
    std::vector<int> vec;
@@ -313,7 +312,8 @@ be used as a formal parameter of a normal function, for example:
 ```Cpp
 public:
    void foo(std::initializer_list<int> list) {
-            for (std::initializer_list<int>::iterator it = list.begin(); it != list.end(); ++it) vec.push_back(*it);
+        for (std::initializer_list<int>::iterator it = list.begin();
            it != list.end(); ++it) vec.push_back(*it);
    }
 magicFoo.foo({6,7,8,9});
@@ -332,7 +332,7 @@ provided in other languages. In the chapter on containers,
 we will learn that C++11 has added a `std::tuple` container for
 constructing a tuple that encloses multiple return values. But the flaw
 is that C++11/14 does not provide a simple way to get and define
-the elements in the tuple directly from the tuple, 
+the elements in the tuple from the tuple,
 although we can unpack the tuple using `std::tie`
 But we still have to be very clear about how many objects this tuple contains,
 what type of each object is, very troublesome.
@@ -342,6 +342,7 @@ and the structured bindings let us write code like this:
 ```cpp
 #include <iostream>
 #include <tuple>
 std::tuple<int, double, std::string> f() {
    return std::make_tuple(1, 2.3, "456");
@@ -359,7 +360,7 @@ The `auto` type derivation is described in the
 ## 2.3 Type inference
-In traditional C and C++, the types of parameters must be clearly defined, which does not help us to quickly encode, especially when we are faced with a large number of complex template types, we must clearly indicate the type of variables in order to proceed. Subsequent coding, which not only slows down our development efficiency, but also makes the code stinking and long.
+In traditional C and C++, the types of parameters must be clearly defined, which does not help us to quickly encode, especially when we are faced with a large number of complex template types, we must indicate the type of variables to proceed. Subsequent coding, which not only slows down our development efficiency but also makes the code stinking and long.
 C++11 introduces the two keywords `auto` and `decltype` to implement type derivation, letting the compiler worry about the type of the variable. This makes C++ the same as other modern programming languages, in a way that provides the habit of not having to worry about variable types.
@@ -411,31 +412,32 @@ auto i = 5;              // i as int
 auto arr = new auto(10); // arr as int *
 ```
-> **Note**: `auto` cannot be used for function arguments, so the following 
+Since C++ 20, `auto` can even be used as function arguments. Consider
-> is not possible to compile (considering overloading, 
+the following example:
-> we should use templates):
+
-> ```cpp
+```cpp
-> int add(auto x, auto y);
+int add(auto x, auto y) {
->
+    return x+y;
-> 2.6.auto.cpp:16:9: error: 'auto' not allowed in function prototype
+}
-> int add(auto x, auto y) {
+
->         ^~~~
+auto i = 5; // type int
-> ```
+auto j = 6; // type int
->
+std::cout << add(i, j) << std::endl;
-> In addition, `auto` cannot be used to derive array types:
+```
 > **Note**: `auto` cannot be used to derive array types yet:
 >
 > ```cpp
-> auto auto_arr2[10] = arr;   // illegal, can't infer array type
+> auto auto_arr2[10] = {arr};   // illegal, can't infer array type
 >
 > 2.6.auto.cpp:30:19: error: 'auto_arr2' declared as array of 'auto'
->     auto auto_arr2[10] = arr;
+>     auto auto_arr2[10] = {arr};
 > ```
 ### decltype
 The `decltype` keyword is used to solve the defect that the auto keyword
-can only type the variable. Its usage is very similar to `sizeof`:
+can only type the variable. Its usage is very similar to `typeof`:
 ```cpp
 decltype(expression)
@@ -484,9 +486,9 @@ R add(T x, U y) {
 > Note: There is no difference between typename and class in the template parameter list. Before the keyword typename appears, class is used to define the template parameters. However, when defining a variable with [nested dependency type](http://en.cppreference.com/w/cpp/language/dependent_name#The_typename_disambiguator_for_dependent_names) in the template, you need to use typename to eliminate ambiguity.
-Such code is actually very ugly, because the programmer must explicitly 
+Such code is very ugly because the programmer must explicitly
 indicate the return type when using this template function.
-But in fact we don't know what kind of operation 
+But in fact, we don't know what kind of operation
 the `add()` function will do, and what kind of return type to get.
 This problem was solved in C++11. Although you may immediately
@@ -582,7 +584,7 @@ decltype(auto) look_up_a_string_2() {
 ### if constexpr
-As we saw at the beginning of this chapter, we know that C++11 introduces the `constexpr` keyword, which compiles expressions or functions into constant results. A natural idea is that if we introduce this feature into the conditional judgment, let the code complete the branch judgment at compile time, can it make the program more efficient? C++17 introduces the `constexpr` keyword into the `if` statement, allowing you to declare the condition of a constant expression in your code. Consider the following code:
+As we saw at the beginning of this chapter, we know that C++11 introduces the `constexpr` keyword, which compiles expressions or functions into constant results. A natural idea is that if we introduce this feature into the conditional judgment, let the code complete the branch judgment at compile-time, can it make the program more efficient? C++17 introduces the `constexpr` keyword into the `if` statement, allowing you to declare the condition of a constant expression in your code. Consider the following code:
 ```cpp
 #include <iostream>
@@ -618,7 +620,7 @@ int main() {
 ### Range-based for loop
-Finally, C++11 introduces a range-based iterative method, and we have the ability to write loops that are as concise 
+Finally, C++11 introduces a range-based iterative method, and we can write loops that are as concise
 as Python, and we can further simplify the previous example:
 ```cpp
@@ -641,7 +643,7 @@ int main() {
 ## 2.5 Templates
-C++ templates have always been a special art of the language, and templates can even be used independently as a new language. The philosophy of the template is to throw all the problems that can be processed at compile time into the compile time, and only deal with those core dynamic services at runtime, so as to greatly optimize the performance of the runtime. Therefore, templates are also regarded by many as one of the black magic of C++.
+C++ templates have always been a special art of the language, and templates can even be used independently as a new language. The philosophy of the template is to throw all the problems that can be processed at compile time into the compile time, and only deal with those core dynamic services at runtime, to greatly optimize the performance of the runtime. Therefore, templates are also regarded by many as one of the black magic of C++.
 ### Extern templates
@@ -696,7 +698,7 @@ typedef MagicType<std::vector<T>, std::string> FakeDarkMagic;
 C++11 uses `using` to introduce the following form of writing, and at the same time supports the same effect as the traditional `typedef`:
-> Usually we use `typedef` to define the alias syntax: `typedef original name new name; `, but the definition syntax for aliases such as function pointers is different, which usually causes a certain degree of difficulty for direct reading.
+> Usually, we use `typedef` to define the alias syntax: `typedef original name new name; `, but the definition syntax for aliases such as function pointers is different, which usually causes a certain degree of difficulty for direct reading.
 ```cpp
 typedef int (*process)(void *);
@@ -709,28 +711,6 @@ int main() {
 }
 ```
 ### Default template parameters
 We may have defined an addition function:
 ```cpp
 template<typename T, typename U>
 auto add(T x, U y) -> decltype(x+y) {
    return x+y;
 }
 ```
 However, when used, it is found that to use add, you must specify the type of its template parameters each time.
 A convenience is provided in C++11 to specify the default parameters of the template:
 ```cpp
 template<typename T = int, typename U = int>
 auto add(T x, U y) -> decltype(x+y) {
    return x+y;
 }
 ```
 ### Variadic templates
 The template has always been one of C++'s unique **Black Magic**.
@@ -745,7 +725,7 @@ and there is no need to fix the number of parameters when defining.
 template<typename... Ts> class Magic;
 ```
-The template class Magic object can accept unrestricted number of typename as 
+The template class Magic object can accept an unrestricted number of typename as
 a formal parameter of the template, such as the following definition:
 ```cpp
@@ -776,6 +756,7 @@ how to unpack the parameters?
 First, we can use `sizeof...` to calculate the number of arguments:
 ```cpp
 #include <iostream>
 template<typename... Ts>
 void magic(Ts... args) {
    std::cout << sizeof...(args) << std::endl;
@@ -797,7 +778,6 @@ the parameter package, but there are two classic processing methods:
 Recursion is a very easy way to think of and the most classic approach. This method continually recursively passes template parameters to the function, thereby achieving the purpose of recursively traversing all template parameters:
 ```cpp
 #include <iostream>
 template<typename T0>
@@ -831,7 +811,7 @@ void printf2(T0 t0, T... t) {
 **3. Initialize list expansion**
-Recursive template functions are a standard practice, but the obvious drawback is that you must define a function that terminates recursion.
+Recursive template functions are standard practice, but the obvious drawback is that you must define a function that terminates recursion.
 Here is a description of the black magic that is expanded using the initialization list:
@@ -878,7 +858,7 @@ template <typename T, typename U>
 The parameters of the template `T` and `U` are specific types.
 But there is also a common form of template parameter that allows different literals
-to be template parameters, ie non-type template parameters:
+to be template parameters, i.e. non-type template parameters:
 ```cpp
 template <typename T, int BufSize>
@@ -894,7 +874,7 @@ buffer_t<int, 100> buf; // 100 as template parameter
 ```
 In this form of template parameters, we can pass `100` as a parameter to the template.
-After C++11 introduced the feature of type derivation, we will naturally ask, since the template parameters here
+After C++11 introduced the feature of type derivation, we will naturally ask, since the template parameters here.
 Passing with a specific literal, can the compiler assist us in type derivation,
 By using the placeholder `auto`, there is no longer a need to explicitly specify the type?
 Fortunately, C++17 introduces this feature, and we can indeed use the `auto` keyword to let the compiler assist in the completion of specific types of derivation.
@@ -919,6 +899,7 @@ C++11 introduces the concept of a delegate construct, which allows a constructor
 in a constructor in the same class, thus simplifying the code:
 ```cpp
 #include <iostream>
 class Base {
 public:
    int value1;
@@ -943,6 +924,7 @@ int main() {
 In traditional C++, constructors need to pass arguments one by one if they need inheritance, which leads to inefficiency. C++11 introduces the concept of inheritance constructors using the keyword using:
 ```cpp
 #include <iostream>
 class Base {
 public:
    int value1;
@@ -956,7 +938,7 @@ public:
 };
 class Subclass : public Base {
 public:
-    using Base::Base; // inhereit constructor
+    using Base::Base; // inheritance constructor
 };
 int main() {
    Subclass s(3);
@@ -1018,7 +1000,7 @@ struct SubClass3: Base {
 ### Explicit delete default function
-In traditional C++, if the programmer does not provide it, the compiler will default to generating default constructors, copy constructs, assignment operators, and destructors for the object. In addition, C++ also defines operators such as `new` `delete` for all classes. This part of the function can be overridden when the programmer needs it.
+In traditional C++, if the programmer does not provide it, the compiler will default to generating default constructors, copy constructs, assignment operators, and destructors for the object. Besides, C++ also defines operators such as `new` `delete` for all classes. This part of the function can be overridden when the programmer needs it.
 This raises some requirements: the ability to accurately control the generation of default functions cannot be controlled. For example, when copying a class is prohibited, the copy constructor and the assignment operator must be declared as `private`. Trying to use these undefined functions will result in compilation or link errors, which is a very unconventional way.
@@ -1065,7 +1047,9 @@ And we want to get the value of the enumeration value, we will have to explicitl
 ```cpp
 #include <iostream>
 template<typename T>
-std::ostream& operator<<(typename std::enable_if<std::is_enum<T>::value, std::ostream>::type& stream, const T& e)
+std::ostream& operator<<(
    typename std::enable_if<std::is_enum<T>::value,
        std::ostream>::type& stream, const T& e)
 {
    return stream << static_cast<typename std::underlying_type<T>::type>(e);
 }
@@ -1081,7 +1065,7 @@ std::cout << new_enum::value3 << std::endl
 This section introduces the enhancements to language usability in modern C++, which I believe are the most important features that almost everyone needs to know and use:
-1. auto type derivation
+1. Auto type derivation
 2. Scope for iteration
 3. Initialization list
 4. Variable parameter template
@@ -1091,6 +1075,10 @@ This section introduces the enhancements to language usability in modern C++, wh
 1. Using structured binding, implement the following functions with just one line of function code:
   ```cpp
   #include <string>
   #include <map>
   #include <iostream>
   template <typename Key, typename Value, typename F>
   void update(std::map<Key, Value>& m, F foo) {
       // TODO:
--- a/book/en-us/03-runtime.md
+++ b/book/en-us/03-runtime.md
@@ -10,9 +10,9 @@ order: 3
 ## 3.1 Lambda Expression
-Lambda expressions are one of the most important features in modern C++, and Lambda expressions actually provide a feature like anonymous functions.
+Lambda expressions are one of the most important features in modern C++, and Lambda expressions provide a feature like anonymous functions.
-Anonymous functions are used when a function is needed, but you don't want to use a function to name a function. There are actually many, many scenes like this.
+Anonymous functions are used when a function is needed, but you don’t want to use a name to call a function. There are many, many scenes like this.
-So anonymous functions are almost standard on modern programming languages.
+So anonymous functions are almost standard in modern programming languages.
 ### Basics
@@ -24,7 +24,7 @@ The basic syntax of a Lambda expression is as follows:
 }
 ```
-The above grammar rules are well understood except for the things in `[catch list]`, 
+The above grammar rules are well understood except for the things in `[capture list]`,
 except that the function name of the general function is omitted.
 The return value is in the form of a `->`
 (we have already mentioned this in the tail return type earlier in the previous section).
@@ -87,8 +87,8 @@ capture lists can be:
 - \[\] empty capture list
 - \[name1, name2, ...\] captures a series of variables
- \[&\] reference capture, let the compiler derive the capture list by itself
+- \[&\] reference capture, let the compiler deduce the reference list by itself
- \[=\] value capture, let the compiler execute the list of derivation applications
+- \[=\] value capture, let the compiler deduce the value list by itself
 #### 4. Expression capture
@@ -105,6 +105,10 @@ The type of the captured variable being declared is judged according to the expr
 and the judgment is the same as using `auto`:
 ```cpp
 #include <iostream>
 #include <memory>  // std::make_unique
 #include <utility> // std::move
 void lambda_expression_capture() {
    auto important = std::make_unique<int>(1);
    auto add = [v1 = 1, v2 = std::move(important)](int x, int y) -> int {
@@ -114,13 +118,13 @@ void lambda_expression_capture() {
 }
 ```
-In the above code, `important` is an exclusive pointer that cannot be caught. 
+In the above code, `important` is an exclusive pointer that cannot be caught by value capture using `=`.
 At this time we need to transfer it to the rvalue and
 initialize it in the expression.
 ### Generic Lambda
-In the previous section we mentioned that the `auto` keyword cannot be used 
+In the previous section, we mentioned that the `auto` keyword cannot be used
 in the parameter list because it would conflict with the functionality of the template.
 But Lambda expressions are not ordinary functions, so Lambda expressions are not templated.
 This has caused us some trouble: the parameter table cannot be generalized,
@@ -143,9 +147,9 @@ void lambda_generic() {
 ## 3.2 Function Object Wrapper
-Although this part of the standard library is part of the standard library, 
+Although the features are part of the standard library and not found in runtime,
 it enhances the runtime capabilities of the C++ language.
-This part of the content is also very important, so put it here for introduction.
+This part of the content is also very important, so put it here for the introduction.
 ### `std::function`
@@ -183,7 +187,6 @@ the call to a function pointer is not type-safe), in other words,
 a container of functions. When we have a container for functions,
 we can more easily handle functions and function pointers as objects. e.g:
 ```cpp
 #include <functional>
 #include <iostream>
@@ -260,9 +263,25 @@ Temporary variables returned by non-references, temporary variables generated
 by operation expressions, original literals, and Lambda expressions
 are all pure rvalue values.
 Note that a string literal became rvalue in a class, and remains an lvalue in other cases (e.g., in a function)：
 ```cpp
 class Foo {
        const char*&& right = "this is a rvalue";
 public:
        void bar() {
            right = "still rvalue"; // the string literal is a rvalue
        }
 };
 int main() {
    const char* const &left = "this is an lvalue"; // the string literal is an lvalue
 }
 ```
 **xvalue, expiring value** is the concept proposed by C++11 to introduce
-rvalue references (so in traditional C++, pure rvalue and rvalue are the same concept), 
+rvalue references (so in traditional C++, pure rvalue and rvalue are the same concepts),
-that is, A value that is destroyed but can be moved.
+a value that is destroyed but can be moved.
 It would be a little hard to understand the xvalue,
 let's look at the code like this:
@@ -283,11 +302,11 @@ And then destroy `temp`, if this `temp` is very large, this will cause a lot of
 overhead (this is the problem that traditional C++ has been criticized for).
 In the last line, `v` is the lvalue, and the value returned by `foo()` is
 the rvalue (which is also a pure rvalue).
-However, `v` can be caught by other variables, and the return value generated 
+
-by `foo()` is used as a temporary value. Once copied by `v`, 
+However, `v` can be caught by other variables, and the return value generated by `foo()`
-it will be destroyed immediately, and cannot be obtained or modified. 
+is used as a temporary value. Once copied by `v`, it will be destroyed immediately, and
-The xvalue defines an behavior in which temporary values can be identified 
+cannot be obtained or modified. The xvalue defines behavior in which temporary values can be
-while being able to be moved.
+identified while being able to be moved.
 After C++11, the compiler did some work for us, where the lvalue `temp`
 is subjected to this implicit rvalue conversion,
@@ -330,7 +349,7 @@ int main()
    std::string&& rv2 = lv1 + lv2;      // legal, rvalue ref extend lifecycle
    rv2 += "string";                    // legal, non-const reference can be modified
-    std::cout << rv2 << std::endl;      // string,string,string,
+    std::cout << rv2 << std::endl;      // string,string,string,string
    reference(rv2);                     // output: lvalue
@@ -380,10 +399,10 @@ The reason is simple because Fortran needs it.
 Traditional C++ has designed the concept of copy/copy for class objects
 through copy constructors and assignment operators,
-but in order to implement the movement of resources,
+but to implement the movement of resources,
 The caller must use the method of copying and then destructing first,
-otherwise you need to implement the interface of the mobile object yourself.
+otherwise, you need to implement the interface of the mobile object yourself.
-Imagine moving to move your home directly to your new home instead of 
+Imagine moving your home directly to your new home instead of
 copying everything (rebuy) to your new home.
 Throwing away (destroying) all the original things is a very anti-human thing.
@@ -496,14 +515,14 @@ For `pass(1)`, although the value is the rvalue, since `v` is a reference, it is
 Therefore `reference(v)` will call `reference(int&)` and output lvalue.
 For `pass(l)`, `l` is an lvalue, why is it successfully passed to `pass(T&&)`?
-This is based on the **reference contraction rule**: In traditional C++, we are not able to continue to reference a reference type.
+This is based on the **reference collapsing rule**: In traditional C++, we are not able to continue to reference a reference type.
 However,
 C++ has relaxed this practice with the advent of rvalue references,
 resulting in a reference collapse rule that allows us to reference references,
 both lvalue and rvalue. But follow the rules below:
 | Function parameter type | Argument parameter type | Post-derivation function parameter type |
-| :--------: | :--------: | :-------------: |
+| :---------------------: | :---------------------: | :-------------------------------------: |
 |           T&            |       lvalue ref        |                   T&                    |
 |           T&            |       rvalue ref        |                   T&                    |
 |           T&&           |       lvalue ref        |                   T&                    |
@@ -511,7 +530,7 @@ both lvalue and rvalue. But follow the rules below:
 Therefore, the use of `T&&` in a template function may not be able to make an rvalue reference, and when a lvalue is passed, a reference to this function will be derived as an lvalue.
 More precisely, ** no matter what type of reference the template parameter is, the template parameter can be derived as a right reference type** if and only if the argument type is a right reference.
-This makes `v` a successful delivery of lvalues.
+This makes `v` successful delivery of lvalues.
 Perfect forwarding is based on the above rules. The so-called perfect forwarding is to let us pass the parameters,
 Keep the original parameter type (lvalue reference keeps lvalue reference, rvalue reference keeps rvalue reference).
@@ -567,11 +586,11 @@ static_cast<T&&> param passing: lvalue reference
 Regardless of whether the pass parameter is an lvalue or an rvalue, the normal pass argument will forward the argument as an lvalue.
 So `std::move` will always accept an lvalue, which forwards the call to `reference(int&&)` to output the rvalue reference.
-Only `std::forward` does not cause any extra copies, and ** perfectly forwards ** (passes) the arguments of the function to other functions that are called internally.
+Only `std::forward` does not cause any extra copies and ** perfectly forwards ** (passes) the arguments of the function to other functions that are called internally.
 `std::forward` is the same as `std::move`, and nothing is done. `std::move` simply converts the lvalue to the rvalue.
 `std::forward` is just a simple conversion of the parameters. From the point of view of the phenomenon,
-`std::forward<T>(v)` is exactly the same as `static_cast<T&&>(v)`.
+`std::forward<T>(v)` is the same as `static_cast<T&&>(v)`.
 Readers may be curious as to why a statement can return values for two types of returns.
 Let's take a quick look at the concrete implementation of `std::forward`. `std::forward` contains two overloads:
@@ -591,14 +610,14 @@ constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type&& __t) noexcep
 ```
 In this implementation, the function of `std::remove_reference` is to eliminate references in the type.
-And `std::is_lvalue_reference` is used to check if the type derivation is correct, in the second implementation of `std::forward`
+And `std::is_lvalue_reference` is used to check if the type derivation is correct, in the second implementation of `std::forward`.
 Check that the received value is indeed an lvalue, which in turn reflects the collapse rule.
 When `std::forward` accepts an lvalue, `_Tp` is deduced to the lvalue, so the return value is the lvalue; and when it accepts the rvalue,
 `_Tp` is derived as an rvalue reference, and based on the collapse rule, the return value becomes the rvalue of `&& + &&`.
 It can be seen that the principle of `std::forward` is to make clever use of the differences in template type derivation.
-At this point we can answer the question: Why is `auto&&` the safest way to use looping statements?
+At this point, we can answer the question: Why is `auto&&` the safest way to use looping statements?
 Because when `auto` is pushed to a different lvalue and rvalue reference, the collapsed combination with `&&` is perfectly forwarded.
 ## Conclusion
@@ -606,6 +625,7 @@ Because when `auto` is pushed to a different lvalue and rvalue reference, the co
 This chapter introduces the most important runtime enhancements in modern C++, and I believe that all the features mentioned in this section are worth knowing:
 Lambda expression
 1. Function object container std::function
 2. rvalue reference
--- a/book/en-us/04-containers.md
+++ b/book/en-us/04-containers.md
@@ -12,13 +12,13 @@ order: 4
 ### `std::array`
-When you see this container, you will definitely have this problem:
+When you see this container, you will have this problem:
 1. Why introduce `std::array` instead of `std::vector` directly?
 2. Already have a traditional array, why use `std::array`?
-First answer the first question. Unlike `std::vector`, the size of the `std::array` object is fixed. If the container size is fixed, then the `std::array` container can be used first.
+First, answer the first question. Unlike `std::vector`, the size of the `std::array` object is fixed. If the container size is fixed, then the `std::array` container can be used first.
-In addition, since `std::vector` is automatically expanded, when a large amount of data is stored, and the container is deleted,
+Also, since `std::vector` is automatically expanded, when a large amount of data is stored, and the container is deleted,
 The container does not automatically return the corresponding memory of the deleted element. In this case, you need to manually run `shrink_to_fit()` to release this part of the memory.
 ```cpp
@@ -103,7 +103,7 @@ std::sort(arr.begin(), arr.end());
 ### `std::forward_list`
-`std::forward_list` is a list container, and the usage is basically similar to `std::list`, so we don't spend a lot of time introducing it.
+`std::forward_list` is a list container, and the usage is similar to `std::list`, so we don't spend a lot of time introducing it.
 Need to know is that, unlike the implementation of the doubly linked list of `std::list`, `std::forward_list` is implemented using a singly linked list.
 Provides element insertion of `O(1)` complexity, does not support fast random access (this is also a feature of linked lists),
@@ -115,7 +115,7 @@ We are already familiar with the ordered container `std::map`/`std::set` in trad
 The average complexity of inserts and searches is `O(log(size))`. When inserting an element, the element size is compared according to the `<` operator and the element is determined to be the same.
 And select the appropriate location to insert into the container. When traversing the elements in this container, the output will be traversed one by one in the order of the `<` operator.
-The elements in the unordered container are not sorted, and the internals are implemented by the Hash table. The average complexity of inserting and searching for elements is `O(constant)`,
+The elements in the unordered container are not sorted, and the internals is implemented by the Hash table. The average complexity of inserting and searching for elements is `O(constant)`,
 Significant performance gains can be achieved without concern for the order of the elements inside the container.
 C++11 introduces two sets of unordered containers: `std::unordered_map`/`std::unordered_multimap` and
@@ -172,7 +172,7 @@ Key:[3] Value:[3]
 ## 4.3 Tuples
 Programmers who have known Python should be aware of the concept of tuples. Looking at the containers in traditional C++, except for `std::pair`
-There seems to be no ready-made structure to store different types of data (usually we will define the structure ourselves).
+there seems to be no ready-made structure to store different types of data (usually we will define the structure ourselves).
 But the flaw of `std::pair` is obvious, only two elements can be saved.
 ### Basic Operations
@@ -278,7 +278,7 @@ auto new_tuple = std::tuple_cat(get_student(1), std::move(t));
 ```
 You can immediately see how quickly you can traverse a tuple? But we just introduced how to index a `tuple` by a very number at runtime, then the traversal becomes simpler.
-First we need to know the length of a tuple, which can:
+First, we need to know the length of a tuple, which can:
 ```cpp
 template <typename T>
@@ -292,12 +292,12 @@ This will iterate over the tuple:
 ```cpp
 for(int i = 0; i != tuple_len(new_tuple); ++i)
    // runtime indexing
-    std::cout << tuple_index(i, new_tuple) << std::endl;
+    std::cout << tuple_index(new_tuple, i) << std::endl;
 ```
 ## Conclusion
-This chapter briefly introduces the new containers in modern C++. Their usage is similar to that of the existing containers in C++. It is relatively simple, and you can choose the containers you need to use according to the actual scene, so as to get better performance.
+This chapter briefly introduces the new containers in modern C++. Their usage is similar to that of the existing containers in C++. It is relatively simple, and you can choose the containers you need to use according to the actual scene, to get better performance.
 Although `std::tuple` is effective, the standard library provides limited functionality and there is no way to meet the requirements of runtime indexing and iteration. Fortunately, we have other methods that we can implement on our own.
--- a/book/en-us/05-pointers.md
+++ b/book/en-us/05-pointers.md
@@ -18,15 +18,15 @@ In traditional C++, "remembering" to manually release resources is not always a
 So the usual practice is that for an object, we apply for space when constructor, and free space when the destructor (called when leaving the scope).
 That is, we often say that the RAII resource acquisition is the initialization technology.
-There are exceptions to everything, we always have the need to allocate objects on free storage. In traditional C++ we have to use `new` and `delete` to "remember" to release resources. C++11 introduces the concept of smart pointers, using the idea of reference counting, so that programmers no longer need to care about manually releasing memory.
+There are exceptions to everything, we always need to allocate objects on free storage. In traditional C++ we have to use `new` and `delete` to "remember" to release resources. C++11 introduces the concept of smart pointers, using the idea of reference counting so that programmers no longer need to care about manually releasing memory.
 These smart pointers include `std::shared_ptr`/`std::unique_ptr`/`std::weak_ptr`, which need to include the header file `<memory>`.
 > Note: The reference count is not garbage collection. The reference count can recover the objects that are no longer used as soon as possible, and will not cause long waits during the recycling process.
-> More clearly and clearly indicate the life cycle of resources.
+> More clearly and indicate the life cycle of resources.
 ## 5.2 `std::shared_ptr`
-`std::shared_ptr` is a smart pointer that records how many `shared_ptr` points to an object, eliminating the display call `delete`, which automatically deletes the object when the reference count becomes zero.
+`std::shared_ptr` is a smart pointer that records how many `shared_ptr` points to an object, eliminating to call `delete`, which automatically deletes the object when the reference count becomes zero.
 But not enough, because using `std::shared_ptr` still needs to be called with `new`, which makes the code a certain degree of asymmetry.
@@ -36,12 +36,10 @@ And return the `std::shared_ptr` pointer of this object type. For example:
 ```cpp
 #include <iostream>
 #include <memory>
-void foo(std::shared_ptr<int> i)
+void foo(std::shared_ptr<int> i) {
 {
    (*i)++;
 }
-int main()
+int main() {
 {
    // auto pointer = new int(10); // illegal, no direct assignment
    // Constructed a std::shared_ptr
    auto pointer = std::make_shared<int>(10);
@@ -133,12 +131,12 @@ int main() {
        // p2 is empty, no prints
        if(p2) p2->foo();
-        std::cout << "p2 was destroied" << std::endl;
+        std::cout << "p2 was destroyed" << std::endl;
    }
    // p1 is not empty, prints
    if (p1) p1->foo();
-    // Foo instance will be destroied when leaving the scope
+    // Foo instance will be destroyed when leaving the scope
 }
 ```
@@ -157,14 +155,14 @@ class A {
 public:
    std::shared_ptr<B> pointer;
    ~A() {
-        std::cout << "A was destroied" << std::endl;
+        std::cout << "A was destroyed" << std::endl;
    }
 };
 class B {
 public:
    std::shared_ptr<A> pointer;
    ~B() {
-        std::cout << "B was destroied" << std::endl;
+        std::cout << "B was destroyed" << std::endl;
    }
 };
 int main() {
@@ -177,9 +175,9 @@ int main() {
 }
 ```
-The result is that A and B will not be destroyed. This is because the pointer inside a, b also references `a, b`, which makes the reference count of `a, b` become 2, leaving the scope. When the `a, b` smart pointer is destructed, it can only cause the reference count of this area to be decremented by one. This causes the memory area reference count pointed to by the `a, b` object to be non-zero, but the external has no The way to find this area, it also caused a memory leak, as shown in Figure 5.1:
+The result is that A and B will not be destroyed. This is because the pointer inside a, b also references `a, b`, which makes the reference count of `a, b` becomes 2, leaving the scope. When the `a, b` smart pointer is destructed, it can only cause the reference count of this area to be decremented by one. This causes the memory area reference count pointed to by the `a, b` object to be non-zero, but the external has no way to find this area, it also caused a memory leak, as shown in Figure 5.1:
-![Figure 5.1](../../assets/figures/pointers1.png)
+![Figure 5.1](../../assets/figures/pointers1_en.png)
 The solution to this problem is to use the weak reference pointer `std::weak_ptr`, which is a weak reference (compared to `std::shared_ptr` is a strong reference). A weak reference does not cause an increase in the reference count. When a weak reference is used, the final release process is shown in Figure 5.2:
@@ -187,7 +185,7 @@ The solution to this problem is to use the weak reference pointer `std::weak_ptr
 In the above figure, only B is left in the last step, and B does not have any smart pointers to reference it, so this memory resource will also be released.
-`std::weak_ptr` has no `*` operator and `->` operator, so it can't operate on resources. Its only function is to check if `std::shared_ptr` exists, its `expired() The ` method can return `true` when the resource is not released, otherwise it returns `false`.
+`std::weak_ptr` has no `*` operator and `->` operator, so it can't operate on resources. Its only function is to check if `std::shared_ptr` exists, its `expired()` method can return `false` when the resource is not released, otherwise, it returns `true`.
 ## Conclusion
--- a/book/en-us/06-regex.md
+++ b/book/en-us/06-regex.md
@@ -27,17 +27,15 @@ Regular expressions act as a template to match a character pattern to the string
 ### Ordinary characters
-Normal characters include all printable and unprintable characters that 
+Normal characters include all printable and unprintable characters that are not explicitly specified as metacharacters. This includes all uppercase
 are not explicitly specified as metacharacters. This includes all uppercase 
 and lowercase letters, all numbers, all punctuation, and some other symbols.
 ### Special characters
-A special character is a character with special meaning in a regular expression, 
+A special character is a character with special meaning in a regular expression and is also the core matching syntax of a regular expression. See the table below:
 and is also the core matching syntax of a regular expression. See the table below:
 | Special characters | Description                                                                                                                                                                                                                                                                                                |
-|:---:|:------------------------------------------------------|
+| :----------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 |        `$`         | Matches the end position of the input string.                                                                                                                                                                                                                                                              |
 |      `(`,`)`       | Marks the start and end of a subexpression. Subexpressions can be obtained for later use.                                                                                                                                                                                                                  |
 |        `*`         | Matches the previous subexpression zero or more times.                                                                                                                                                                                                                                                     |
@@ -48,14 +46,14 @@ and is also the core matching syntax of a regular expression. See the table belo
 |        `\`         | Marks the next character as either a special character, or a literal character, or a backward reference, or an octal escape character. For example, `n` Matches the character `n`. `\n` matches newline characters. The sequence `\\` Matches the `'\'` character, while `\(` matches the `'('` character. |
 |        `^`         | Matches the beginning of the input string, unless it is used in a square bracket expression, at which point it indicates that the set of characters is not accepted.                                                                                                                                       |
 |        `{`         | Marks the beginning of a qualifier expression.                                                                                                                                                                                                                                                             |
-|`\`| Indicates a choice between the two. |
+|        `\|`        | Indicates a choice between the two.                                                                                                                                                                                                                                                                        |
 ### Quantifiers
 The qualifier is used to specify how many times a given component of a regular expression must appear to satisfy the match. See the table below:
 | Character | Description                                                                                                                                                                                                                                                                                                       |
-|:---:|:------------------------------------------------------|
+| :-------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 |    `*`    | matches the previous subexpression zero or more times. For example, `foo*` matches `fo` and `foooo`. `*` is equivalent to `{0,}`.                                                                                                                                                                                 |
 |    `+`    | matches the previous subexpression one or more times. For example, `foo+` matches `foo` and `foooo` but does not match `fo`. `+` is equivalent to `{1,}`.                                                                                                                                                         |
 |    `?`    | matches the previous subexpression zero or one time. For example, `Your(s)?` can match `Your` in `Your` or `Yours`. `?` is equivalent to `{0,1}`.                                                                                                                                                                 |
@@ -67,7 +65,7 @@ With these two tables, we can usually read almost all regular expressions.
 ## 6.2 `std::regex` and Its Related
-The most common way to match string content is to use regular expressions. Unfortunately, in traditional C++, regular expressions have not been supported by the language level, and are not included in the standard library. C++ is a high-performance language. In the development of background services, the use of regular expressions is also used when judging URL resource links. The most mature and common practice in industry.
+The most common way to match string content is to use regular expressions. Unfortunately, in traditional C++, regular expressions have not been supported by the language level, and are not included in the standard library. C++ is a high-performance language. In the development of background services, the use of regular expressions is also used when judging URL resource links. The most mature and common practice in the industry.
 The general solution is to use the regular expression library of `boost`. C++11 officially incorporates the processing of regular expressions into the standard library, providing standard support from the language level and no longer relying on third parties.
@@ -77,7 +75,7 @@ We use a simple example to briefly introduce the use of this library. Consider t
 - `[az]+\.txt`: In this regular expression, `[az]` means matching a lowercase letter, `+` can match the previous expression multiple times, so `[az]+` can Matches a string of lowercase letters. In the regular expression, a `.` means to match any character, and `\.` means to match the character `.`, and the last `txt` means to match `txt` exactly three letters. So the content of this regular expression to match is a text file consisting of pure lowercase letters.
-`std::regex_match` is used to match strings and regular expressions, and there are many different overloaded forms. The simplest form is to pass `std::string` and a `std::regex` to match. When the match is successful, it will return `true`, otherwise it will return `false`. For example:
+`std::regex_match` is used to match strings and regular expressions, and there are many different overloaded forms. The simplest form is to pass `std::string` and a `std::regex` to match. When the match is successful, it will return `true`, otherwise, it will return `false`. For example:
 ```cpp
 #include <iostream>
--- a/book/en-us/07-thread.md
+++ b/book/en-us/07-thread.md
@@ -28,16 +28,16 @@ int main() {
 ## 7.2 Mutex and Critical Section
-We have already learned the basics of concurrency technology in the operating system, or in the database, and `mutex` is one of the cores.
+We have already learned the basics of concurrency technology in the operating system, or the database, and `mutex` is one of the cores.
 C++11 introduces a class related to `mutex`, with all related functions in the `<mutex>` header file.
 `std::mutex` is the most basic `mutex` class in C++11, and you can create a mutex by instantiating `std::mutex`.
 It can be locked by its member function `lock()`, and `unlock()` can be unlocked.
 But in the process of actually writing the code, it is best not to directly call the member function,
 Because calling member functions, you need to call `unlock()` at the exit of each critical section, and of course, exceptions.
-At this time, C++11 also provides a template class `std::lock_gurad` for the RAII syntax for the mutex.
+At this time, C++11 also provides a template class `std::lock_guard` for the RAII syntax for the mutex.
-RAII guarantees the exceptional security of the code while losing the simplicity of the code.
+RAII guarantees the exceptional security of the code while keeping the simplicity of the code.
 ```cpp
 #include <iostream>
@@ -114,10 +114,10 @@ int main() {
 ## 7.3 Future
 The Future is represented by `std::future`, which provides a way to access the results of asynchronous operations. This sentence is very difficult to understand.
-In order to understand this feature, we need to understand the multi-threaded behavior before C++11.
+To understand this feature, we need to understand the multi-threaded behavior before C++11.
 Imagine if our main thread A wants to open a new thread B to perform some of our expected tasks and return me a result.
-At this time, thread A may be busy with other things, and have no time to take into account the results of B.
+At this time, thread A may be busy with other things and have no time to take into account the results of B.
 So we naturally hope to get the result of thread B at a certain time.
 Before the introduction of `std::future` in C++11, the usual practice is:
@@ -156,7 +156,7 @@ The condition variable `std::condition_variable` was born to solve the deadlock
 For example, a thread may need to wait for a condition to be true to continue execution.
 A dead wait loop can cause all other threads to fail to enter the critical section so that when the condition is true, a deadlock occurs.
 Therefore, the `condition_variable` instance is created primarily to wake up the waiting thread and avoid deadlocks.
-`notd_one()` of `std::condition_variable` is used to wake up a thread;
+`notify_one()` of `std::condition_variable` is used to wake up a thread;
 `notify_all()` is to notify all threads. Below is an example of a producer and consumer model:
 ```cpp
@@ -217,15 +217,15 @@ int main() {
 }
 ```
-It is worth mentioning that although we can use `notify_one()` in the producer, it is not really recommended to use it here.
+It is worth mentioning that although we can use `notify_one()` in the producer, it is not recommended to use it here.
-Because in the case of multiple consumers, our consumer implementation simply gives up the lock holding, which makes it possible for other consumers to compete for this lock, so as to better utilize the concurrency between multiple consumers. Having said that, but in fact because of the exclusivity of `std::mutex`,
+Because in the case of multiple consumers, our consumer implementation simply gives up the lock holding, which makes it possible for other consumers to compete for this lock, to better utilize the concurrency between multiple consumers. Having said that, but in fact because of the exclusivity of `std::mutex`,
-We simply can't expect multiple consumers to be able to actually produce content in a parallel consumer queue, and we still need a more granular approach.
+We simply can't expect multiple consumers to be able to produce content in a parallel consumer queue, and we still need a more granular approach.
 ## 7.5 Atomic Operation and Memory Model
-Careful readers may be tempted by the fact that the example of the producer consumer model in the previous section may have compiler optimizations that cause program errors.
+Careful readers may be tempted by the fact that the example of the producer-consumer model in the previous section may have compiler optimizations that cause program errors.
 For example, the boolean `notified` is not modified by `volatile`, and the compiler may have optimizations for this variable, such as the value of a register.
-As a result, the consumer thread can never observe the change of this value. This is a good question. To explain this problem, we need to further discuss the concept of memory model introduced from C++11. Let's first look at a question. What is the output of the following code?
+As a result, the consumer thread can never observe the change of this value. This is a good question. To explain this problem, we need to further discuss the concept of the memory model introduced from C++11. Let's first look at a question. What is the output of the following code?
 ```cpp
 #include <thread>
@@ -253,20 +253,20 @@ int main() {
 }
 ```
-Intuitively, ʻa = 5;` in `t2` seems to always execute before `flag = 1;`, and `while (flag != 1)` in `t1` seems to guarantee `std ::cout << "b = " << b << std::endl;` will not be executed before the mark is changed. Logically, it seems that the value of `b` should be equal to 5.
+Intuitively, `a = 5;` seems in `t2` seems to always execute before `flag = 1;`, and `while (flag != 1)` in `t1` seems to guarantee `std ::cout << "b = " << b << std::endl;` will not be executed before the mark is changed. Logically, it seems that the value of `b` should be equal to 5.
-But the actual situation is much more complicated than this, or the code itself is undefined behavior, because for `a` and `flag`, they are read and written in two parallel threads.
+But the actual situation is much more complicated than this, or the code itself is undefined behavior because, for `a` and `flag`, they are read and written in two parallel threads.
-There has been competition. In addition, even if we ignore competing reading and writing, it is still possible to receive out-of-order execution of the CPU, and the impact of the compiler on the rearrangement of instructions.
+There has been competition. Also, even if we ignore competing for reading and writing, it is still possible to receive out-of-order execution of the CPU and the impact of the compiler on the rearrangement of instructions.
 Cause `a = 5` to occur after `flag = 1`. Thus `b` may output 0.
 ### Atomic Operation
-`std::mutex` can solve the problem of concurrent read and write, but the mutex is an operating system level function.
+`std::mutex` can solve the problem of concurrent read and write, but the mutex is an operating system-level function.
 This is because the implementation of a mutex usually contains two basic principles:
 1. Provide automatic state transition between threads, that is, "lock" state
 2. Ensure that the memory of the manipulated variable is isolated from the critical section during the mutex operation
-This is a very strong set of synchronization conditions, in other words, when it is finally compiled into a CPU instruction, it will behave as a lot of instructions (we will look at how to implement a simple mutex later).
+This is a very strong set of synchronization conditions, in other words when it is finally compiled into a CPU instruction, it will behave like a lot of instructions (we will look at how to implement a simple mutex later).
 This seems too harsh for a variable that requires only atomic operations (no intermediate state).
 The research on synchronization conditions has a very long history, and we will not go into details here. Readers should understand that under the modern CPU architecture, atomic operations at the CPU instruction level are provided.
@@ -303,7 +303,7 @@ int main() {
 }
 ```
-Of course, not all types provide atomic operations because the feasibility of atomic operations depends on the architecture of the CPU and whether the type structure being instantiated satisfies the memory alignment requirements of the architecture, so we can always pass Std::atomic<T>::is_lock_free` to check if the atom type needs to support atomic operations, for example:
+Of course, not all types provide atomic operations because the feasibility of atomic operations depends on the architecture of the CPU and whether the type structure being instantiated satisfies the memory alignment requirements of the architecture, so we can always pass `std::atomic<T>::is_lock_free` to check if the atom type needs to support atomic operations, for example:
 ```cpp
 #include <atomic>
@@ -314,6 +314,8 @@ struct A {
    int y;
    long long z;
 };
 int main() {
    std::atomic<A> a;
    std::cout << std::boolalpha << a.is_lock_free() << std::endl;
    return 0;
@@ -364,7 +366,7 @@ Weakening the synchronization conditions between processes, usually we will cons
         x.store(2)
   ```
-    Under the order consistency requirement, `x.load()` must read the last written data, so `x.store(2)` and `x.store(1)` do not have any guarantees, ie As long as ``x.store(2)` of `T2` occurs before `x.store(3)`.
+   Under the order consistency requirement, `x.load()` must read the last written data, so `x.store(2)` and `x.store(1)` do not have any guarantees, ie As long as `x.store(2)` of `T2` occurs before `x.store(3)`.
 3. Causal consistency: its requirements are further reduced, only the sequence of causal operations is guaranteed, and the order of non-causal operations is not required.
@@ -395,9 +397,9 @@ Weakening the synchronization conditions between processes, usually we will cons
         y.load()            c = a + b  x.store(3)
   ```
-    The three examples given above are all causal consistent, because in the whole process, only `c` has a dependency on `a` and `b`, and `x` and `y` are not related in this example. (But in actual situations we need more detailed information to determine that `x` is not related to `y`)
+   The three examples given above are all causal consistent because, in the whole process, only `c` has a dependency on `a` and `b`, and `x` and `y` are not related in this example. (But in actual situations we need more detailed information to determine that `x` is not related to `y`)
-4. Final Consistency: It is the weakest consistency requirement. It only guarantees that an operation will be observed at a certain point in the future, but does not require the observed time. So we can even strengthen this condition a bit, for example, to specify that the time observed for an operation is always bounded. Of course this is no longer within our discussion.
+4. Final Consistency: It is the weakest consistency requirement. It only guarantees that an operation will be observed at a certain point in the future, but does not require the observed time. So we can even strengthen this condition a bit, for example, to specify that the time observed for an operation is always bounded. Of course, this is no longer within our discussion.
   ```
       x.store(3)  x.store(4)
@@ -419,7 +421,7 @@ Weakening the synchronization conditions between processes, usually we will cons
 ### Memory Orders
-In order to achieve the ultimate performance and achieve consistency of various strength requirements, C++11 defines six different memory sequences for atomic operations. The option `std::memory_order` expresses four synchronization models between multiple threads:
+To achieve the ultimate performance and achieve consistency of various strength requirements, C++11 defines six different memory sequences for atomic operations. The option `std::memory_order` expresses four synchronization models between multiple threads:
 1. Relaxed model: Under this model, atomic operations within a single thread are executed sequentially, and instruction reordering is not allowed, but the order of atomic operations between different threads is arbitrary. The type is specified by `std::memory_order_relaxed`. Let's look at an example:
@@ -427,7 +429,7 @@ In order to achieve the ultimate performance and achieve consistency of various
   std::atomic<int> counter = {0};
   std::vector<std::thread> vt;
   for (int i = 0; i < 100; ++i) {
-        vt.emplace_back([](){
+       vt.emplace_back([&](){
           counter.fetch_add(1, std::memory_order_relaxed);
       });
   }
@@ -438,11 +440,11 @@ In order to achieve the ultimate performance and achieve consistency of various
   std::cout << "current counter:" << counter << std::endl;
   ```
 2. Release/consumption model: In this model, we begin to limit the order of operations between processes. If a thread needs to modify a value, but another thread will have a dependency on that operation of the value, that is, the latter depends. former. Specifically, thread A has completed three writes to `x`, and thread `B` relies only on the third `x` write operation, regardless of the first two write behaviors of `x`, then `A ` When active `x.release()` (ie using `std::memory_order_release`), the option `std::memory_order_consume` ensures that `B` observes `A` when calling `x.load()` Three writes to `x`. Let's look at an example:
   ```cpp
-    std::atomic<int*> ptr;
+   // initialize as nullptr to prevent consumer load a dangling pointer
   std::atomic<int*> ptr(nullptr);
   int v;
   std::thread producer([&]() {
       int* p = new int(42);
@@ -460,9 +462,10 @@ In order to achieve the ultimate performance and achieve consistency of various
   consumer.join();
   ```
-3. Release/Acquire model: Under this model, we can further tighten the order of atomic operations between different threads, specifying the timing between releasing `std::memory_order_release` and getting `std::memory_order_acquire`. **All** write operations before the release operation are visible to any other thread, ie, happens-before.
+3. Release/Acquire model: Under this model, we can further tighten the order of atomic operations between different threads, specifying the timing between releasing `std::memory_order_release` and getting `std::memory_order_acquire`. **All** write operations before the release operation is visible to any other thread, i.e., happens before.
-    As you can see, `std::memory_order_release` ensures that the write behavior after it does not occur before the release operation, is a backward barrier, and `std::memory_order_acquire` ensures the previous write behavior after it, no It will happen after the get operation, it is a forward barrier. For the option `std::memory_order_acq_rel`, it combines the characteristics of the two, and only determines a memory barrier, so that the current thread reads and writes to the memory. Will not be rearranged before and after this operation.
+   As you can see, `std::memory_order_release` ensures that a write before a release does not occur after the release operation, which is a **backward barrier**, and `std::memory_order_acquire` ensures that a subsequent read or write after a acquire does not occur before the acquire operation, which is a **forward barrier**.
   For the `std::memory_order_acq_rel` option, combines the characteristics of the two barriers and determines a unique memory barrier, such that reads and writes of the current thread will not be rearranged across the barrier.
   Let's check an example:
@@ -490,15 +493,15 @@ In order to achieve the ultimate performance and achieve consistency of various
   acquire.join();
   ```
-    In this case we used `compare_exchange_strong`, which is the Compare-and-swap primitive, which has a weaker version, `compare_exchange_weak`, which allows a failure to be returned even if the exchange is successful. The reason is due to a false failure on some platforms, specifically, when the CPU performs a context switch, another thread loads the same address to produce an inconsistency. In addition, the performance of `compare_exchange_strong` may be slightly worse than `compare_exchange_weak`, but in most cases, `compare_exchange_strong` should be limited.
+   In this case we used `compare_exchange_strong`, which is the Compare-and-swap primitive, which has a weaker version, `compare_exchange_weak`, which allows a failure to be returned even if the exchange is successful. The reason is due to a false failure on some platforms, specifically when the CPU performs a context switch, another thread loads the same address to produce an inconsistency. In addition, the performance of `compare_exchange_strong` may be slightly worse than `compare_exchange_weak`, but in most cases, `compare_exchange_strong` should be limited.
-4. Sequential Consistent Model: Under this model, atomic operations satisfy sequence consistency, which in turn can cause performance loss. It can be specified explicitly by `std::memory_order_seq_cst`. Let's look a final example:
+4. Sequential Consistent Model: Under this model, atomic operations satisfy sequence consistency, which in turn can cause performance loss. It can be specified explicitly by `std::memory_order_seq_cst`. Let's look at a final example:
   ```cpp
   std::atomic<int> counter = {0};
   std::vector<std::thread> vt;
   for (int i = 0; i < 100; ++i) {
-        vt.emplace_back([](){
+       vt.emplace_back([&](){
           counter.fetch_add(1, std::memory_order_seq_cst);
       });
   }
@@ -511,12 +514,11 @@ In order to achieve the ultimate performance and achieve consistency of various
   This example is essentially the same as the first loose model example. Just change the memory order of the atomic operation to `memory_order_seq_cst`. Interested readers can write their own programs to measure the performance difference caused by these two different memory sequences.
 ## Conclusion
 The C++11 language layer provides support for concurrent programming. This section briefly introduces `std::thread`/`std::mutex`/`std::future`, an important tool that can't be avoided in concurrent programming.
 In addition, we also introduced the "memory model" as one of the most important features of C++11.
-They provide an critical foundation for standardized high performance computing for C++.
+They provide a critical foundation for standardized high-performance computing for C++.
 ## Exercises
--- a/book/en-us/09-others.md
+++ b/book/en-us/09-others.md
@@ -13,7 +13,7 @@ order: 9
 ### `long long int`
 `long long int` is not the first to be introduced in C++11.
-In fact, as early as C99, `long long int` has been included in the C standard, 
+As early as C99, `long long int` has been included in the C standard,
 so most compilers already support it.
 C++11 now formally incorporate it into the standard library,
 specifying a `long long int` type with at least 64 bits.
@@ -22,12 +22,10 @@ specifying a `long long int` type with at least 64 bits.
 One of the big advantages of C++ over C is that
 C++ itself defines a complete set of exception handling mechanisms.
-However, before C++11, almost no one used to write 
+However, before C++11, almost no one used to write an exception declaration expression after the function name.
 an exception declaration expression after the function name. 
 Starting from C++11, this mechanism was deprecated,
 so we will not discuss or introduce the previous mechanism.
-How to work and how to use it, you should not take the initiative 
+How to work and how to use it, you should not take the initiative to understand it.
 to understand it.
 C++11 simplifies exception declarations into two cases:
@@ -47,7 +45,7 @@ immediately terminate the program.
 `noexcept` can also be used as an operator to manipulate an expression.
 When the expression has no exception, it returns `true`,
-otherwise it returns `false`.
+otherwise, it returns `false`.
 ```cpp
 #include <iostream>
@@ -83,7 +81,7 @@ the external will not trigger. For instance:
 try {
    may_throw();
 } catch (...) {
-    std::cout << "exception captured from my_throw()" << std::endl;
+    std::cout << "exception captured from may_throw()" << std::endl;
 }
 try {
    non_block_throw();
@@ -100,7 +98,7 @@ try {
 The final output is:
 ```
-exception captured, from my_throw()
+exception captured, from may_throw()
 exception captured, from non_block_throw()
 ```
@@ -190,7 +188,7 @@ int main() {
 }
 ```
-where `std::max_align_t` requires exactly the same alignment for each scalar type, so it has almost no difference in maximum scalars.
+where `std::max_align_t` requires the same alignment for each scalar type, so it has almost no difference in maximum scalars.
 In turn, the result on most platforms is `long double`, so the alignment requirement for `AlignasStorage` we get here is 8 or 16.
 ## Conclusion
--- a/book/en-us/10-cpp20.md
+++ b/book/en-us/10-cpp20.md
@@ -13,14 +13,14 @@ For example, as early as C++11, the `Concept`,
 which was eager to call for high-altitude but ultimately lost, is now on the line.
 The C++ Organizing Committee decided to vote to finalize C++20 with many proposals,
 such as **Concepts**/**Module**/**Coroutine**/**Ranges**/ and so on.
-In this chapter we'll take a look at some of the important features that 
+In this chapter, we'll take a look at some of the important features that
 C++20 will introduce.
 ## Concept
-Concept is a further enhancement to C++ template programming. 
+The concept is a further enhancement to C++ template programming.
 In simple terms, the concept is a compile-time feature.
-It allows the compiler to evaluate template parameters at compile time, 
+It allows the compiler to evaluate template parameters at compile-time,
 greatly enhancing our experience with template programming in C++.
 When programming with templates, we often encounter a variety of heinous errors.
 This is because we have so far been unable to check and limit template parameters.
--- a/book/zh-cn/01-intro.md
+++ b/book/zh-cn/01-intro.md
@@ -25,6 +25,7 @@ InstalledDir: /Library/Developer/CommandLineTools/usr/bin
 > **注意**：弃用并非彻底不能用，只是用于暗示程序员这些特性将从未来的标准中消失，应该尽量避免使用。但是，已弃用的特性依然是标准库的一部分，并且出于兼容性的考虑，大部分特性其实会『永久』保留。
 - **不再允许字符串字面值常量赋值给一个 `char *`。如果需要用字符串字面值常量赋值和初始化一个 `char *`，应该使用 `const char *` 或者 `auto`。**
    ```cpp
    char *str = "hello world!"; // 将出现弃用警告
    ```
@@ -120,7 +121,7 @@ clean:
 > 注意：`Makefile` 中的缩进是制表符而不是空格符，如果你直接复制这段代码到你的编辑器中，制表符可能会被自动替换掉，请自行确保在 `Makefile` 中的缩进是由制表符完成的。
 >
-> 如果你还不知道 Makefile 的使用也没有关系，本教程中不会构建过于复杂的代码，简单的在命令行中使用 `clang++ -std=c++2a` 也可以阅读本书。
+> 如果你还不知道 `Makefile` 的使用也没有关系，本教程中不会构建过于复杂的代码，简单的在命令行中使用 `clang++ -std=c++2a` 也可以阅读本书。
 如果你是首次接触现代 C++，那么你很可能还看不懂上面的那一小段代码，即：
--- a/book/zh-cn/02-usability.md
+++ b/book/zh-cn/02-usability.md
@@ -14,7 +14,7 @@ order: 2
 ###  nullptr
-`nullptr` 出现的目的是为了替代 `NULL`。在某种意义上来说，传统 C++ 会把 `NULL`、`0` 视为同一种东西，这取决于编译器如何定义 NULL，有些编译器会将 NULL 定义为 `((void*)0)`，有些则会直接将其定义为 `0`。
+`nullptr` 出现的目的是为了替代 `NULL`。在某种意义上来说，传统 C++ 会把 `NULL`、`0` 视为同一种东西，这取决于编译器如何定义 `NULL`，有些编译器会将 `NULL` 定义为 `((void*)0)`，有些则会直接将其定义为 `0`。
 C++ **不允许**直接将 `void *` 隐式转换到其他类型。但如果编译器尝试把 `NULL` 定义为 `((void*)0)`，那么在下面这句代码中：
@@ -22,7 +22,7 @@ C++ **不允许**直接将 `void *` 隐式转换到其他类型。但如果编
 char *ch = NULL;
 ```
-没有了 `void *` 隐式转换的 C++ 只好将`NULL` 定义为 `0`。而这依然会产生新的问题，将 `NULL` 定义成 0 将导致 `C++` 中重载特性发生混乱。考虑下面这两个 `foo` 函数：
+没有了 `void *` 隐式转换的 C++ 只好将 `NULL` 定义为 `0`。而这依然会产生新的问题，将 `NULL` 定义成 `0` 将导致 `C++` 中重载特性发生混乱。考虑下面这两个 `foo` 函数：
 ```cpp
 void foo(char*);
@@ -31,9 +31,9 @@ void foo(int);
 那么 `foo(NULL);` 这个语句将会去调用 `foo(int)`，从而导致代码违反直觉。
-为了解决这个问题，C++11 引入了 `nullptr` 关键字，专门用来区分空指针、0。而 `nullptr` 的类型为 `nullptr_t`，能够隐式的转换为任何指针或成员指针的类型，也能和他们进行相等或者不等的比较。
+为了解决这个问题，C++11 引入了 `nullptr` 关键字，专门用来区分空指针、`0`。而 `nullptr` 的类型为 `nullptr_t`，能够隐式的转换为任何指针或成员指针的类型，也能和他们进行相等或者不等的比较。
-你可以尝试使用 clang++ 编译下面的代码：
+你可以尝试使用 `clang++` 编译下面的代码：
 ```cpp
 #include <iostream>
@@ -73,11 +73,11 @@ foo(char*) is called
 从输出中我们可以看出，`NULL` 不同于 `0` 与 `nullptr`。所以，请养成直接使用 `nullptr`的习惯。
-此外，在上面的代码中，我们使用了 `decltype` 和 `std::is_same` 这两个属于现代 C++ 的语法，简单来说，`decltype` 用于类型推导，而 `std::is_same` 用于比较两个类型是否相等，我们会在后面 [decltype](#decltype) 一节中详细讨论。
+此外，在上面的代码中，我们使用了 `decltype` 和 `std::is_same` 这两个属于现代 C++ 的语法，简单来说，`decltype` 用于类型推导，而 `std::is_same` 用于比较两个类型是否相同，我们会在后面 [decltype](#decltype) 一节中详细讨论。
 ### constexpr
-C++ 本身已经具备了常量表达式的概念，比如 1+2, 3*4 这种表达式总是会产生相同的结果并且没有任何副作用。如果编译器能够在编译时就把这些表达式直接优化并植入到程序运行时，将能增加程序的性能。一个非常明显的例子就是在数组的定义阶段：
+C++ 本身已经具备了常量表达式的概念，比如 `1+2`, `3*4` 这种表达式总是会产生相同的结果并且没有任何副作用。如果编译器能够在编译时就把这些表达式直接优化并植入到程序运行时，将能增加程序的性能。一个非常明显的例子就是在数组的定义阶段：
 ```cpp
 #include <iostream>
@@ -123,7 +123,7 @@ int main() {
 C++11 提供了 `constexpr` 让用户显式的声明函数或对象构造函数在编译期会成为常量表达式，这个关键字明确的告诉编译器应该去验证 `len_foo` 在编译期就应该是一个常量表达式。
-此外，`constexpr` 的函数可以使用递归：
+此外，`constexpr` 修饰的函数可以使用递归：
 ```cpp
 constexpr int fibonacci(const int n) {
@@ -131,7 +131,7 @@ constexpr int fibonacci(const int n) {
 }
 ```
-从 C++14 开始，constexpr 函数可以在内部使用局部变量、循环和分支等简单语句，例如下面的代码在 C++11 的标准下是不能够通过编译的：
+从 C++14 开始，`constexpr` 函数可以在内部使用局部变量、循环和分支等简单语句，例如下面的代码在 C++11 的标准下是不能够通过编译的：
 ```cpp
 constexpr int fibonacci(const int n) {
@@ -153,7 +153,7 @@ constexpr int fibonacci(const int n) {
 ### if/switch 变量声明强化
-在传统 C++ 中，变量的声明在虽然能够位于任何位置，甚至于 `for` 语句内能够声明一个临时变量 `int`，但始终没有办法在 `if` 和 `switch` 语句中声明一个临时的变量。例如：
+在传统 C++ 中，变量的声明虽然能够位于任何位置，甚至于 `for` 语句内能够声明一个临时变量 `int`，但始终没有办法在 `if` 和 `switch` 语句中声明一个临时的变量。例如：
 ```cpp
 #include <iostream>
@@ -181,7 +181,7 @@ int main() {
 }
 ```
-在上面的代码中，我们可以看到 `itr` 这一变量是定义在整个 `main()` 的作用域内的，这导致当我们需要再次遍历整个 `std::vectors` 时，需要重新命名另一个变量。C++17 消除了这一限制，使得我们可以在 if（或 switch）中完成这一操作：
+在上面的代码中，我们可以看到 `itr` 这一变量是定义在整个 `main()` 的作用域内的，这导致当我们需要再次遍历整个 `std::vectors` 时，需要重新命名另一个变量。C++17 消除了这一限制，使得我们可以在 `if`（或 `switch`）中完成这一操作：
 ```cpp
 // 将临时变量放到 if 语句内
@@ -232,6 +232,7 @@ int main() {
 ```cpp
 #include <initializer_list>
 #include <vector>
 class MagicFoo {
 public:
    std::vector<int> vec;
@@ -257,7 +258,8 @@ int main() {
 ```Cpp
 public:
    void foo(std::initializer_list<int> list) {
-            for (std::initializer_list<int>::iterator it = list.begin(); it != list.end(); ++it) vec.push_back(*it);
+        for (std::initializer_list<int>::iterator it = list.begin();
            it != list.end(); ++it) vec.push_back(*it);
    }
 magicFoo.foo({6,7,8,9});
@@ -277,6 +279,7 @@ C++17 完善了这一设定，给出的结构化绑定可以让我们写出这
 ```cpp
 #include <iostream>
 #include <tuple>
 std::tuple<int, double, std::string> f() {
    return std::make_tuple(1, 2.3, "456");
@@ -346,28 +349,32 @@ auto i = 5;              // i 被推导为 int
 auto arr = new auto(10); // arr 被推导为 int *
 ```
-> **注意**：`auto` 不能用于函数传参，因此下面的做法是无法通过编译的（考虑重载的问题，我们应该使用模板）：
+从 C++ 20 起，`auto` 甚至能用于函数传参，考虑下面的例子：
 ```cpp
 int add(auto x, auto y) {
    return x+y;
 }
 auto i = 5; // 被推导为 int
 auto j = 6; // 被推导为 int
 std::cout << add(i, j) << std::endl;
 ```
 >
 > **注意**：`auto` 还不能用于推导数组类型：
 >
 > ```cpp
-> int add(auto x, auto y);
+> auto auto_arr2[10] = {arr}; // 错误, 无法推导数组元素类型
 >
 > 2.6.auto.cpp:16:9: error: 'auto' not allowed in function prototype
 > int add(auto x, auto y) {
 >         ^~~~
 > ```
 >
 > 此外，`auto` 还不能用于推导数组类型：
 >
 > ```cpp
 > auto auto_arr2[10] = arr;   // 错误,  无法推导数组元素类型
 >
 > 2.6.auto.cpp:30:19: error: 'auto_arr2' declared as array of 'auto'
->     auto auto_arr2[10] = arr;
+>     auto auto_arr2[10] = {arr};
 > ```
 ### decltype
-`decltype` 关键字是为了解决 auto 关键字只能对变量进行类型推导的缺陷而出现的。它的用法和 `sizeof` 很相似：
+`decltype` 关键字是为了解决 `auto` 关键字只能对变量进行类型推导的缺陷而出现的。它的用法和 `typeof` 很相似：
 ```cpp
 decltype(表达式)
@@ -413,7 +420,7 @@ R add(T x, U y) {
 > 注意：typename 和 class 在模板参数列表中没有区别，在 typename 这个关键字出现之前，都是使用 class 来定义模板参数的。但在模板中定义有[嵌套依赖类型](http://en.cppreference.com/w/cpp/language/dependent_name#The_typename_disambiguator_for_dependent_names)的变量时，需要用 typename 消除歧义
-这样的代码其实变得很丑陋，因为程序员在使用这个模板函数的时候，必须明确指出返回类型。但事实上我们并不知道 `add()` 这个函数会做什么样的操作，获得一个什么样的返回类型。
+这样的代码其实变得很丑陋，因为程序员在使用这个模板函数的时候，必须明确指出返回类型。但事实上我们并不知道 `add()` 这个函数会做什么样的操作，以及获得一个什么样的返回类型。
 在 C++11 中这个问题得到解决。虽然你可能马上会反应出来使用 `decltype` 推导 `x+y` 的类型，写出这样的代码：
@@ -421,7 +428,7 @@ R add(T x, U y) {
 decltype(x+y) add(T x, U y)
 ```
-但事实上这样的写法并不能通过编译。这是因为在编译器读到 decltype(x+y) 时，`x` 和 `y` 尚未被定义。为了解决这个问题，C++11 还引入了一个叫做尾返回类型（trailing return type），利用 auto 关键字将返回类型后置：
+但事实上这样的写法并不能通过编译。这是因为在编译器读到 decltype(x+y) 时，`x` 和 `y` 尚未被定义。为了解决这个问题，C++11 还引入了一个叫做尾返回类型（trailing return type），利用 `auto` 关键字将返回类型后置：
 ```cpp
 template<typename T, typename U>
@@ -573,7 +580,7 @@ extern template class std::vector<double>; // 不在该当前编译文件中实
 std::vector<std::vector<int>> matrix;
 ```
-这在传统C++编译器下是不能够被编译的，而 C++11 开始，连续的右尖括号将变得合法，并且能够顺利通过编译。甚至于下下面这种写法都能够通过编译：
+这在传统 C++ 编译器下是不能够被编译的，而 C++11 开始，连续的右尖括号将变得合法，并且能够顺利通过编译。甚至于像下面这种写法都能够通过编译：
 ```cpp
 template<bool T>
@@ -617,28 +624,6 @@ int main() {
 }
 ```
 ### 默认模板参数
 我们可能定义了一个加法函数：
 ```cpp
 template<typename T, typename U>
 auto add(T x, U y) -> decltype(x+y) {
    return x+y;
 }
 ```
 但在使用时发现，要使用 add，就必须每次都指定其模板参数的类型。
 在 C++11 中提供了一种便利，可以指定模板的默认参数：
 ```cpp
 template<typename T = int, typename U = int>
 auto add(T x, U y) -> decltype(x+y) {
    return x+y;
 }
 ```
 ### 变长参数模板
 模板一直是 C++ 所独有的**黑魔法**（一起念：**Dark Magic**）之一。
@@ -659,9 +644,9 @@ class Magic<int,
            std::vector<int>>> darkMagic;
 ```
-既然是任意形式，所以个数为 0 的模板参数也是可以的：`class Magic<> nothing;`。
+既然是任意形式，所以个数为 `0` 的模板参数也是可以的：`class Magic<> nothing;`。
-如果不希望产生的模板参数个数为0，可以手动的定义至少一个模板参数：
+如果不希望产生的模板参数个数为 `0`，可以手动的定义至少一个模板参数：
 ```cpp
 template<typename Require, typename... Args> class Magic;
@@ -670,7 +655,7 @@ template<typename Require, typename... Args> class Magic;
 变长参数模板也能被直接调整到到模板函数上。传统 C 中的 `printf` 函数，
 虽然也能达成不定个数的形参的调用，但其并非类别安全。
 而 C++11 除了能定义类别安全的变长参数函数外，
-还可以使类似 printf 的函数能自然地处理非自带类别的对象。
+还可以使类似 `printf` 的函数能自然地处理非自带类别的对象。
 除了在模板参数中能使用 `...` 表示不定长模板参数外，
 函数参数也使用同样的表示法代表不定长参数，
 这也就为我们简单编写变长参数函数提供了便捷的手段，例如：
@@ -823,6 +808,7 @@ int main() {
 C++11 引入了委托构造的概念，这使得构造函数可以在同一个类中一个构造函数调用另一个构造函数，从而达到简化代码的目的：
 ```cpp
 #include <iostream>
 class Base {
 public:
    int value1;
@@ -844,9 +830,10 @@ int main() {
 ### 继承构造
-在传统 C++ 中，构造函数如果需要继承是需要将参数一一传递的，这将导致效率低下。C++11 利用关键字 using 引入了继承构造函数的概念：
+在传统 C++ 中，构造函数如果需要继承是需要将参数一一传递的，这将导致效率低下。C++11 利用关键字 `using` 引入了继承构造函数的概念：
 ```cpp
 #include <iostream>
 class Base {
 public:
    int value1;
@@ -971,14 +958,16 @@ if (new_enum::value3 == new_enum::value4) {
 }
 ```
-在这个语法中，枚举类型后面使用了冒号及类型关键字来指定枚举中枚举值的类型，这使得我们能够为枚举赋值（未指定时将默认使用 int）。
+在这个语法中，枚举类型后面使用了冒号及类型关键字来指定枚举中枚举值的类型，这使得我们能够为枚举赋值（未指定时将默认使用 `int`）。
 而我们希望获得枚举值的值时，将必须显式的进行类型转换，不过我们可以通过重载 `<<` 这个算符来进行输出，可以收藏下面这个代码段：
 ```cpp
 #include <iostream>
 template<typename T>
-std::ostream& operator<<(typename std::enable_if<std::is_enum<T>::value, std::ostream>::type& stream, const T& e)
+std::ostream& operator<<(
    typename std::enable_if<std::is_enum<T>::value,
        std::ostream>::type& stream, const T& e)
 {
    return stream << static_cast<typename std::underlying_type<T>::type>(e);
 }
@@ -994,8 +983,8 @@ std::cout << new_enum::value3 << std::endl
 本节介绍了现代 C++ 中对语言可用性的增强，其中笔者认为最为重要的几个特性是几乎所有人都需要了解并熟练使用的：
-1. auto 类型推导
+1. `auto` 类型推导
-2. 范围 for 迭代
+2. 范围 `for` 迭代
 3. 初始化列表
 4. 变参模板
--- a/book/zh-cn/03-runtime.md
+++ b/book/zh-cn/03-runtime.md
@@ -27,12 +27,12 @@ Lambda 表达式的基本语法如下：
 上面的语法规则除了 `[捕获列表]` 内的东西外，其他部分都很好理解，只是一般函数的函数名被略去，
 返回值使用了一个 `->` 的形式进行（我们在上一节前面的尾返回类型已经提到过这种写法了）。
-所谓捕获列表，其实可以理解为参数的一种类型，lambda 表达式内部函数体在默认情况下是不能够使用函数体外部的变量的，
+所谓捕获列表，其实可以理解为参数的一种类型，Lambda 表达式内部函数体在默认情况下是不能够使用函数体外部的变量的，
 这时候捕获列表可以起到传递外部数据的作用。根据传递的行为，捕获列表也分为以下几种：
 #### 1. 值捕获
-与参数传值类似，值捕获的前提是变量可以拷贝，不同之处则在于，被捕获的变量在 lambda 表达式被创建时拷贝，
+与参数传值类似，值捕获的前提是变量可以拷贝，不同之处则在于，被捕获的变量在 Lambda 表达式被创建时拷贝，
 而非调用时才拷贝：
 ```cpp
@@ -67,19 +67,19 @@ void lambda_reference_capture() {
 }
 ```
-**3. 隐式捕获**
+#### 3. 隐式捕获
 手动书写捕获列表有时候是非常复杂的，这种机械性的工作可以交给编译器来处理，这时候可以在捕获列表中写一个 
 `&` 或 `=` 向编译器声明采用引用捕获或者值捕获.
-总结一下，捕获提供了lambda 表达式对外部值进行使用的功能，捕获列表的最常用的四种形式可以是：
+总结一下，捕获提供了 Lambda 表达式对外部值进行使用的功能，捕获列表的最常用的四种形式可以是：
 - \[\] 空捕获列表
 - \[name1, name2, ...\] 捕获一系列变量
- \[&\] 引用捕获, 让编译器自行推导捕获列表
+- \[&\] 引用捕获, 让编译器自行推导引用列表
- \[=\] 值捕获, 让编译器执行推导应用列表
+- \[=\] 值捕获, 让编译器自行推导值捕获列表
-**4. 表达式捕获**
+#### 4. 表达式捕获
 > 这部分内容需要了解后面马上要提到的右值引用以及智能指针
@@ -90,20 +90,19 @@ C++14 给与了我们方便，允许捕获的成员用任意的表达式进行
 ```cpp
 #include <iostream>
-#include <utility>
+#include <memory>  // std::make_unique
 #include <utility> // std::move
-int main() {
+void lambda_expression_capture() {
    auto important = std::make_unique<int>(1);
    auto add = [v1 = 1, v2 = std::move(important)](int x, int y) -> int {
        return x+y+v1+(*v2);
    };
    std::cout << add(3,4) << std::endl;
    return 0;
 }
 ```
-在上面的代码中，`important` 是一个独占指针，是不能够被捕获到的，这时候我们需要将其转移为右值，
+在上面的代码中，important 是一个独占指针，是不能够被 "=" 值捕获到，这时候我们可以将其转移为右值，在表达式中初始化。
 在表达式中初始化。
 ### 泛型 Lambda
@@ -225,6 +224,22 @@ int main() {
 要么是求值结果相当于字面量或匿名临时对象，例如 `1+2`。非引用返回的临时变量、运算表达式产生的临时变量、
 原始字面量、Lambda 表达式都属于纯右值。
 需要注意的是，字符串字面量只有在类中才是右值，当其位于普通函数中是左值。例如：
 ```cpp
 class Foo {
        const char*&& right = "this is a rvalue"; // 此处字符串字面量为右值
 public:
        void bar() {
            right = "still rvalue"; // 此处字符串字面量为右值
        } 
 };
 int main() {
    const char* const &left = "this is an lvalue"; // 此处字符串字面量为左值
 }
 ```
 **将亡值(xvalue, expiring value)**，是 C++11 为了引入右值引用而提出的概念（因此在传统 C++ 中，
 纯右值和右值是同一个概念），也就是即将被销毁、却能够被移动的值。
@@ -240,7 +255,7 @@ std::vector<int> v = foo();
 ```
 在这样的代码中，就传统的理解而言，函数 `foo` 的返回值 `temp` 在内部创建然后被赋值给 `v`，
-然而 `v` 获得这个对象时，会将整个 temp 拷贝一份，然后把 `temp` 销毁，如果这个 `temp` 非常大，
+然而 `v` 获得这个对象时，会将整个 `temp` 拷贝一份，然后把 `temp` 销毁，如果这个 `temp` 非常大，
 这将造成大量额外的开销（这也就是传统 C++ 一直被诟病的问题）。在最后一行中，`v` 是左值、
 `foo()` 返回的值就是右值（也是纯右值）。但是，`v` 可以被别的变量捕获到，
 而 `foo()` 产生的那个返回值作为一个临时值，一旦被 `v` 复制后，将立即被销毁，无法获取、也不能修改。
@@ -252,7 +267,7 @@ std::vector<int> v = foo();
 ### 右值引用和左值引用
-需要拿到一个将亡值，就需要用到右值引用的申明：`T &&`，其中 `T` 是类型。
+要拿到一个将亡值，就需要用到右值引用：`T &&`，其中 `T` 是类型。
 右值引用的声明让这个临时值的生命周期得以延长、只要变量还活着，那么将亡值将继续存活。
 C++11 提供了 `std::move` 这个方法将左值参数无条件的转换为右值，
@@ -470,7 +485,7 @@ void pass(T&& v) {
    std::cout << "    std::forward 传参: ";
    reference(std::forward<T>(v));
    std::cout << "static_cast<T&&> 传参: ";
-    reference(std::forward<T>(v));
+    reference(static_cast<T&&>(v));
 }
 int main() {
    std::cout << "传递右值:" << std::endl;
@@ -529,12 +544,12 @@ constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type&& __t) noexcep
 而 `std::is_lvalue_reference` 用于检查类型推导是否正确，在 `std::forward` 的第二个实现中
 检查了接收到的值确实是一个左值，进而体现了坍缩规则。
-当 `std::forward` 接受左值时，`_Tp` 被推导为左值，而所以返回值为左值；而当其接受右值时，
+当 `std::forward` 接受左值时，`_Tp` 被推导为左值，所以返回值为左值；而当其接受右值时，
 `_Tp` 被推导为 右值引用，则基于坍缩规则，返回值便成为了 `&& + &&` 的右值。
 可见 `std::forward` 的原理在于巧妙的利用了模板类型推导中产生的差异。
 这时我们能回答这样一个问题：为什么在使用循环语句的过程中，`auto&&` 是最安全的方式？
-因为当 `auto` 被推到为不同的左右引用时，与 `&&` 的坍缩组合是完美转发。
+因为当 `auto` 被推导为不同的左右引用时，与 `&&` 的坍缩组合是完美转发。
 ## 总结
--- a/book/zh-cn/04-containers.md
+++ b/book/zh-cn/04-containers.md
@@ -292,7 +292,7 @@ auto tuple_len(T &tpl) {
 // 迭代
 for(int i = 0; i != tuple_len(new_tuple); ++i)
    // 运行期索引
-    std::cout << tuple_index(i, new_tuple) << std::endl;
+    std::cout << tuple_index(new_tuple, i) << std::endl;
 ```
 ## 总结
--- a/book/zh-cn/05-pointers.md
+++ b/book/zh-cn/05-pointers.md
@@ -27,7 +27,7 @@ order: 5
 ## 5.2 `std::shared_ptr`
-`std::shared_ptr` 是一种智能指针，它能够记录多少个 `shared_ptr` 共同指向一个对象，从而消除显示的调用 
+`std::shared_ptr` 是一种智能指针，它能够记录多少个 `shared_ptr` 共同指向一个对象，从而消除显式的调用 
 `delete`，当引用计数变为零的时候就会将对象自动删除。
 但还不够，因为使用 `std::shared_ptr` 仍然需要使用 `new` 来调用，这使得代码出现了某种程度上的不对称。
@@ -38,12 +38,10 @@ order: 5
 ```cpp
 #include <iostream>
 #include <memory>
-void foo(std::shared_ptr<int> i)
+void foo(std::shared_ptr<int> i) {
 {
    (*i)++;
 }
-int main()
+int main() {
 {
    // auto pointer = new int(10); // illegal, no direct assignment
    // Constructed a std::shared_ptr
    auto pointer = std::make_shared<int>(10);
@@ -148,20 +146,20 @@ struct B;
 struct A {
    std::shared_ptr<B> pointer;
    ~A() {
-        std::cout << "A 被销毁" << std::end;
+        std::cout << "A 被销毁" << std::endl;
    }
 };
 struct B {
    std::shared_ptr<A> pointer;
    ~B() {
-        std::cout << "B 被销毁" << std::end;
+        std::cout << "B 被销毁" << std::endl;
    }
 };
 int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
-    a.pointer = b;
+    a->pointer = b;
-    b.pointer = a;
+    b->pointer = a;
 }
 ```
@@ -175,7 +173,7 @@ int main() {
 在上图中，最后一步只剩下 B，而 B 并没有任何智能指针引用它，因此这块内存资源也会被释放。
-`std::weak_ptr` 没有 `*` 运算符和 `->` 运算符，所以不能够对资源进行操作，它的唯一作用就是用于检查 `std::shared_ptr` 是否存在，其 `expired()` 方法能在资源未被释放时，会返回 `true`，否则返回 `false`。
+`std::weak_ptr` 没有 `*` 运算符和 `->` 运算符，所以不能够对资源进行操作，它的唯一作用就是用于检查 `std::shared_ptr` 是否存在，其 `expired()` 方法能在资源未被释放时，会返回 `false`，否则返回 `true`。
 ## 总结
--- a/book/zh-cn/06-regex.md
+++ b/book/zh-cn/06-regex.md
@@ -42,7 +42,7 @@ order: 6
 | `\`|  将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， `n` 匹配字符 `n`。`\n` 匹配换行符。序列 `\\` 匹配 `'\'` 字符，而 `\(` 则匹配 `'('` 字符。|
 |`^`|  匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。|
 |`{`|  标记限定符表达式的开始。|
-|`\`|  指明两项之间的一个选择。|
+|`\|`|  指明两项之间的一个选择。|
 ### 限定符
--- a/book/zh-cn/07-thread.md
+++ b/book/zh-cn/07-thread.md
@@ -33,9 +33,9 @@ C++11 引入了 `mutex` 相关的类，其所有相关的函数都放在 `<mutex
 `std::mutex` 是 C++11 中最基本的 `mutex` 类，通过实例化 `std::mutex` 可以创建互斥量，
 而通过其成员函数 `lock()` 可以进行上锁，`unlock()` 可以进行解锁。
-但是在在实际编写代码的过程中，最好不去直接调用成员函数，
+但是在实际编写代码的过程中，最好不去直接调用成员函数，
 因为调用成员函数就需要在每个临界区的出口处调用 `unlock()`，当然，还包括异常。
-这时候 C++11 还为互斥量提供了一个 RAII 语法的模板类 `std::lock_gurad`。
+这时候 C++11 还为互斥量提供了一个 RAII 语法的模板类 `std::lock_guard`。
 RAII 在不失代码简洁性的同时，很好的保证了代码的异常安全性。
 在 RAII 用法下，对于临界区的互斥量的创建只需要在作用域的开始部分，例如：
@@ -66,7 +66,7 @@ int main() {
 }
 ```
-由于 C++ 保证了所有栈对象在声明周期结束时会被销毁，所以这样的代码也是异常安全的。
+由于 C++ 保证了所有栈对象在生命周期结束时会被销毁，所以这样的代码也是异常安全的。
 无论 `critical_section()` 正常返回、还是在中途抛出异常，都会引发堆栈回退，也就自动调用了 `unlock()`。
 而 `std::unique_lock` 则相对于 `std::lock_guard` 出现的，`std::unique_lock` 更加灵活，
@@ -261,7 +261,7 @@ int main() {
 从直观上看，`t2` 中 `a = 5;` 这一条语句似乎总在 `flag = 1;` 之前得到执行，而 `t1` 中 `while (flag != 1)` 
 似乎保证了 `std::cout << "b = " << b << std::endl;` 不会再标记被改变前执行。从逻辑上看，似乎 `b` 的值应该等于 5。
 但实际情况远比此复杂得多，或者说这段代码本身属于未定义的行为，因为对于 `a` 和 `flag` 而言，他们在两个并行的线程中被读写，
-出现了竞争。除此之外，即便我们忽略竞争读写，仍然可能收 CPU 的乱序执行，编译器对指令的重排的影响，
+出现了竞争。除此之外，即便我们忽略竞争读写，仍然可能受 CPU 的乱序执行，编译器对指令的重排的影响，
 导致 `a = 5` 发生在 `flag = 1` 之后。从而 `b` 可能输出 0。
 ### 原子操作
@@ -321,6 +321,8 @@ struct A {
    int y;
    long long z;
 };
 int main() {
    std::atomic<A> a;
    std::cout << std::boolalpha << a.is_lock_free() << std::endl;
    return 0;
@@ -437,7 +439,7 @@ struct A {
    std::atomic<int> counter = {0};
    std::vector<std::thread> vt;
    for (int i = 0; i < 100; ++i) {
-        vt.emplace_back([](){
+        vt.emplace_back([&](){
            counter.fetch_add(1, std::memory_order_relaxed);
        });
    }
@@ -451,7 +453,8 @@ struct A {
 2. 释放/消费模型：在此模型中，我们开始限制进程间的操作顺序，如果某个线程需要修改某个值，但另一个线程会对该值的某次操作产生依赖，即后者依赖前者。具体而言，线程 A 完成了三次对 `x` 的写操作，线程 `B` 仅依赖其中第三次 `x` 的写操作，与 `x` 的前两次写行为无关，则当 `A` 主动 `x.release()` 时候（即使用 `std::memory_order_release`），选项 `std::memory_order_consume` 能够确保 `B` 在调用 `x.load()` 时候观察到 `A` 中第三次对 `x` 的写操作。我们来看一个例子：
    ```cpp
-    std::atomic<int*> ptr;
+    // 初始化为 nullptr 防止 consumer 线程从野指针进行读取
    std::atomic<int*> ptr(nullptr);
    int v;
    std::thread producer([&]() {
        int* p = new int(42);
@@ -469,9 +472,9 @@ struct A {
    consumer.join();
    ```
-3. 释放/获取模型：在此模型下，我们可以进一步加紧对不同线程间原子操作的顺序的限制，在释放 `std::memory_order_release` 和获取 `std::memory_order_acquire` 之间规定时序，即发生在释放操作之前的**所有**写操作，对其他线程的任何获取操作都是可见的，亦即发生顺序（happens-before）。
+3. 释放/获取模型：在此模型下，我们可以进一步加紧对不同线程间原子操作的顺序的限制，在释放 `std::memory_order_release` 和获取 `std::memory_order_acquire` 之间规定时序，即发生在释放（release）操作之前的**所有**写操作，对其他线程的任何获取（acquire）操作都是可见的，亦即发生顺序（happens-before）。
-    可以看到，`std::memory_order_release` 确保了它之后的写行为不会发生在释放操作之前，是一个向后的屏障，而 `std::memory_order_acquire` 确保了它之后的前的写行为，不会发生在该获取操作之后，是一个向前的屏障，对于选项 `std::memory_order_acq_rel` 而言，则结合了这两者的特点，唯一确定了一个内存屏障，使得当前线程对内存的读写不会被重排到此操作的前后。
+    可以看到，`std::memory_order_release` 确保了它之前的写操作不会发生在释放操作之后，是一个向后的屏障（backward），而 `std::memory_order_acquire` 确保了它之前的写行为不会发生在该获取操作之后，是一个向前的屏障（forward）。对于选项 `std::memory_order_acq_rel` 而言，则结合了这两者的特点，唯一确定了一个内存屏障，使得当前线程对内存的读写不会被重排并越过此操作的前后：
    我们来看一个例子：
@@ -507,7 +510,7 @@ struct A {
    std::atomic<int> counter = {0};
    std::vector<std::thread> vt;
    for (int i = 0; i < 100; ++i) {
-        vt.emplace_back([](){
+        vt.emplace_back([&](){
            counter.fetch_add(1, std::memory_order_seq_cst);
        });
    }
--- a/book/zh-cn/09-others.md
+++ b/book/zh-cn/09-others.md
@@ -72,7 +72,7 @@ int main()
 try {
    may_throw();
 } catch (...) {
-    std::cout << "捕获异常, 来自 my_throw()" << std::endl;
+    std::cout << "捕获异常, 来自 may_throw()" << std::endl;
 }
 try {
    non_block_throw();
@@ -89,7 +89,7 @@ try {
 最终输出为：
 ```
-捕获异常, 来自 my_throw()
+捕获异常, 来自 may_throw()
 捕获异常, 来自 non_block_throw()
 ```
--- a/code/2/2.01.nullptr.cpp
+++ b/code/2/2.01.nullptr.cpp
@@ -22,7 +22,7 @@ int main() {
        std::cout << "NULL == nullptr" << std::endl;
    foo(0);          // will call foo(int)
-    // foo(NULL);    // doen't compile
+    // foo(NULL);    // doesn't compile
    foo(nullptr);    // will call foo(char*)
    return 0;
 }
--- a/code/2/2.06.auto.cpp
+++ b/code/2/2.06.auto.cpp
@@ -21,10 +21,9 @@ public:
    }
 };
-// wrong
+int add(auto x, auto y) { // Supported in C++20
-// int add(auto x, auto y) {
+    return x+y;
-//     return x+y;
+}
 // }
 int main() {
    MagicFoo magicFoo = {1, 2, 3, 4, 5};
@@ -36,8 +35,9 @@ int main() {
    auto i = 5;                    // type int
    auto j = 6;                    // type int
    std::cout << add(i, j) << std::endl;
    auto arr = new auto(10);       // type int*
-    // auto auto_arr2[10] = arr;
+    // auto auto_arr2[10] = {arr}; // invalid
    // std::cout << add(i, j) << std::endl;
    return 0;
 }
--- a/code/3/3.1.lambda.basic.cpp
+++ b/code/3/3.1.lambda.basic.cpp
@@ -9,7 +9,8 @@
 #include <iostream>
-#include <utility>
+#include <memory>  // std::make_unique
 #include <utility> // std::move
 void lambda_value_capture() {
    int value = 1;
--- a/code/5/5.2.unique.ptr.cpp
+++ b/code/5/5.2.unique.ptr.cpp
@@ -41,10 +41,10 @@ int main() {
        // p2 is empty, no prints
        if(p2) p2->foo();
-        std::cout << "p2 was destroied" << std::endl;
+        std::cout << "p2 was destroyed" << std::endl;
    }
    // p1 is not empty, prints
    if (p1) p1->foo();
-    // Foo instance will be destroied when leaving the scope
+    // Foo instance will be destroyed when leaving the scope
 }
--- a/code/5/5.3.weak.ptr.cpp
+++ b/code/5/5.3.weak.ptr.cpp
@@ -18,14 +18,14 @@ class A {
 public:
    std::shared_ptr<B> pointer;
    ~A() {
-        std::cout << "A was destroied" << std::endl;
+        std::cout << "A was destroyed" << std::endl;
    }
 };
 class B {
 public:
    std::shared_ptr<A> pointer;
    ~B() {
-        std::cout << "B was destroied" << std::endl;
+        std::cout << "B was destroyed" << std::endl;
    }
 };
 int main() {
--- a/code/7/7.8.memory.order.cpp
+++ b/code/7/7.8.memory.order.cpp
@@ -15,15 +15,15 @@
 using namespace std;
 using namespace std::chrono;
 atomic<int> counter = {0};
 const int N = 10000;
 void relaxed_order() {
    cout << "relaxed_order: " << endl;
    atomic<int> counter = {0};
    vector<thread> vt;
    for (int i = 0; i < N; ++i) {
-        vt.emplace_back([](){
+        vt.emplace_back([&](){
            counter.fetch_add(1, memory_order_relaxed);
        });
    }
@@ -86,9 +86,10 @@ void release_acquire_order() {
 void sequential_consistent_order() {
    cout << "sequential_consistent_order: " << endl;
    atomic<int> counter = {0};
    vector<thread> vt;
    for (int i = 0; i < N; ++i) {
-        vt.emplace_back([](){
+        vt.emplace_back([&](){
            counter.fetch_add(1, memory_order_seq_cst);
        });
    }
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -1,10 +1,10 @@
 FROM node:latest
-LABEL "maintainer"="Changkun Ou <hi@changkun.us>"
+LABEL "maintainer"="Changkun Ou <hi[at]changkun.de>"
 LABEL "repository"="https://github.com/changkun/modern-cpp-tutorial"
 LABEL "homepage"="https://changkun.de/modern-cpp/"
-# FUCKING UNICODE
+# For Unicode
 ENV LANG C.UTF-8
 ENV LC_ALL C.UTF-8
--- a/epub/en-us/Makefile
+++ b/epub/en-us/Makefile
@@ -0,0 +1,51 @@
 title = 'Modern C++ Tutorial: C++11/14/17/20 On the Fly'
 filename = 'modern-cpp-tutorial'
 outputname='modern-cpp-tutorial'
 revision = $(shell git describe --always --tags)
 date = $(shell date +'%Y.%m.%d-%H:%M')
 all: revision epub
 revision:
 	@echo '---' >> meta.markdown
 	@echo 'title: "Modern C++ Tutorial: C++11/14/17/20 On the Fly"' >> meta.markdown
 	@echo 'author: Changkun Ou <hi[at]changkun.de>' >> meta.markdown
 	@echo 'subtitle: |' >> meta.markdown
 	@echo '  The content in this PDF file may outdated, please check our website <https://changkun.de/modern-cpp> or GitHub repository <https://github.com/changkun/modern-cpp-tutorial> for the latest book updates. Last update: ${date}' >> meta.markdown
 	@echo 'rights: © Ou Changkun, CC BY-NC-ND 4.0.' >> meta.markdown
 	@echo 'ibooks:' >> meta.markdown
 	@echo '  - version: ${revision}' >> meta.markdown
 	@echo '---' >> meta.markdown
 epub: markdown
 	@echo "Compiling PDF file..."
 	pandoc -f markdown+smart --toc -t epub -o $(filename).epub \
 		--highlight-style haddock \
 		--epub-cover-image ../../assets/cover-2nd-en.png \
 		--title-prefix $(title) \
 		meta.markdown \
 		00-preface.md.markdown \
 		01-intro.md.markdown \
 		02-usability.md.markdown \
 		03-runtime.md.markdown \
 		04-containers.md.markdown \
 		05-pointers.md.markdown \
 		06-regex.md.markdown \
 		07-thread.md.markdown \
 		08-filesystem.md.markdown \
 		09-others.md.markdown \
 		10-cpp20.md.markdown \
 		appendix1.md.markdown \
 		appendix2.md.markdown
 	@echo "Done."
 	rm -f *.md *.markdown
 markdown:
 	@echo "Copy markdown files..."
 	cp -r ../../book/en-us/* .
 	@echo "Aggregating markdown files..."
 	python3 filter.py
 clean:
 	rm -rf *.md *.markdown
 .PHONY: markdown epub clean
--- a/epub/en-us/filter.py
+++ b/epub/en-us/filter.py
@@ -0,0 +1,19 @@
 # !/usr/bin/env python3
 # author: changkun<hi[at]changkun.de>
 import os
 chapters = ['00-preface.md', '01-intro.md',  '02-usability.md', '03-runtime.md', '04-containers.md', '05-pointers.md', '06-regex.md', '07-thread.md', '08-filesystem.md', '09-others.md', '10-cpp20.md', 'appendix1.md', 'appendix2.md']
 ignores = ['TOC', 'Table of Content', 'License', 'license']
 for chapter in chapters:
    with open(chapter+'.markdown', 'w') as outfile:
        if os.path.isfile(chapter):
            with open(chapter) as ch:
                outfile.write('\n')
                for line in ch:
                    if any(keyword in line for keyword in ignores):
                        continue
                    else:
                        outfile.write(line)
--- a/epub/zh-cn/Makefile
+++ b/epub/zh-cn/Makefile
@@ -0,0 +1,51 @@
 title = '现代 C++ 教程：高速上手 C++11/14/17/20'
 filename = 'modern-cpp-tutorial'
 outputname='modern-cpp-tutorial'
 revision = $(shell git describe --always --tags)
 date = $(shell date +'%Y.%m.%d-%H:%M')
 all: revision epub
 revision:
 	@echo '---' >> meta.markdown
 	@echo 'title: "现代 C++ 教程：高速上手 C++11/14/17/20"' >> meta.markdown
 	@echo 'author: 欧长坤 <hi[at]changkun.de>' >> meta.markdown
 	@echo 'subtitle: |' >> meta.markdown
 	@echo '  此文件的内容可能过期，请检查本书网站 <https://changkun.de/modern-cpp> 及 GitHub 仓库<https://github.com/changkun/modern-cpp-tutorial> 以获取最新内容。最后更新：${date}' >> meta.markdown
 	@echo 'rights: © Ou Changkun, CC BY-NC-ND 4.0.' >> meta.markdown
 	@echo 'ibooks:' >> meta.markdown
 	@echo '  - version: ${revision}' >> meta.markdown
 	@echo '---' >> meta.markdown
 epub: markdown
 	@echo "Compiling PDF file..."
 	pandoc -f markdown+smart --toc -t epub -o $(filename).epub \
 		--highlight-style haddock \
 		--epub-cover-image ../../assets/cover-2nd.png \
 		--title-prefix $(title) \
 		meta.markdown \
 		00-preface.md.markdown \
 		01-intro.md.markdown \
 		02-usability.md.markdown \
 		03-runtime.md.markdown \
 		04-containers.md.markdown \
 		05-pointers.md.markdown \
 		06-regex.md.markdown \
 		07-thread.md.markdown \
 		08-filesystem.md.markdown \
 		09-others.md.markdown \
 		10-cpp20.md.markdown \
 		appendix1.md.markdown \
 		appendix2.md.markdown
 	@echo "Done."
 	rm -f *.md *.markdown
 markdown:
 	@echo "Copy markdown files..."
 	cp -r ../../book/zh-cn/* .
 	@echo "Aggregating markdown files..."
 	python3 filter.py
 clean:
 	rm -rf *.md *.markdown
 .PHONY: markdown epub clean
--- a/epub/zh-cn/filter.py
+++ b/epub/zh-cn/filter.py
@@ -0,0 +1,19 @@
 # !/usr/bin/env python3
 # author: changkun<hi[at]changkun.de>
 import os
 chapters = ['00-preface.md', '01-intro.md',  '02-usability.md', '03-runtime.md', '04-containers.md', '05-pointers.md', '06-regex.md', '07-thread.md', '08-filesystem.md', '09-others.md', '10-cpp20.md', 'appendix1.md', 'appendix2.md']
 ignores = ['TOC', '返回目录', '许可', 'license']
 for chapter in chapters:
    with open(chapter+'.markdown', 'w') as outfile:
        if os.path.isfile(chapter):
            with open(chapter) as ch:
                outfile.write('\n')
                for line in ch:
                    if any(keyword in line for keyword in ignores):
                        continue
                    else:
                        outfile.write(line)
--- a/exercises/7/7.1/thread_pool.hpp
+++ b/exercises/7/7.1/thread_pool.hpp
@@ -109,7 +109,7 @@ decltype(auto) ThreadPool::enqueue(F&& f, Args&&... args) {
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
-        // avoid add new thread if theadpool is destroied
+        // avoid add new thread if theadpool is destroyed
        if(stop)
            throw std::runtime_error("enqueue on stopped ThreadPool");
--- a/pdf/en-us/Makefile
+++ b/pdf/en-us/Makefile
@@ -6,14 +6,13 @@ revision = $(shell git describe --always --tags)
 all: revision pdf
 revision:
-	@echo '% Autogenerated, do not edit' > revision.tex
+	printf '%% Autogenerated, do not edit\n' > revision.tex
-	@echo '\\newcommand{\\revision}{'$(revision)'}' >> revision.tex
+	printf '\\newcommand{\\revision}{'$(revision)'}' >> revision.tex
 pdf: markdown
 	@echo "Compiling PDF file..."
 	pandoc -f markdown+smart -s $(filename).md -o $(filename).pdf \
 		--title-prefix $(title) \
 		--listings -H meta/cpp-listings.tex \
 		--template=meta/template.tex \
 		--pdf-engine=`which xelatex`
 	@echo "Done."
--- a/pdf/en-us/aggregator.py
+++ b/pdf/en-us/aggregator.py
@@ -1,5 +1,5 @@
 # !/usr/bin/env python3
-# author: changkun<hi@changkun.us>
+# author: changkun<hi[at]changkun.de>
 import os
@@ -11,7 +11,7 @@ ignores = ['TOC', 'Table of Content', 'License', 'license']
 with open('modern-cpp-tutorial.md', 'w') as outfile:
    outfile.write("""---
 title: "Modern C++ Tutorial: C++11/14/17/20 On the Fly"
-author: Changkun Ou <hi@changkun.us>
+author: Changkun Ou <hi[at]changkun.de>
 copyright: cc-by-nc-nd 4.0
 ---
 """)
--- a/pdf/en-us/meta/cpp-listings.tex
+++ b/pdf/en-us/meta/cpp-listings.tex
@@ -1,26 +0,0 @@
 \usepackage{xcolor}
 \definecolor{keyword}{HTML}{BA2CA3}
 \definecolor{string}{HTML}{D12F1B}
 \definecolor{comment}{HTML}{008400}
 \lstset{
  basicstyle={\small\ttfamily},
  keywordstyle={\color[rgb]{0.13,0.29,0.53}\bfseries},
  breaklines=true,
  emphstyle={\bfseries\color{Rhodamine}},
  commentstyle={\color[rgb]{0.56,0.35,0.01}\itshape},
  stringstyle={\color[rgb]{0.31,0.60,0.02}},
  showstringspaces=false,
  frame=shadowbox,
  breakatwhitespace=false,
  captionpos=b,
  extendedchars=true,
  keepspaces=true,
  numbers=left,
  numberstyle=\tiny,
  rulecolor=\color{black},
  rulesepcolor={\color{blue!20!white}},
  showspaces=false,
 }
--- a/pdf/en-us/meta/template.tex
+++ b/pdf/en-us/meta/template.tex
@@ -47,9 +47,7 @@ $if(biblio-files)$
 \bibliography{$biblio-files$}
 $endif$
 $endif$
 $if(listings)$
 \usepackage{listings}
 $endif$
 $if(lhs)$
 \lstnewenvironment{code}{\lstset{language=Haskell,basicstyle=\small\ttfamily}}{}
 $endif$
@@ -161,7 +159,7 @@ $endif$
  {\LARGE\textbf{Modern C++ Tutorial: C++11/14/17/20 On the Fly}}
  \vspace{1em}
-  {\large Changkun Ou (hi@changkun.us)}
+  {\large Changkun Ou (hi[at]changkun.de)}
  \vspace{1ex}
  Last update: \today
--- a/pdf/zh-cn/Makefile
+++ b/pdf/zh-cn/Makefile
@@ -6,14 +6,13 @@ revision = $(shell git describe --always --tags)
 all: revision pdf
 revision:
-	@echo '% Autogenerated, do not edit' > revision.tex
+	printf '%% Autogenerated, do not edit\n' > revision.tex
-	@echo '\\newcommand{\\revision}{'$(revision)'}' >> revision.tex
+	printf '\\newcommand{\\revision}{'$(revision)'}' >> revision.tex
 pdf: markdown
 	@echo "Compiling PDF file..."
 	pandoc -f markdown+smart -s $(filename).md -o $(filename).pdf \
 		--title-prefix $(title) \
 		--listings -H meta/cpp-listings.tex \
 		--template=meta/template.tex \
 		--pdf-engine=`which xelatex`
 	@echo "Done."
--- a/pdf/zh-cn/aggregator.py
+++ b/pdf/zh-cn/aggregator.py
@@ -1,5 +1,5 @@
 # !/usr/bin/env python3
-# author: changkun<hi@changkun.us>
+# author: changkun<hi[at]changkun.de>
 import os, io
@@ -9,7 +9,7 @@ ignores = ['TOC', '返回目录', '许可', 'license']
 head = """---
 title: "现代 C++ 教程：高速上手 C++11/14/17/20"
-author: 欧长坤 <hi@changkun.us>
+author: 欧长坤 <hi[at]changkun.de>
 copyright: cc-by-nc-nd 4.0
 ---
 """
--- a/pdf/zh-cn/meta/cpp-listings.tex
+++ b/pdf/zh-cn/meta/cpp-listings.tex
@@ -1,26 +0,0 @@
 \usepackage{xcolor}
 \definecolor{keyword}{HTML}{BA2CA3}
 \definecolor{string}{HTML}{D12F1B}
 \definecolor{comment}{HTML}{008400}
 \lstset{
  basicstyle={\small\ttfamily},
  keywordstyle={\color[rgb]{0.13,0.29,0.53}\bfseries},
  breaklines=true,
  emphstyle={\bfseries\color{Rhodamine}},
  commentstyle={\color[rgb]{0.56,0.35,0.01}\itshape},
  stringstyle={\color[rgb]{0.31,0.60,0.02}},
  showstringspaces=false,
  frame=shadowbox,
  breakatwhitespace=false,
  captionpos=b,
  extendedchars=true,
  keepspaces=true,
  numbers=left,
  numberstyle=\tiny,
  rulecolor=\color{black},
  rulesepcolor={\color{blue!20!white}},
  showspaces=false,
 }
--- a/pdf/zh-cn/meta/template.tex
+++ b/pdf/zh-cn/meta/template.tex
@@ -51,9 +51,8 @@ $if(biblio-files)$
 \bibliography{$biblio-files$}
 $endif$
 $endif$
-$if(listings)$
+\usepackage{textcomp}
 \usepackage{listings}
 $endif$
 $if(lhs)$
 \lstnewenvironment{code}{\lstset{language=Haskell,basicstyle=\small\ttfamily}}{}
 $endif$
@@ -167,7 +166,7 @@ $endif$
  {\LARGE\textbf{现代 C++ 教程：高速上手 C++11/14/17/20}}
  \vspace{1em}
-  {\large 欧长坤 (hi@changkun.us)}
+  {\large 欧长坤 (hi[at]changkun.de)}
  \vspace{1ex}
  最后更新 \today - \revision
--- a/website/Makefile
+++ b/website/Makefile
@@ -2,12 +2,12 @@ all: clean
 	node install.js
 	python3 filter.py
 	cp ../assets/cover-2nd.png ./src/modern-cpp/assets/cover-2nd.png
 	cp ../assets/cover-2nd-logo.png ./src/modern-cpp/assets/cover-2nd-logo.png
 	cp ../assets/cover-2nd-en.png ./src/modern-cpp/assets/cover-2nd-en.png
 	cp ../assets/cover-2nd-en-logo.png ./src/modern-cpp/assets/cover-2nd-en-logo.png
 	cp ../assets/alipay.jpg ./src/modern-cpp/assets/alipay.jpg
 	cp ../assets/wechat.jpg ./src/modern-cpp/assets/wechat.jpg
 	cp ../assets/qq-group.png ./src/modern-cpp/assets/qq-group.png
 	cp ../assets/donate.md ./src/modern-cpp/about/
 	cp ../assets/community.md ./src/modern-cpp/about/
 	cp -r ../assets/figures ./src/modern-cpp/assets/figures
 	cp -r ../exercises ./src/modern-cpp/
 	cp -r ../code ./src/modern-cpp/
@@ -17,11 +17,13 @@ s: all
 	node_modules/serve/bin/serve.js ./public
 clean:
 	rm -rf ./src/modern-cpp/assets/cover-2nd.png \
 		./src/modern-cpp/assets/cover-2nd-en.png \
 		./src/modern-cpp/assets/cover-2nd-logo.png \
 		./src/modern-cpp/assets/cover-2nd-en-logo.png \
 		./src/modern-cpp/assets/figures \
 		./src/modern-cpp/assets/alipay.jpg \
 		./src/modern-cpp/assets/wechat.jpg \
 		./src/modern-cpp/about/donate.md \
 		./src/modern-cpp/about/community.md \
 		./src/modern-cpp/code \
 		./src/modern-cpp/exercises \
 		public db.json src/modern-cpp/zh-cn src/modern-cpp/en-us
--- a/website/_config.yml
+++ b/website/_config.yml
@@ -3,7 +3,7 @@ title: "现代 C++ 教程: 高速上手 C++ 11/14/17/20"
 subtitle: C++ 11/14/17/20 On the Fly
 description: "欧长坤"
 author: 欧长坤
-email: hi[at]changkun.us
+email: hi[at]changkun.de
 language: zh-CN
 # URL
--- a/website/filter.py
+++ b/website/filter.py
@@ -1,5 +1,5 @@
 # !/usr/bin/env python3
-# author: changkun<hi@changkun.us>
+# author: changkun<hi[at]changkun.de>
 import os
 import re
--- a/website/package-lock.json
+++ b/website/package-lock.json
--- a/website/package.json
+++ b/website/package.json
@@ -3,17 +3,17 @@
  "version": "2.0.0",
  "private": true,
  "hexo": {
-    "version": "3.8.0"
+    "version": "5.3.0"
  },
  "dependencies": {
-    "hexo-generator-index": "^0.2.1",
+    "hexo-generator-index": "^2.0.0",
    "hexo-image-caption": "^0.1.1",
-    "hexo-renderer-ejs": "^0.3.1",
+    "hexo-renderer-ejs": "^1.0.0",
-    "hexo-renderer-marked": "^1.0.1",
+    "hexo-renderer-marked": "^4.0.0",
-    "hexo-renderer-stylus": "^0.3.3"
+    "hexo-renderer-stylus": "^2.0.1"
  },
  "devDependencies": {
-    "hexo": "^3.8.0",
+    "hexo": "^5.3.0",
-    "serve": ">=7.0.0"
+    "serve": "^11.3.2"
  }
 }
--- a/website/src/modern-cpp/about/ack.md
+++ b/website/src/modern-cpp/about/ack.md
@@ -0,0 +1,31 @@
 ---
 title: 致谢
 type: about
 order: 4
 ---
 ## Acknowledgements
 This book was originally written in Chinese by [Changkun Ou](https://changkun.de).
 The author has limited time and language skills. If readers find any mistakes in the book or any language improvements, please feel free to open an [Issue](https://github.com/changkun/modern-cpp-tutorial/issues) or start a [Pull request](https://github.com/changkun/modern-cpp-tutorial/pulls). For detailed guidelines and checklist, please refer to [How to contribute](CONTRIBUTING.md).
 The author is grateful to all contributors, including but not limited to [Contributors](https://github.com/changkun/modern-cpp-tutorial/graphs/contributors).
 <p>This project is also supported by:</p>
 <p>
  <a href="https://www.digitalocean.com/?refcode=834a3bbc951b&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=CopyPaste">
    <img src="https://opensource.nyc3.cdn.digitaloceanspaces.com/attribution/assets/SVG/DO_Logo_horizontal_blue.svg" width="201px">
  </a>
 </p>
 ## 致谢
 笔者时间和水平有限，如果读者发现书中内容的错误，欢迎提 [Issue](https://github.com/changkun/modern-cpp-tutorial/issues)，或者直接提 [Pull request](https://github.com/changkun/modern-cpp-tutorial/pulls)。详细贡献指南请参考[如何参与贡献](CONTRIBUTING.md)，由衷感谢每一位指出本书中出现错误的读者，包括但不限于 [Contributors](https://github.com/changkun/modern-cpp-tutorial/graphs/contributors)。
 <p>本项目还由以下产品提供赞助支持：</p>
 <p>
  <a href="https://www.digitalocean.com/?refcode=834a3bbc951b&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=CopyPaste">
    <img src="https://opensource.nyc3.cdn.digitaloceanspaces.com/attribution/assets/SVG/DO_Logo_horizontal_blue.svg" width="201px">
  </a>
 </p>
--- a/website/themes/moderncpp/layout/layout.ejs
+++ b/website/themes/moderncpp/layout/layout.ejs
@@ -10,6 +10,15 @@
    <link rel="shortcut icon" type="image/x-icon" href="/modern-cpp/assets/cover-2nd.png">
    <meta name="msapplication-TileColor" content="#7e2d36">
    <meta name="theme-color" content="#7e2d36">
    <!-- Global site tag (gtag.js) - Google Analytics -->
    <script async src="https://www.googletagmanager.com/gtag/js?id=UA-80889616-2"></script>
    <script>
      window.dataLayer = window.dataLayer || [];
      function gtag(){dataLayer.push(arguments);}
      gtag('js', new Date());
      gtag('config', 'UA-80889616-2');
    </script>
    <link href='//fonts.googleapis.com/css?family=Source+Sans+Pro:300,400,600|Roboto Mono' rel='stylesheet' type='text/css'>
    <link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet" type="text/css">
@@ -20,7 +29,7 @@
    <!-- this needs to be loaded before guide's inline scripts -->
    <script src="https://cdn.jsdelivr.net/npm/vue"></script>
    <script>window.PAGE_TYPE = "<%- page.type %>"</script>
-
+    <script async src="//changkun.de/urlstat/client.js"></script>
  </head>
  <body class="<%- isIndex ? '' : 'docs' -%>">
    <% if (page.type == 'book-en-us') { %>
--- a/website/themes/moderncpp/layout/partials/header.ejs
+++ b/website/themes/moderncpp/layout/partials/header.ejs
@@ -1,10 +1,10 @@
 <div id="header">
  <a id="logo" href="<%- url_for("/modern-cpp/") %>">
    <% if (page.type == 'book-en-us') { %>
-      <img src="<%- url_for("/modern-cpp/assets/cover-2nd-en.png") %>">
+      <img src="<%- url_for("/modern-cpp/assets/cover-2nd-en-logo.png") %>">
      <span>Modern C++ Tutorial: C++ 11/14/17/20 On the Fly</span>
    <% } else {%>
-      <img src="<%- url_for("/modern-cpp/assets/cover-2nd.png") %>">
+      <img src="<%- url_for("/modern-cpp/assets/cover-2nd-logo.png") %>">
      <span>现代 C++ 教程：高速上手 C++ 11/14/17/20</span>
    <% } %>
  </a>
--- a/website/themes/moderncpp/layout/partials/main_menu.ejs
+++ b/website/themes/moderncpp/layout/partials/main_menu.ejs
@@ -16,8 +16,8 @@
  <ul class="nav-dropdown">
      <li><ul>
      <li><a class="nav-link" href="<%- url_for("/modern-cpp/about/donate.html") %>" >资助</a></li>
      <li><a class="nav-link" href="<%- url_for("/modern-cpp/about/community.html") %>" >社区</a></li>
      <li><a class="nav-link" href="<%- url_for("/modern-cpp/about/copyright.html") %>" >版权声明</a></li>
      <li><a class="nav-link" href="<%- url_for("/modern-cpp/about/ack.html") %>" >致谢</a></li>
      </ul></li>
  </ul>
 </li>
--- a/website/themes/moderncpp/layout/partials/main_menu_en.ejs
+++ b/website/themes/moderncpp/layout/partials/main_menu_en.ejs
@@ -16,8 +16,8 @@
 <ul class="nav-dropdown">
    <li><ul>
    <li><a class="nav-link" href="<%- url_for("/modern-cpp/about/donate.html") %>" >Donate</a></li>
    <li><a class="nav-link" href="<%- url_for("/modern-cpp/about/community.html") %>" >Community</a></li>
    <li><a class="nav-link" href="<%- url_for("/modern-cpp/about/copyright.html") %>" >Copyright</a></li>
    <li><a class="nav-link" href="<%- url_for("/modern-cpp/about/ack.html") %>" >Acknowledgements</a></li>
    </ul></li>
 </ul>
 </li>
--- a/website/themes/moderncpp/source/modern-cpp/css/_header.styl
+++ b/website/themes/moderncpp/source/modern-cpp/css/_header.styl
@@ -138,7 +138,7 @@ body.docs
    position: absolute
    width: 25px
    height: 30px
-    background: url(../assets/cover-2nd-en.png) center center no-repeat
+    background: url(../assets/cover-2nd-en-logo.png) center center no-repeat
    background-size: auto 100%
    top: 12px
    right: 12px
Author	SHA1	Message	Date
Changkun Ou	9ff1deb882	website: update dependencies	2021-08-11 13:20:31 +02:00
Raine Adams (they/them)	55da3fd452	book: revise preface (#197 )	2021-08-11 13:16:56 +02:00
Changkun Ou	93ce6490a6	book: revise release acquire semantics Fixes #174	2021-08-11 13:10:34 +02:00
Changkun Ou	b0f6f30988	book: fmt	2021-08-11 12:41:48 +02:00
Changkun Ou	309f1f3731	book: wrap code Fixes #186	2021-08-11 12:41:16 +02:00
Changkun Ou	6f5615b971	book: fix an inconsistency between en-us and zh-cn	2021-08-11 12:36:35 +02:00
Changkun Ou	e202554f16	book: import correct header Fixes #192 Fixes #147	2021-08-11 12:33:44 +02:00
Changkun Ou	529399ffcd	pdf: use printf over echo echo may introduce inconsistent behaviors over different platforms. printf is considered better than echo. See: https://unix.stackexchange.com/questions/65803/why-is-printf-better-than-echo Fixes #188	2021-08-11 12:27:20 +02:00
Changkun Ou	ed88f4efbb	website: update dependencies	2021-08-11 12:19:11 +02:00
Changkun Ou	d472ff1421	book: add text about auto as func args Fixes #180	2021-08-11 11:20:57 +02:00
weissle	7eeaa7ae4e	book: typo fix (#202 )	2021-08-06 18:58:34 +02:00
Jiannanya	068840bb72	book: typo fixes (#200 )	2021-07-31 11:35:21 +02:00
QuarticCat	7f7d7086a9	book: remove default template parameters (#194 )	2021-07-07 08:25:57 +02:00
Killer_Quinn	69aa4f0bdf	book: typo fix (#190 )	2021-06-13 16:38:29 +02:00
Guo	711694e0a2	book: typo fix (#189 )	2021-06-10 14:43:51 +02:00
Timothy	645fa62677	book: format fixes (#187 )	2021-04-30 16:00:19 +02:00
Nikhil Garuda	731a219d89	book: typo and grammar fixes (#185 )	2021-04-18 12:12:26 +02:00
obweix	45bef893a7	book: typo fixes (#183 )	2021-04-16 09:01:20 +02:00
Dw9	ad4b9580a5	book: rephrease unique_ptr value capturing (#182 )	2021-04-13 09:36:31 +02:00
Umedzhon Abdumuminov	5e2531058c	book: fix anchor link (#181 )	2021-04-12 11:42:50 +02:00
LaChimere	4cb055f629	book: typo fixes (#177 )	2021-04-05 23:30:43 +02:00
Kartik Saranathan	a386449dec	book: typo fixes (#175 )	2021-03-15 10:39:11 +01:00
Changkun Ou	aa4d1eead5	github: add sponsor button	2021-02-11 14:12:32 +01:00
Changkun Ou	25aa347428	website: add urlstat	2021-02-06 23:35:01 +01:00
abuco	9ded3a2967	pdf: fix rendering issue due to line break (#170 ) Fixes #149	2021-01-24 08:42:14 +01:00
Changkun Ou	6b73213e78	assets: remove qq group	2021-01-13 13:35:22 +01:00
Changkun Ou	a5445b7c55	book: typo fixes Fixes #159	2020-12-31 09:40:58 +01:00
Changkun Ou	7eceaf1bee	all: remove chat group (#165 )	2020-12-31 09:26:05 +01:00
Guoliang WANG	054119f69c	book: fmt (#163 ) Co-authored-by: guoliang wang <tswanggl@hotmail.com>	2020-12-29 08:52:14 +01:00
Guoliang WANG	91739f178c	book: typo fixes (#164 ) Co-authored-by: guoliang wang <tswanggl@hotmail.com>	2020-12-29 08:51:11 +01:00
Guoliang WANG	45618ad676	book: fmt (#154 ) * Add space between english and chinease char * Add space between english and chinease char * book: typo fixes Co-authored-by: guoliang wang <tswanggl@hotmail.com>	2020-12-21 05:25:45 +01:00
Changkun Ou	938dcd9e95	all: update dep and email addr	2020-12-17 23:59:14 +01:00
Changkun Ou	7ab24fe51c	github: switch to action from travis (#153 )	2020-12-17 23:45:11 +01:00
dependabot[bot]	66297323ad	website: bump ini from 1.3.5 to 1.3.7 (#152 ) Bumps [ini](https://github.com/isaacs/ini) from 1.3.5 to 1.3.7. - [Release notes](https://github.com/isaacs/ini/releases) - [Commits](https://github.com/isaacs/ini/compare/v1.3.5...v1.3.7) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2020-12-11 17:23:51 +01:00
iaxax	6b911261fa	book: typo fixes (#148 ) Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2020-11-30 07:14:22 +01:00
dependabot[bot]	6dc07f6611	website: bump highlight.js from 9.18.1 to 9.18.5 in /website (#146 ) Bumps [highlight.js](https://github.com/highlightjs/highlight.js) from 9.18.1 to 9.18.5. - [Release notes](https://github.com/highlightjs/highlight.js/releases) - [Changelog](https://github.com/highlightjs/highlight.js/blob/9.18.5/CHANGES.md) - [Commits](https://github.com/highlightjs/highlight.js/compare/9.18.1...9.18.5) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2020-11-25 06:41:00 +01:00
Tengfei Niu	1e78a01ac0	book: fix incorrect return value description of std::weak_ptr expired (#144 ) * Fix error 资源尚存在时，`std::weak_ptr` 的 `expired()` 方法返回 `false`, 否则返回 `true`。 * book: fix error Fix error, while the resource of `std::shared_ptr` exists, `std::weak_ptr`'s `expired()` method returns `false`, otherwise it returns `true`.	2020-11-17 08:34:05 +01:00
Tianyi Shi	56de7fa327	book: typo fixes (#143 )	2020-11-15 07:23:39 +01:00
Tengfei Niu	6a3d8d7103	book: typo fixes (#141 )	2020-11-13 11:08:35 +01:00
flynn	c239ef1b2d	all: correct pdf link (#138 )	2020-10-29 16:33:45 +01:00
Changkun Ou	0f8819f4f9	book: remove nullptr 0L condition This is a bug introduced in #132. Fixes #136	2020-10-20 07:44:21 +02:00
Changkun Ou	030b43e22b	website: add google analytics	2020-10-19 08:51:57 +02:00
Changkun Ou	659a3801a5	book: typo fixes in 07-thread.md Fixes #125	2020-10-18 20:39:22 +02:00
sunshaoce	c9f8eb70fd	book: improve NULL example (#133 )	2020-10-03 09:27:14 +02:00
Allen	212f4f3503	book: typo fixes (#126 ) comple -> compile	2020-09-30 07:11:56 +02:00
Changkun Ou	ff05988742	all: add sponsor	2020-09-10 00:07:56 +02:00
changdingfang	518c6e97d7	book: typos fix in ch07-thread (#118 ) revise the code to make sure it consistent with the book description	2020-08-28 17:24:05 +02:00
Rayan	a3f9aaa394	book/en: fix markdown syntax error (#121 ) Fixes #120	2020-08-28 17:08:48 +02:00
changdingfang	32bdf85ebd	book: fix indent typos (#117 )	2020-08-24 06:59:44 +02:00
TinyWang	4de9eb49f7	book: use curly brackets to initailize aggregate objects (#112 )	2020-08-10 10:00:08 +02:00
Changkun Ou	9dbdd53f2e	book/en: typo fixes Fixes #113	2020-08-10 09:52:24 +02:00
dependabot[bot]	93df232f1b	build(deps): bump prismjs from 1.20.0 to 1.21.0 in /website (#114 ) Bumps [prismjs](https://github.com/PrismJS/prism) from 1.20.0 to 1.21.0. - [Release notes](https://github.com/PrismJS/prism/releases) - [Changelog](https://github.com/PrismJS/prism/blob/master/CHANGELOG.md) - [Commits](https://github.com/PrismJS/prism/compare/v1.20.0...v1.21.0) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2020-08-10 09:51:14 +02:00
Changkun Ou	c4c7ad14ee	website: update dependencies	2020-07-26 11:58:11 +02:00
Changkun Ou	c015324c5c	pdf: escape dollar sign in lstlistings fixes #106	2020-07-26 11:53:30 +02:00
Changkun Ou	1421f372e0	book: typo fixes fixes #104	2020-07-26 11:04:07 +02:00
Changkun Ou	bfd2f7caaf	website: optimize logo size fixes #110	2020-07-26 10:57:26 +02:00
dependabot[bot]	5beea9797a	build(deps): bump acorn from 6.2.0 to 6.4.1 in /website (#109 ) Bumps [acorn](https://github.com/acornjs/acorn) from 6.2.0 to 6.4.1. - [Release notes](https://github.com/acornjs/acorn/releases) - [Commits](https://github.com/acornjs/acorn/compare/6.2.0...6.4.1) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2020-07-17 21:57:57 +02:00
dependabot[bot]	1dddfce585	build(deps): bump lodash from 4.17.14 to 4.17.19 in /website (#108 ) Bumps [lodash](https://github.com/lodash/lodash) from 4.17.14 to 4.17.19. - [Release notes](https://github.com/lodash/lodash/releases) - [Commits](https://github.com/lodash/lodash/compare/4.17.14...4.17.19) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2020-07-17 21:06:48 +02:00
TinyWang	79b6d5b567	book: fix the incorrect character in regex (#107 )	2020-07-17 16:36:48 +02:00
dragonWater	3abc907bb4	book: fix incorrect string literal (#102 ) and a typo (#103 )	2020-06-03 08:19:41 +02:00
TinyWang	f1c1e06178	book: fix the wrong about delctype (#101 )	2020-05-30 15:26:10 +02:00
Daniel	0f39561c5a	book: improve wording for decltype sentence (#100 )	2020-05-27 07:33:39 +02:00
Ivan.Yang	b5e90c4fdf	book: typo fix (#99 )	2020-05-22 12:14:42 +02:00
Wenjin.Rao	1fcfd36964	book: fix a minor typo (#97 )	2020-04-23 08:28:57 +02:00
Changkun Ou	b7debcc558	assets: remove qq and wechat group	2020-04-20 08:36:40 +02:00
Changkun Ou	d31da4caf9	book: fix typo in memory order acquire Fixes #96	2020-04-20 08:34:16 +02:00
Changkun Ou	a5d1563609	book: fix a chunk of english typos Fixes #87	2020-03-15 15:30:48 +01:00
HaoYuan	89060d4b96	book: fix typo in 03-runtime.md (#95 ) fix chapter3.7 perfect.forward code err.	2020-03-15 15:13:20 +01:00
CrustaShrimp	a98686bd82	book: english typos (#93 )	2020-02-23 11:26:08 +01:00
Adamas	e5450c767c	book: fix smart pointers (#90 )	2020-01-08 07:09:27 +01:00
BillyWooo	bc4ff8f614	book/03-runtime: typo (#89 )	2019-12-18 22:55:49 +01:00
wangb	04420e835e	book: fix a minor typo (#83 )	2019-11-13 08:55:08 +01:00
Christoph Dibak	8767bb89c4	book: english typo (#79 )	2019-09-20 15:06:54 +02:00
Swastik Baranwal	0aa031f0f6	book: add missing header files (#74 )	2019-09-18 16:27:08 +02:00
Changkun Ou	934eb895c5	build: fixing pdf and epub build Fixes #77	2019-09-17 14:31:24 +02:00
Changkun Ou	6914acc324	epub: support epub version	2019-09-08 11:55:29 +02:00
Changkun Ou	4b1181f233	book: fix minor typo	2019-08-28 08:47:23 +02:00
Changkun Ou	e784ed003e	assets: add wechat group see #75	2019-08-14 16:02:11 +02:00
Changkun Ou	d428b44c56	all: add build badge	2019-08-09 20:40:09 +02:00