API: Application Program Interface
ABI: Application Binary Interface
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
P: Philosophy
Mang tính triết lý không có miêu tả code rõ ràng. Áp dụng theo tư tưởng

P.1: Express ideas directly in code
Thể hiện rõ ý tưởng trong code
Reason: Bởi vì trình biên dịch không ̉ọc comments hay tài liệu thiết kế. Vì vậy lập trình viên cần tường minh, khai bá rõ ràng mục đích khi code. Tránh gây nhầm lẫn khó hiểu tối nghĩa.
VD: setRotate(float r) Tối nghĩa vì không rõ r là gì. đơn vị radian hay deg
VD: thay vì tìm kiếm theo vòng for thì sử dụng std::find sẽ rõ nghĩa hơn

P.2: Write in ISO Standard C++
Sử dụng thư viện chuẩn

P.3: Express intent
Ngoài việc sử dụng hàm, tên hàm code rõ nội dung như ở P.1 thì lập trình viên cũng cần kiểm soát bắt chặt mục đích mong muốn thực hiện theo logic

P.4: Ideally, a program should be statically type safe
Hãy khai báo và sử dụng kiểu dữ liệu một cách an toàn, giảm thiểu việc ép kiểu, các dạng dữ liệu nhập nhằng không tường minh, độ tin cậy thấp

P.5: Prefer compile-time checking to run-time checking
Hãy cố gắng kiểm tra code trong quá trình biên dịch

P.6: What cannot be checked at compile time should be checkable at run time
Những gì không thể check trong quá trình biên dịch thì cần phải check trong quá trình chạy

P.7: Catch run-time errors early
Cần tìm và khắc phục các lỗi trong quá trình runtime sớm

P.8: Don’t leak any resources
Không được rò rỉ bất cứ nguổn tài nguyên nào. Tất cả được tao ra vầ cẩn phải huỷ bỏ ngay sau đó khi không sử dụng

P.9: Don’t waste time or space
Không lãng phí thời gian và không gian

P.10: Prefer immutable data to mutable data
Sử dụng dữ liệu không thay đổi tốt hơn so với dữ liệu thay đổi

P.11: Encapsulate messy constructs, rather than spreading through the code
Đóng gói các mã lệnh có cấu trúc lộn xộn thay vì cứ lan rộng code ra. Tuy rằng có thể tối ưu tăng hiệu suất hơn nhưng lại tiềm ẩn lỗi và khó viết

P.12: Use supporting tools as appropriate
Sử dụng các công cụ hỗ trợ tích hợp, nó sẽ tốt hơn trong việc tự sinh code, quản lý phân tích code...  đo hiệu suắt

P.13: Use support libraries as appropriate
Sử dụng các thư viện hỗ trợ nếu như nó thích hợp
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
I: Interfaces
Giao diện nó như một giao kèo giữa nhà cung cấp dịch vụ và người sử dụng dịch vụ. Nó sẽ giúp cho mọi thứ dễ hiểu, khuyến khích sử dụng hiệu quả, không dê bị lỗi, hỗ trợ thử nghiệm

I.1: Make interfaces explicit
Tạo ra một giao diện rõ ràng. Các hàm nên chỉ làm đúng nhiệm vụ và phạm vi của mình không truy suất vào biến toàn cục cũng như tự đưa ra quyết định về luồng dựa trên giá trị biến nằm ngoài phạm vi

I.2: Avoid global variables
Tránh sử dụng các biến toàn cục

I.3: Avoid singletons
Tránh sử dụng singletons

I.4: Make interfaces precisely and strongly typed
Xây dựng giao diện đơn giản rõ ràng

I.5: State preconditions (if any)
Hạn chế các tham số đầu vào

I.6: Prefer Expects() for expressing preconditions
Hãy sử dụng Expects cho những điều kiện kiên quyết

I.7: State postconditions
Xem xét giá trị trước khi trở về

I.8: Prefer Ensures() for expressing postconditions
Sử dụng Expects để kiểm tra giá trị trước khi trả về

I.9: If an interface is a template, document its parameters using concepts
Nếu như giao diện được tạo bởi template

I.10: Use exceptions to signal a failure to perform a required task
Sử dụng ngoại lệ để báo hiếu một nhiệm vụ bị thất bại

I.11: Never transfer ownership by a raw pointer (T*) or reference (T&)
Không bao giờ được thay đổi quyền sở hữu của con trỏ hoặc tham chiếu

I.12: Declare a pointer that must not be null as not_null
Quy định tham số truyền vào không phải là null với not_null

I.13: Do not pass an array as a single pointer
Không sử dụng một mảng như là con trỏ đơn

