[C/C++] - Tips for Better Coding Style
關于更好的編程風格的建議 (v1.5)
Translated By Phoenix(phoenix8848@gmail.com)
In this entry, I show you 4 tips that address frequently asked questions from C++ programmers of all levels of expertise. It's surprising to discover how many experienced programmers are still unaware of the deprecation of the .h notation of standard header files, the proper usage of namespaces, and the rules regarding binding of references to temporary objects, for example. These issues and others will be discussed here.
在這篇文章里我將談談各種層次的Ｃ++程序員經常問及的四個問題。例如我很驚訝地發現還有很多程序員沒有意識到標準頭文件擴展名.h的爭議，命名空間的恰當用法以及引用臨時對象的規則。這些問題及其它將在這里進行討論。
First, we start by explaining the difference between the deprecated “xxx.h” header names and the modern, standard-compliant “xxx” header-naming notation. Next, we explore a few dark corners of C++ which due to compilers' limitations and the somewhat recondite nature of the associated language rules tend(原文為“rulestend”) to confuse many programmers, e.g., the notion of comma-separated expressions and the rules of binding references to rvalues. Finally, we will learn how to invoke a function prior to a program's startup.
首先我們從解釋受非議的“XXX.h”頭文件名與現代、符合標準的“<XXX>”頭文件名記號之間的區別開始。接下來我們探索C++不為人知的角落，由于編譯器的局限性和關聯語言規則某些隱蔽的自然特性迷惑了許多程序員，比如逗號分隔表達式的意義與引用型變量的規則。最后我們將學習如何在程序啟動前啟動一個函數。
Tip 1: “iostream.h” or “iostream”?
語題1：“iostream.h” or “iostream”?
Many C++ programmers still use “iostream.h” instead of the newer, standard compliant “iostream” library. What are the differences between the two? First, the .h notation of standard header files was deprecated more than five years ago. Using deprecated features in new code is never a good idea. In terms of functionality, “iostream” contains a set of templatized I/O classes which support both narrow and wide characters, as opposed to “iostream.h” which only supports char-oriented streams. Third, the C++ standard specification of iostream's interface was changed in many subtle aspects. Consequently, the interfaces and implementation of “iostream” differ from those of “iostream.h”. Finally, “iostream” components are declared in namespace std whereas “iostream.h” components are global.
很多C++程序員還在使用“iostream.h”代替新的符合標準的“iostream”庫。兩者有什么區別呢？首先，標準頭文件“.h”擴展名在五年前就倍受爭議。在新代碼中使用有爭議的（過時的）特性永遠都不是一個好主意。從本質上看，“iostream”包括一系列支持窄字符與寬字符的模板化（templatized） I/O輸入輸出類，而相反地，“iostream.h”只支持字符流。第三，iostream接口的標準C++規范在許多細節方面進行了變動。因此，“iostream”的接口與實現同那些“iostream.h”是有區別的。最后，“iostream”是在std命名空間中定義的而“iostream.h”則是全局的。
Because of these substantial differences, you cannot mix the two libraries in one program. As a rule, use “iostream” unless you're dealing with legacy code that is only compatible with “iostream.h”.
由于這些本質方面的不同，不能在同一程序中混合使用這兩種庫。作為一個規則，
應盡量使用“iostream”，除非你要處理的是只能與“iostream.h”兼容的遺留代碼。（感謝） Tip 2: Binding a Reference to an R-Value
話題2：將引用與右值綁定
（R-Value：右值，與“左值”相對。例如x=3中，“x”是一個“左值”，“3”是一個右值。從本質上講，左值是一個內存的地址，右值是一個實際的二進制值。）
R-Values and L-Values are a fundamental concept of C++ programming. In essence, an R-Value is an expression that cannot appear on the left-hand side of an assignment expression. By contrast, an L-Value refers to an object (in its wider sense), or a chunk of memory, to which you can write a value. References can be bound to both R-Values and L-Values. However, due to the language's restrictions regarding R-Values, you have to be aware of the restrictions on binding references to R-Values, too.
右值和左值是C++編程的一個基本概念。本質上來講右值是一個不可能出現在等號左邊的表達式。相反，左值引用一個對象（廣義范圍上的），或者一塊可讀寫的內存。引用既可以指向右值也可以指向左值。然而，由于語言在處理右值上的限制，你也得在將引用指向右值是慎重考慮。
Binding a reference to an R-Value is allowed as long as the reference is bound to a const type. The rationale behind this rule is straightforward: you can't change an R-Value, and only a reference to const ensures that the program doesn't modify an R-Value through its reference. In the following example, the function f() takes a reference to const int:
將引用與右值綁定像引用
常量（這里const type應為"常量",感謝 ）一樣也是被允許的。這條原則背后的原理是很顯而易見的：你無法改變右值，因為對
常量的引用確保程序不會通過這個接口改變右值。下面的例子，f()函數包含一個對
常整型變量的引用。
1 void f(const int & i);
2
3 int main()
4 {
5 f(2); /* OK */
6 }
The program passes the R-Value 2 as an argument to f(). At runtime, C++ creates a temporary object of type int with the value 2 and binds it to the reference i. The temporary and its reference exist from the moment f() is invoked until it returns; they are destroyed immediately afterwards. Note that had we declared the reference i without the const qualifier, the function f() could have modified its argument, thereby causing undefined behavior. For this reason, you may only bind references to const objects.
這段代碼將右值“2”做為函數f()的一個參數。代碼運行時，C++將創建一個值為2的臨時整型變量并將其與引用類型i綁定。這個臨時對象與它的接口將在 f()運行期間一直存到直到函數f返回。函數f返回后它們立即被釋放。注意我們沒有將i聲明為常量類型，但是函數f仍有可能修改它的這個參數，這將引起異常。因此最好是將引用與
常量類型綁定。
The same rule applies to user-defined objects. You may bind a reference to a temporary object only if it's const:
同樣的規則適用于自定義類型。只有一個臨時對象為
常量時才可以與引用類型綁定。
struct A{};
1 void f(const A& a);
2
3 int main()
4 {
5 f(A()); /* OK, binding a temporary A to a const reference*/
6 }
Tip 3: Comma-Separated Expressions
話題3：逗號表達式
Comma-separated expressions were inherited from C. It's likely that you use such expressions in for- and while-loops rather often. Yet, the language rules in this regard are far from being intuitive. First, let's see what a comma separated expression is.
逗號表達式是從C語言沿襲下來的。它就像你經常使用的for循環與while-loop循環一樣。但是這里面的語法規則遠不像看起來的那樣。首先，讓我們看看什么是逗號表達式。
An expression may consist of one or more sub-expressions separated by commas. For example:
一個表達式可以被逗號分隔為一個或若干個子表達式。例如：
1 if(++x, --y, cin.good()) /*three expressions*/
The if condition contains three expressions separated by commas. C++ ensures that each of the expressions is evaluated and its side effects take place. However, the value of an entire comma-separated expression is only the result of the rightmost expression. Therefore, the if condition above evaluates as true only if cin.good() returns true. Here's another example of a comma expression:
這條if語句被逗號分事為三個表達式。從C++的角度每個表達式都是合法的但是副作用產生了。整個逗號表達式的值是由最右邊的表達式決定的。于是只有con.good()的返回值是true時整個表達式的值才是true。這里有另一個關于逗號表達式的例子。
1 int j=10;
2 int i=0;
3
4 while( ++i, --j)
5 {
6 /*..repeat as long as j is not 0*/
7 }
Tip 4: Calling a Function Before Program's Startup
在程序啟動前調用函數
Certain applications need to invoke startup functions that run before the main program starts. For example, polling, billing, and logger functions must be invoked before the actual program begins. The easiest way to achieve this is by calling these functions from a constructor of a global object. Because global objects are conceptually constructed before the program's outset, these functions will run before main() starts. For example:
有些應用需要在主程序啟運前運行啟動函數。例如投票、支付和登錄函數必須在實際種程序啟動前運行。一個最簡單的實現方法就是在一個全局對象的構造函數里調用這些函數。因為全局對象在程序的最開頭被隱式的創建，這些函數就可以在main()函數之前得到運行。例如：
1 class Logger
2 {
3 public:
4 Logger()
5 {
6 activate_log();
7 }
8 };
9
10 Logger log; /*global instance*/
11
12 int main()
13 {
14 record * prec=read_log();
15 //.. application code
16 }
The global object log is constructed before main() starts. During its construction, log invokes the function activate_log(). Thus, when main() starts, it can read data from the log file.
全局對象log在main()函數啟動之前被創建。在它的構造函數里，log調用了active_log()函數。于是，當main()函數啟動時，它可以從日志文件中讀取數據。