see #12: translation of preface and chapter 01

book/en-us/00-preface.md

@@ -10,12 +10,41 @@ 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.
+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 C++11/14/17/20 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.
+
+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.
+
+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 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++.
+
 ## Purpose
 
+The book claims "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.
+
+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.
+
+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.
+
 ## 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.
+
+## 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](../../exercise). The folder name is the chapter number.
+
 [Table of Content](./toc.md) | [Next Chapter: Towards Modern C++](./01-intro.md)
 
 ## Licenses

book/en-us/01-intro.md

@@ -1,15 +1,147 @@
 ---
 title: Chapter 01：Towards Modern C++
-type: book-zh-cn
+type: book-en-us
 order: 1
 ---
 
 # Chapter 01: Towards Modern C++
 
+[TOC]
+
+**Compilation Environment**: This book will use `clang++` as the only compiler used, 
+and always use the `-std=c++2a` compilation flag in your code.
+
+```bash
+$ clang++ -v
+Apple LLVM version 10.0.1 (clang-1001.0.46.4)
+Target: x86_64-apple-darwin18.6.0
+Thread model: posix
+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:
+
+> **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.
+
+- **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
+    ```
+
+- **C++98 exception description, `unexpected_handler`, `set_unexpected()` and other related features are deprecated and should use `noexcept`.**
+
+- **`auto_ptr` is deprecated and `unique_ptr` should be used.**
+
+- **`register` keyword is deprecated and can be used but no longer has any practical meaning.**
+
+- The `++` operation of the **`bool` type is deprecated.**
+
+- ** If a class has a destructor, the properties for which it generates copy constructors and copy assignment operators are deprecated.**
+
+- **C language style type conversion is deprecated (ie using `(convert_type)`) before variables, and `static_cast`, `reinterpret_cast`, `const_cast` should be used for type conversion.**
+
+- **In particular, some of the C standard libraries that can be used are deprecated in the latest C++17 standard, such as `<ccomplex>`, `<cstdalign>`, `<cstdbool>` and `<ctgmath>` Wait**
+
+- ... 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.
+
+## 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.
+
+![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:
+
+```cpp
+// foo.h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int add(int x, int y);
+
+#ifdef __cplusplus
+}
+#endif
+
+// foo.c
+int add(int x, int y) {
+    return x+y;
+}
+
+// 1.1.cpp
+#include "foo.h"
+#include <iostream>
+#include <functional>
+
+int main() {
+    [out = std::ref(std::cout << "Result from C code: " << add(1, 2))](){
+        out.get() << ".\n";
+    }();
+    return 0;
+}
+```
+
+You should first compile the C code with `gcc`:
+
+```bash
+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):
+
+```bash
+clang++ 1.1.cpp foo.o -std=c++2a -o 1.1
+```
+
+Of course, you can use `Makefile` to compile the above code:
+
+```makefile
+C = gcc
+CXX = clang++
+
+SOURCE_C = foo.c
+OBJECTS_C = foo.o
+
+SOURCE_CXX = 1.1.cpp
+
+TARGET = 1.1
+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.
+>
+> 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.
+
+If you are new to modern C++, you probably still don't understand the following small piece of code above, namely:
+
+```cpp
+[out = std::ref(std::cout << "Result from C code: " << add(1, 2))](){
+    out.get() << ".\n";
+}();
+```
+
+Don't worry at the moment, we will come to meet them in our later chapters.
+
 [Table of Content](./toc.md) | [Previous Chapter](./00-preface.md) | [Next Chapter: Language Usability Enhancements](./02-usability.md)
 
 ## 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)
+- [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)
+
 ## Licenses
 
 <a rel="license" href="http://creativecommons.org/licenses/by-nc-nd/4.0/"><img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-nd/4.0/88x31.png" /></a><br />This work was written by [Ou Changkun](https://changkun.de) and licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc-nd/4.0/">Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License</a>. The code of this repository is open sourced under the [MIT license](../../LICENSE).