I.22: Avoid complex initialization of global objects
Tránh việc khởi tạo các biến cục bộ một cách phức tạp

I.23: Keep the number of function arguments low
Dữ cho số lượng tham sô đầu vào của function ở ít. Hàm mà nhiều tham số thường do thiếu sự trừu tượng hoặc hàm đang sử lý nhiều việc khác nhau vì vậy cần phải sắp xếp và tổ chức lại

I.24: Avoid adjacent unrelated parameters of the same type
Tránh các tham số không liên quan nằm cùng nhau bởi vì các tham sấ cùng loại nằm gần nhau có thể dễ bị đảo ngược gây nhầm lẫn

I.25: Prefer abstract classes as interfaces to class hierarchies
Nên sử dụng abstract classes hơn là interface để phân cấp cấu trúc lớp

I.26: If you want a cross-compiler ABI, use a C-style subset
Nếu bạn muốn support nhiều trình biên dịch khác nhau bạn nên sử dụng C-style, bởi mỗi trình biên dịch có thể khác nhau

I.27: For stable library ABI, consider the Pimpl idiom
Cho một thư viện abi ổn định, xem xét cạc diễn đạt Pimpl

I.30: Encapsulate rule violations
Đóng gói các quy tắc hay mục đích riêng của dự án lại để không lây lan ra những chỗ khác trong hệ thống
---------------------------------------------------------------------------------------------------------------------------------------------------------------
F: Functions

F.1: “Package” meaningful operations as carefully named functions
Chú ý đóng gói với tên phương thức cần đật tên cẩn thận. Việc đóng gói làm cho mã dễ đọc hơn, tái sử dụng hạn chế lỗi từ mã phức tạp. Nếu là một hành động rõ ràng lên tách nó ra và đật tôn cho nó
Các mã ngắn nhất không phải là luôn luôn tốt nhất cho hiệu suất và bảo trì

F.2: A function should perform a single logical operation
Một function nên thực hiện một hoạt động hợp lý duy nhất

F.3: Keep functions short and simple
Giữ cho function ngắn gọn và đơn giản

F.4: If a function may have to be evaluated at compile time, declare it constexpr
Nếu một function có thể đánh giá trong quá trình biên dịch, khai báo với constexpr
VD: constexpr int fac(int)

F.5: If a function is very small and time-critical, declare it inline
Nế́u function nhỏ và yếu tố thời gian đặt lên hàng đầu thì địng nghĩa nó với inline
VD: inline string cat(const string& s, const string& s2) {return s+s2;}

F.6: If your function may not throw, declare it noexcept
Nếu function có thể không sinh ra ngoại lệ, định nghĩa nó với noexcept. Các chưng năng như swap, move, destructors và default constructors thường không phát sinh ngoại lệ
VD: vector<string> collect(istream& is) noexcept

F.7: For general use, take T* or T& arguments rather than smart pointers
?

F.8: Prefer pure functions
Nên sử dụng các function thuần tuý

F.9: Unused parameters should be unnamed
Các tham số chưa được sử dụng lên khai báo không tên
-----------------------------------------------------------------------------------------------------------------------------------------------------------------
F.call Parameter passing

F.15: Prefer simple and conventional ways of passing information
Truyền thông tin một cách đơn giản và thông thường

F.16: For “in” parameters, pass cheaply-copied types by value and others by reference to const
Các tham số truyền vào cần truyền với nên chuyền vào đúng cách với từ khoá const
VD: void f1(const stirng& s)
    void f2(int x)

F.17: For “in-out” parameters, pass by reference to non-const
Đối với tham số in-out thì không sử dụng từ khoá const
VD: void update(Record& r);

F.18: For “consume” parameters, pass by X&& and std::move the parameter
Đối với những tham số được dùng để sử dụng, truyền tham số sử dụng X&& và std::move

F.19: For “forward” parameters, pass by TP&& and only std::forward the parameter
Nếu tham số được chuyển tiếp cho mã khác và không được trược tiếp sử dụng ở mã này thì sử dụng std::forward

F.20: For “out” output values, prefer return values to output parameters
Trả về giá trị qua return không nên sử dụng trả về giá trị qua paramester.

F.21: To return multiple “out” values, prefer returning a tuple or struct
Nếu có nhiều giá trị cần truyền ra sử dụng std::tuple hoặc đóng gói struct

F.22: Use T* or owner<T*> to designate a single object
Sử dụng T* hoặc owner<T*> để chỉ định một giá trị duy nhất

F.23: Use a not_null<T> to indicate that “null” is not a valid value
Sử dụng not_null<T> để chỉ ra rằng null không phải là giá trị hợp lệ

F.24: Use a span<T> or a span_p<T> to designate a half-open sequence
Sử dụng span<T> hoặc span_p<T> để duyệt qua danh sách. Việc này sẽ tránh gây ra lỗi tràn bộ nhớ khi duyệt qua danh sách
VD:
X* find(span<X> r, const X& v);
vector<X> vec;
auto p = find({vec.begin(), vec.end()}, X{});

F.25: Use a zstring or a not_null<zstring> to designate a C-style string
sử dụng zstring hoặc not_null<zstring> để thiết kế kiểu string theo C-style

F.26: Use a unique_ptr<T> to transfer ownership where a pointer is needed
Sử dụng unique_ptr<T> để thay đổi quyền sở hữu của một con trỏ khi cần

F.27: Use a shared_ptr<T> to share ownership
Sử dụng shared_ptr<T> để thay đổi việc chia sẻ quyển sở hữu con trỏ

F.60: Prefer T* over T& when “no argument” is a valid option
Sử dụng T* hơn là T& khi không có tham số lựa chọn hợp lệ. T* có thể null còn T& thi không thể null.

F.42: Return a T* to indicate a position (only)
Trả vể T* để trả về một vị trí duy nhất. Một con trỏ có thể thay đổi vị trí nên nếu không sử dụng nullptr thì sử dụng tham chiếu.

F.43: Never (directly or indirectly) return a pointer or a reference to a local object
Không bao giờ được trực tiếp hoặc gián tiếp trả về một con trỏ hay một tham chiếu địa phương.
int* f()
{
    int fx = 9;
    return &fx;  // BAD
}

F.44: Return a T& when copy is undesirable and “returning no object” isn’t needed
Trả về T& khi sao chép là không momg muốn và "trả về không có đối tượng" là không cần thiết

F.45: Don’t return a T&&
Không được trả về T&&, ngoại trừ std::move và std::forward

F.46: int is the return type for main()
Hàm main cần trả về int

F.47: Return T& from assignment operators
Trả về T& đối với toán tử chuyển nhượng

F.50: Use a lambda when a function won’t do (to capture local variables, or to write a local function)
Sử dụng lambda khi sử dụng một function như là cục bộ, địa phương

F.51: Where there is a choice, prefer default arguments over overloading
Nên sử dụng đối số mặc định hơn là quả tải phương thức

F.52: Prefer capturing by reference in lambdas that will be used locally, including passed to algorithms
Tốt hơn nếu sử dụng & trong lambda tại địa phương bao gồm thông qua thuật toán
[&](buffer& b)

F.53: Avoid capturing by reference in lambdas that will be used nonlocally, including returned, stored on the heap, or passed to another thread
Tránh sử dụng tham chiếu trong lambda khi không cùng thuộc phạm vi. Bao gồm cả return, lưu trữ trên heap hoặc thread

F.54: If you capture this, capture all variables explicitly (no default capture)
Lên truyền các tham số vào lambda theo cách rõ rành nhất để tránh gây nhầm lẫn
[i, this]{ use(i, x); }

F.55: Don’t use va_arg arguments
Không sử dụng đối số va_arg. Có thể thay thế bằng overloading, variadic templates, variant arugments, initializer_list
-----------------------------------------------------------------------------------------------------------------------------------------------------------------
C: Classes and Class Hierarchies

C.1: Organize related data into structures (structs or classes)
Tổ chức những dữ liệu liên quan tới nhau vào lớp hoặc struct

C.2: Use class if the class has an invariant; use struct if the data members can vary independently
Sử dụng struct khi dữ liệu bên trong có thể thay đổi độc lập

C.3: Represent the distinction between an interface and an implementation using a class
Phân biệt rõ ràng giữa giao diện và thực hiện giúp cải thiện khả năng đọc và đơn giản hóa việc bảo trì

C.4: Make a function a member only if it needs direct access to the representation of a class
Tạo một function chỉ là thành viên nếu nó cần truy cập trực tiếp đến thể hiện của lớp

C.5: Place helper functions in the same namespace as the class they support
Đặt các hàm trợ giúp trong không gian tên giống như lớp mà chúng hỗ trợ

C.7: Don’t define a class or enum and declare a variable of its type in the same statement
Không xác định một lớp hoặc enum và khai báo một biến kiểu trong cùng một lệnh

C.8: Use class rather than struct if any member is non-public
Sử dụng class hơn là struct nếu bất kỳ thành viên nào không phải là public

C.9: Minimize exposure of members
Giảm thiểu sự phơi bầy thành viên