英翻中翻譯C/C++ 說話新手十三誡(The Thirteen Commandments for Newbie C/C++ Programmers)
by Khoguan Phuann
請留意：
(1) 本篇旨在提示新手，避免初學常犯 翻譯毛病（其實熟手在行也常犯:-Q) 翻譯社
但不克不及庖代完整的進修，請本身好好研讀一兩本 C 說話的好書，
並多多實作練習。
(2) 強烈建議新手先看過此文再提問，你 翻譯問題極可能此文已提出並
解答了。
(3) 以下所舉的毛病例子如果在你的電腦上印出和准確例子溝通的成果，
那只是不足為恃 翻譯一時僥倖 翻譯社
(4) 不守十三誡者，輕則執行成效的輸出數據錯誤，或是程式當掉，重則
引爆核彈、毀滅地球（如果你的 C 程式是用來控制核彈發射器的話）。
=============================================================
目錄： (頁碼/行號) 2/24
01. 不可以使用尚未給予適當初值 翻譯變數 3/46
02. 不克不及存取跨越陣列既定規模的空間 5/90
03. 不行以提取不知指向何方的指標 7/134
04. 不要試圖用 char* 去更改一個"字串常數" 12/244
05. 不克不及在函式中回傳一個指向區域性主動變數的指標 16/332
06. 不行以只做 malloc() 翻譯公司 而不做響應的 free() 19/398
07. 在數值運算、賦值或對照中不可以隨意混用分歧型此外數值 21/442
08. ++i/i++/--i/i--/f(&i)哪一個先履行跟挨次有關 24/508
09. 慎用Macro 27/574
10. 不要在 stack 設置過大的變數以免堆疊溢位(stack overflow) 32/684
11. 利用浮點數正確度造成 翻譯誤差問題 35/750
12. 不要猜想二維陣列可以用 pointer to pointer 來傳遞 36/772
13. 函式內 new 出來的空間記得要讓主程式的指標接住 40/860
直接輸入數字可跳至該頁碼
或用:指令輸入行號
01. 你不可以利用還沒有給予適當初值的變數
錯誤例子：
int accumulate(int max) /* 從 1 累加到 max，傳回效果 */
{
int sum; /* 未賜與初值的區域變數，其內容值是垃圾 */
for (int num = 1; num <= max; num++) { sum += num; }
return sum;
}
准確例子：
int accumulate(int max)
{
int sum = 0; /* 准確 翻譯付與恰當的初值 */
for (int num = 1; num <= max; num++) { sum += num; }
return sum;
}
備註：
按照 C Standard，具有靜態貯存期(static storage duration) 翻譯變數，
例如 全域變數(global variable)或帶有 static 潤飾符者等，
如果沒有顯式初始化的話，按照分歧 翻譯資料型態予以進行以下初始化：
若變數為算術型別 (int , double 翻譯公司 ...) 時，初始化為零或正零 翻譯社
若變數為指標型別 (int*, double* 翻譯公司 ...) 時，初始化為 null 指標。
若變數為複合型別 (struct, double _Complex, ...) 時，遞迴初始化所有成員。
若變數為結合型別 (union) 時，只有其中的第一個成員會被遞迴初始化。
(以上感激Hazukashiine板友斧正)
(可是有些MCU 編譯器可能不睬會這個規定，所以還是請養成設定初值的好習慣)
補充資料：
- 精髓區z->5->1->1->1
- C11 Standard 5.1.2, 6.2.4, 6.7.9
02. 你不成以存取超過陣列既定規模的空間
毛病例子：
int str[5];
for (int i = 0 ; i <= 5 ; i++) str[i] = i;
正確例子：
int str[5];
for (int i = 0; i < 5; i++) str[i] = i;
說明：宣佈陣列時，所給 翻譯陣列元素個數值若是是 N, 那麼我們在後面
透過 [索引值] 存取其元素時，所能利用的索引值局限是從 0 到 N-1
C/C++ 為了執行效率，其實不會主動檢查陣列索引值是不是跨越陣列界限，
我們要自己來確保不會越界。一旦越界，操作 翻譯不再是正當的空間，
將致使沒法預期的後果。
備註：
C++11以後可以用Range-based for loop提取array、
vector(或是其他有提供准確.begin()和.end() 翻譯class)內的元素
可以確保提取的元素必然落在正確範圍內。
例：
// vector
std::vector<int> v = {0, 1, 2 翻譯公司 3, 4, 5};
for(const int &i : v) // access by const reference
std::cout << i << ' ';
std::cout << '
';
// array
int a[] = {0 翻譯公司 1 翻譯公司 2, 3, 4 翻譯公司 5};
for(int n: a) // the initializer may be an array
std::cout << n << ' ';
std::cout << '
';
補充資料：
http://en.cppreference.com/w/cpp/language/range-for
03. 你不行以提取(dereference)不知指向何方 翻譯指標（包括 null 指標）。
毛病例子：
char *pc1; /* 未賜與初值，不知指向何方 */
char *pc2 = NULL; /* pc2 起始化為 null pointer */
*pc1 = 'a'; /* 將 'a' 寫到不知何方，錯誤 */
*pc2 = 'b'; /* 將 'b' 寫到「位址0」，毛病 */
准確例子：
char c; /* c 翻譯內容尚未起始化 */
char *pc1 = &c; /* pc1 指向字元變數 c */
*pc1 = 'a'; /* c 的內容變為 'a' */
/* 動態分派 10 個 char(其值不決) 翻譯公司並將第一個char的位址賦值給 pc2 */
char *pc2 = (char *) malloc(10);
pc2[0] = 'b'; /* 動態設置裝備擺設來的第 0 個字元，內容變為 'b'
free(pc2);
申明：指標變數必須先指向某個可以正當操作的空間，才能進行操作。
( 利用者記得要查抄 malloc 回傳是不是為 NULL，
礙於篇幅本文假定利用上皆正當，也有准確歸還記憶體 )
錯誤例子：
char *name; /* name 尚未指向有用的空間 */
printf("Your name, please: ");
fgets(name,20,stdin); /* 您肯定要寫入 翻譯那塊空間合法嗎??? */
printf("Hello, %s
", name);
准確例子：
/* 假如編譯期就可以決定字串 翻譯最大空間，那就不要宣佈成 char* 改用 char[] */
char name[21]; /* 可讀入字串最長 20 個字元，保存一格空間放 '\0' */
printf("Your name 翻譯公司 please: ");
fgets(name,20,stdin);
printf("Hello, %s
", name);
准確例子(2)：
若是在執行時期才能決定字串的最大空間，C供給兩種作法：
a. 哄騙 malloc() 函式來動態分配空間，用malloc宣告的陣列會被存在heap
須留意：若是宣佈較大陣列，要確認malloc的回傳值是否為NULL
size_t length;
printf("請輸入字串 翻譯最大長度(含null字元): ");
scanf("%u" 翻譯公司 &length);
name = (char *)malloc(length);
if (name) { // name != NULL
printf("您輸入的是 %u
", length);
} else { // name == NULL
puts("輸入值太大或系統已無足夠空間");
}
/* 最跋文得 free() 掉 malloc() 所分派的空間 */
free(name);
name = NULL; //(註1)
b. C99起頭可使用variable-length array (VLA)
須注重：
- 因為VLA是被存放在stack裡，使用前要確認array size不克不及太大
- 不是每一個compiler都支援VLA(註2)
- C++ Standard不支援(固然有些compiler支援)
float read_and_process(int n)
{
float vals[n];
for (int i = 0; i < n; i++)
vals[i] = read_val();
return process(vals 翻譯公司 n);
}
正確例子(3)：
C++的利用者也有兩種作法：
a. std::vector (不管你 翻譯陣列巨細會不會變都可用)
std::vector<int> v1;
v1.resize(10); // 從新設定vector size
b. C++11以後，若是確定陣列巨細不會變，可以用std::array
須留意：一般使用下(存在stack)一樣要確認array size不能太大
std::array<int, 5> a = { 1, 2 翻譯公司 3 }; // a[0]~a[2] = 1,2,3; a[3]以後為0;
a[a.size() - 1] = 5; // a[4] = 0;
備註：
註1. C++的使用者，C++03或之前請用0代替NULL，C++11入手下手請改用nullptr
註2. gcc和clang支援VLA，Visual C++不支援
彌補資料：
http://www.cplusplus.com/reference/vector/vector/resize/
04. 你弗成以試圖用 char* 去更改一個"字串常數"
試圖去更改字串常數(string literal)的結果會是undefined behavior 翻譯社
毛病例子：
char* pc = "john"; /* pc 如今指著一個字串常數 */
*pc = 'J'; /* undefined behaviour，結果沒法展望*/
pc = "jane"; /* 合法，pc指到在別的位址 翻譯另一個字串常數*/
/* 可是"john"這個字串照舊存在原來的地方不會消逝*/
因為char* pc = "john"這個動作會新增一個內含元素為"john\0" 翻譯static char[5]，
然後pc會指向這個static char的位址(平日是唯讀)。
若是試圖存取這個static char[]，Standard並沒有界說成效為何。
pc = "jane" 這個動作會把 pc 指到另外一個沒在用的位址然後新增一個
內含元素為"jane\0" 翻譯static char[5] 翻譯社
可是之前那個字串 "john
" 仍是留在原地沒有消逝。
通常編譯器 翻譯作法是把字串常數放在一塊read only(.rdata)的區域內，
此區域巨細是有限的，所以假如你反複把pc指給分歧 翻譯字串常數，
是有可能會出問題的。
准確例子：
char pc[] = "john"; /* pc 目下當今是個正當的陣列，裡面住著字串 john */
/* 也就是 pc[0]='j', pc[1]='o' 翻譯公司 pc[2]='h',
pc[3]='n', pc[4]='\0' */
*pc = 'J';
pc[2] = 'H';
申明：字串常數的內容應該如果"唯讀" 翻譯 翻譯社您有利用權，可是沒有更改的權利。
若您但願利用可以更改的字串，那您應該將其放在合法空間
毛病例子：
char *s1 = "Hello 翻譯公司 ";
char *s2 = "world!";
/* strcat() 不會另行設置裝備擺設空間，只會將資料附加到 s1 所指唯讀字串的後面，
造成寫入到程式無權碰觸的記憶體空間 */
strcat(s1 翻譯公司 s2);
准確例子(2)：
/* s1 宣告成陣列，並保存足夠空間寄存後續要附加的內容 */
char s1[20] = "Hello, ";
char *s2 = "world!";
/* 因為 strcat() 翻譯返回值等於第一個參數值，所以 s3 就不需要了 */
strcat(s1 翻譯公司 s2);
C++對於字串常數的嚴格界說為const char* 或 const char[]。
然則由於要相容C，char* 也是許可的寫法(不建議就是)。
不過，在C++試圖更改字串常數(要先const_cast)一樣是undefined behavior。
const char* pc = "Hello";
char* p = const_cast<char*>(pc);
p[0] = 'M'; // undefined behaviour
備註：
由於不加const輕易造成混淆，
建議不論是C還是C++一概用 const char* 界說字串常數 翻譯社
彌補資料：
http://en.cppreference.com/w/c/language/string_literal
http://en.cppreference.com/w/cpp/language/string_literal
字串函數相幹：#1IOXeMHX
undefined behavior : 精髓區 z -> 3 -> 3 -> 23
05. 你弗成以在函式中回傳一個指向區域性主動變數 翻譯指標。不然，會獲得垃圾值
[感激 gocpp 網友供應程式例子]
毛病例子：
char *getstr(char *name)
{
char buf[30] = "hello, "; /*將字串常數"hello, "的內容複製到buf陣列*/
strcat(buf, name);
return buf;
}
說明：區域性主動變數，將會在分開該區域時(本例中就是從getstr函式返回時)
被覆滅，因此呼喚端獲得的指標所指的字串內容就失效了。
准確例子：
void getstr(char buf[] 翻譯公司 int buflen, char const *name)
{
char const s[] = "hello, ";
strcpy(buf, s);
strcat(buf 翻譯公司 name);
}
准確例子：
int* foo()
{
int* pInteger = (int*) malloc( 10*sizeof(int) );
return pInteger;
}
int main()
{
int* pFromfoo = foo();
}
申明：上例固然回傳了函式中的指標，但由於指標內容所指的位址並不是區域變數，
而是用動態 翻譯體式格局抓取而得，換句話說這塊空間是長在 heap 而非 stack，
又因 heap 空間其實不會主動收受接管，是以這塊空間在脫離函式後，依然有用
(然則這個例子可能會因為 programmer 的忽視，遺忘 free 而造成
memory leak)
[針對字串操作，C++供給了更方便平安更直觀 翻譯 string class 翻譯公司 能用就盡可能用]
准確例子:
#include <string> /* 並不是 #include <cstring> */
using std::string;
string getstr(string const &name)
{
return string("hello, ") += name;
}
06. [C]你弗成以只做 malloc(), 而不做響應的 free(). 不然會造成記憶體漏失
但若不是用 malloc() 所獲得的記憶體，則弗成以 free()。已 free()了
所指記憶體的指標，在它指向另外一塊有用 翻譯動態分派得來 翻譯空間之前，不行
以再被 free()，也不可以提取(dereference)這個指標 翻譯社
小技能: 可在 free 之後將指標指到 NULL，free不會對空指標感化 翻譯社
例：
int *p = malloc(sizeof(int));
free(p);
p = NULL;
free(p); // free不會對空指標有感化
[C++] 你不成以只做 new, 而不做響應的 delete (除unique_ptr以外)
註：new 與 delete 對應，new[] 與 delete[] 對應，
不成與malloc/free混用(結果不行展望)
切記，做了幾回 new，就必須做幾回 delete
小技能: 可在 delete 之後將指標指到0或nullptr(C++11起頭)，
由於 delete 本身會先做查抄，因此可以免掉多次 delete 的毛病
准確例子:
int *ptr = new int(99);
delete ptr;
ptr = nullptr;
delete ptr; /* delete 只會處理指向非 NULL 翻譯指標 */
備註：
C++11後新增智能指標(smart pointer): unique_ptr
當unique_ptr所指物件消逝時，會主動釋放其記憶體，不需要delete。
例：
#include <memory> // 含unique_ptr的標頭檔
std::unique_ptr<int> p1(new int(5));
補充資料：
http://en.cppreference.com/w/cpp/memory/unique_ptr
07. 你不行以在數值運算、賦值或比較中隨便混用分歧型別的數值，而不隆重考
慮數值型別轉換可能帶來 翻譯「意外欣喜」（驚惶） 翻譯社必需隨時留意數值運算
的效果，其規模是否會超越變數的型別
毛病例子：
unsigned int sum = 2000000000 + 2000000000; /* 超出 int 寄存範圍 */
unsigned int sum = (unsigned int) (2000000000 + 2000000000);
double f = 10 / 3;
准確例子：
/* 掃數都用 unsigned int, 注重數字後面的 u 翻譯公司 大寫 U 同樣成 */
unsigned int sum = 2000000000u + 2000000000u;
/* 或是用顯式的轉型 */
unsigned int sum = (unsigned int) 2000000000 + 2000000000;
double f = 10.0 / 3.0;
毛病例子:
unsigned int a = 0;
int b[10];
for(int i = 9 ; i >= a。-> 翻譯社|,-> 翻譯公司|的-> 翻譯 ; i--) { b[i] = 0; }
申明：由於 int 與 unsigned 配合運算的時刻，會轉換 int 為 unsigned，
是以迴圈條件永久知足，與預期行為不符
毛病例子： （感謝 sekya 網友供應）
unsigned char a = 0x80; /* no problem */
char b = 0x80; /* implementation-defined result */
if( b == 0x80 ) { /* 紛歧定恒真 */
printf( "b ok
" );
}
說明：語言並未規定 char 生成為 unsigned 或 signed，是以將 0x80 放入
char 型態 翻譯變數，將會視各家編譯器不同作法而有不同後果
毛病例子(以下假定為在32bit機器上履行)：
#include <math.h>
long a = -2147483648 ; // 2147483648 = 2 的 31 次方
while (labs(a)>0){ // labs(-2147483648)<0 有可能産生
++a;
}
申明：如果你去看C99/C11 Standard，你會發現long
變數的最大/最小值為(被define在limits.h)
LONG_MIN -2147483647 // compiler實作時最小值弗成大於 -(2147483648-1)
LONG_MAX 2147483647 // compiler實作時最小值不行小於 (2147483648-1)
不外由於32bit能顯示 翻譯規模就是2**32種，所以一般16/32bit功課系統會把
LONG_MIN多減去1，也就是int 的顯示規模為(-LONG_MAX - 1) ~ LONG_MAX。
(64bit的作業系統long多為8 bytes，可是依舊符合Standard要求 翻譯最小局限)
當程式跑到labs(-2147483648)>0時，由於2147483648大於LONG_MAX，
Standard告訴我們，當labs的成效沒法被long有限 翻譯局限默示，
編譯器會怎麼幹就看他愉快(undefined behavior) 翻譯社
(不只long，其他如int、long long等以此類推)
彌補資料：
- C11 Standard 5.2.4.2.1, 7.22.6.1
- https://www.fefe.de/intof.html
08. ++i/i++/--i/i--/f(&i)哪個先履行跟遞次有關
++i/i++ 和--i/i-- 的問題幾近每個月城市出現，所以特殊強調。
當一段程式碼中，某個變數的值用某種體式格局被改變一次以上，
例如 ++x/--x/x++/x--/function(&x)(能改變x 翻譯函式)
- 如果Standard沒有迥殊去界說某段敘述中哪一個部分必需被先履行，
那成效會是undefined behavior(結果未知)。
- 如果Standard有特殊去界說履行挨次，那後果就憑據執行順序決定。
C/C++均正確的例子：
if (--a || ++a) {} // ||左側先較量爭論，如果左邊為1右側就不會算
if (++i && f(&i)) {} // &&左側先較量爭論，假如左邊為0右側就不會算
a = (*p++) ? (*p++) : 0 ; // 問號左側先較量爭論
int j = (++i, i++); // 這裡的逗號為運算子，表示依序計算
C/C++均毛病 翻譯例子：
int j = ++i + i++; // undefined behavior，Standard沒界說+號哪邊先履行
x = x++; // undefined behavior, Standard沒定義=號哪邊先執行
printf( "%d %d %d", I++ 翻譯公司 f(&I), I++ ); // undefined behavior 翻譯公司 緣由同上
foo(i++, i++); // undefined behavior，這裡的逗號是用來分隔引入參數的
// 分隔符(separator)而非運算子，Standard沒界說哪邊先執行
在C與C++03錯誤可是在C++11起頭(但不包括C)正確 翻譯例子：
C++11中，++i/--i為左值(lvalue)，i++/i--為右值(rvalue) 翻譯社
左值可以被assign value給它，右值則不可。
而在C中，++i/--i/i++/i--都是右值 翻譯社
所以以下的code在C++會准確，C則否。
++++++++++phew ; // C++11會把它注釋為++(++(++(++(++phew))));
i = v[++i]; // ++i會先完成
i = ++i + 1; // ++i會先完成
在C++17開始(但不包括C)才准確 翻譯例子：
cout << i << i++; // 先左後右
a[i] = i++; // i++先做
a[x++] = --x; // 先處置懲罰--x，再處理a[x++] (loveflames彌補)
彌補資料
- Undefined behavior and sequence points
http://stackoverflow.com/questions/4176328/undefined-behavior-and-
sequence-points)
- C11 Standard 6.5.13-17，Annex C
- Sequence poit
https://en.wikipedia.org/wiki/Sequence_point
- Order of evaluation
http://en.cppreference.com/w/cpp/language/eval_order
09. 慎用macro(#define)
Macro是個像鐵鎚一樣好用又危險的對象：
用得好可以釘釘子，用欠好可以把釘子打彎、敲到你手指或被抓去吃子彈。
因為macro 界說出的「偽函式」有以下缺點：
(1) debug會變得複雜 翻譯社
(2) 無法遞迴呼喚 翻譯社
(3) 沒法用 & 加在 macro name 之前，獲得函式位址。
(4) 沒有namespace。
(5) 可能會致使奇怪的side effect或其他沒法預測的問題。
所以，利用macro前，請先確認以上的弱點是不是會影響你 翻譯程式運行 翻譯社
替代方案：enum(定義整數)，const T(定義常數)，inline function(定義函式)
C++的template(定義可用不同type參數 翻譯函式)，
或C++11開始的匿名函式(Lambda function)與constexpr T(編譯期常數)
以下就針對macro的弱點做申明：
(1) debug會變得複雜 翻譯社
編譯器不克不及對macro自己做語法查抄，只能查抄預處置(preprocess)後 翻譯成效。
(2) 沒法遞迴呼喚。
按照C standard 6.10.3.4，
若是某macro 翻譯定義裡裏面含有跟此macro名稱同樣的的字串，
該字串將不會被預處理。
所以：
#define pr(n) ((n==1)? 1 : pr(n-1))
cout<< pr(5) <<endl;
預處理過後會變成：
cout<< ((5==1)? 1 : pr(5 -1)) <<endl; // pr沒有定義，編譯會出錯
(3) 無法用 & 加在 macro name 之前，取得函式位址。
因為他不是函式，所以你也不可以把函式指標套用在macro上。
(4) 沒有namespace。
錯誤例子：
#define begin() x = 0
for (std::vector<int>::iterator it = myvector.begin();
it != myvector.end(); ++it) // begin是std的保留字
std::cout << ' ' << *it;
改善方法：macro名稱一概用大寫，如BEGIN()
(5) 可能會致使希奇 翻譯side effect或其他無法預測 翻譯問題。
錯誤例子：
#include <stdio.h>
#define SQUARE(x) (x * x)
int main()
{
printf("%d
" 翻譯公司 SQUARE(10-5)); // 預處理後變成SQUARE(10-5*10-5)
return 0;
}
正確例子：在 Macro 定義中, 務必為它的參數個別加上括號
#include <stdio.h>
#define SQUARE(x) ((x) * (x))
int main()
{
printf("%d
", SQUARE(10-5));
return 0;
}
不外碰到以下有side effect的例子就算加了括號也沒用。
毛病例子： （感激 yaca 網友提供）
#define MACRO(x) (((x) * (x)) - ((x) * (x)))
int main()
{
int x = 3;
printf("%d
", MACRO(++x)); // 有side effect
return 0;
}
補充資料：
- http://stackoverflow.com/questions/14041453/why-are-preprocessor-
macros-evil-and-what-are-the-alternatives
- http://stackoverflow.com/questions/12447557/can-we-have-recursive-macros
- C11 Standard 6.10.3.4
- http://en.cppreference.com/w/cpp/language/lambda
10. 不要在 stack 設置過大的變數以避免堆疊溢位(stack overflow)
由於編譯器會自行決定 stack 翻譯上限，某些預設是數 KB 或數十KB，當變數所需的空
間過大時，很容易造成 stack overflow，程式亦隨之當掉(segmentation fault) 翻譯社
可能造成堆疊溢位的原因包孕遞迴太屢次(多為程式設計缺點)，
或是在 stack 設置過大的變數 翻譯社
毛病例子：
int array[10000000]; // 在stack宣告過大陣列
std::array<int, 10000000> myarray; //在stack宣告過大std::array
正確例子：
C:
int *array = (int*) malloc( 10000000*sizeof(int) );
C++:
std::vector<int> v;
v.resize(10000000);
說明：建議將使用空間較大 翻譯變數用malloc/new配置在 heap 上，由於此時 stack
上只需設置裝備擺設一個 int* 翻譯空間指到在heap的該變數，可避免 stack overflow。
利用 heap 時，固然全部 process 可用的空間是有限的，但採用動態抓取
的體例，new 沒法設置裝備擺設時會丟出 std::bad_alloc 破例，malloc 無法設置裝備擺設
時會回傳 null(註2)，不會影響到正常利用下 翻譯程式功能
備註：
註1. 利用 heap 時，整個 process 可用的空間一樣是有限的，若是需要頻繁地
malloc / free 或 new / delete 較大的空間，需注重避免造成記憶體破碎
(memory fragmentation)。
註2. 由於Linux使用overcommit機制辦理記憶體，malloc即便在記憶體不足時
仍然會回傳非NULL 翻譯address，一樣情形在Windows/Mac OS則會回傳NULL
(感激 LiloHuang 增補)
補充資料：
- https://zh.wikipedia.org/wiki/%E5%A0%86%E7%96%8A%E6%BA%A2%E4%BD%8D
- http://stackoverflow.com/questions/3770457/what-is-memory-fragmentation
- http://library.softwareverify.com/memory-fragmentation-your-worst-nightmare/
overcommit跟malloc:
- http://goo.gl/V9krbB
- http://goo.gl/5tCLQc
11. 利用浮點數千萬要注意切確度所釀成的誤差問題
按照 IEEE 754 的規範，又電腦中是用有限的二進位貯存數字，是以常有可
能因為精確度而造成誤差，例如加減乘除，等號大小判定，分派律等數學上
常用到的操作，很有可能因此而失足(不成立)
更具體 翻譯申明可以參考精髓區 z-8-11
或參考冼鏡光先生所揭曉的一文 "利用浮點數最最根基的觀念"
http://blog.dcview.com/article.php?a=VmhQNVY%2BCzo%3D
12. 不要料想二維陣列可以用 pointer to pointer 來傳遞
(感謝 loveme00835 legnaleurc 版友的幫忙)
起首必需有個觀念，C 語言中陣列是無法直接拿來傳遞的!
不外這時候候會有人跳出來辯駁:
void pass1DArray( int array[] );
int a[10];
pass1DArray( a ); /* 可以正當編譯，並且履行成績正確!! */
事實上，編譯器會這麼對待
void pass1DArray( int *array );
int a[10];
pass1DArray( &a[0] );
我們可以順便看出來，array 變數自己可以 decay 成記憶體起頭的位置
是以我們可以 int *p = a; 這種體式格局，拿指標去接陣列。
也因為上述的例子，很多人以為那二維陣列是不是也能夠改成 int **
錯誤例子:
void pass2DArray( int **array );
int a[5][10];
pass2DArray( a );
/* 這時候候編譯器就會報錯啦 */
/* expected ‘int **’ but argument is of type ‘int (*)[10]’*/
在一維陣列中，指標的移動操作，會恰好籠蓋到陣列 翻譯範圍
例如，宣佈了一個 a[10]，那我可以把 a 當做指標來操作 *a 至 *(a+9)
是以我們可以獲得一個概念，在操作的時候，可以 decay 成指標來利用
也就是我可以把一個陣列當做一個指標來利用 (again 翻譯公司 陣列!=指標)
可是多維陣列中，沒法如斯利用，事實上這也很直觀，試圖拿一個
pointer to pointer to int 來操作一個 int 二維陣列，這是不公道的！
儘管我們沒法將二維陣列直接 decay 成兩個指標，然則我們可以換個角度想，
二維陣列可以算作 "外層大 翻譯一維陣列，每維內層各又包括著一維陣列"
如果想通了這一點，我們可以仿制之前 翻譯法則，
把外層大的一維陣列 decay 成指標，該指標指向內層 翻譯一維陣列
void pass2DArray( int (*array) [10] ); // array 是個指標，指向 int [10]
int a[5][10];
pass2DArray( a );
這時候候就很好理解了，函數 pass2DArray 內的 array[0] 會代表什麼呢？
謎底是它代表著 a[0] 外層 翻譯那一維陣列，裡面包含著內層 [0]~[9]
也是以 array[0][2] 就會對應到 a[0][2]，array[4][9] 對應到 a[4][9]
結論就是，只有最外層的那一維陣列可以 decay 成指標，其他維陣列都要
明白的指出陣列大小，如許多維陣列的傳遞就不會有問題了
也因為方才 翻譯例子，我們可以清晰 翻譯知道在傳遞陣列時，實際行為是在傳遞
指標，也是以假如我們想用 sizeof 來求得陣列元素個數，那是不可行的
毛病例子:
void print1DArraySize( int* arr ) {
printf("%u", sizeof(arr)/sizeof(arr[0])); /* sizeof(arr) 只是 */
} /* 一個指標的巨細 */
受此限制，我們必需手動傳入巨細
void print1DArraySize( int* arr, size_t arrSize );
C++ 提供 reference 的機制，使得我們不需再這麼麻煩，
可以直接傳遞陣列的 reference 給函數，巨細也可以直接求出
准確例子:
void print1DArraySize( int (&array)[10] ) { // 傳遞 reference
cout << sizeof(array) / sizeof(int); // 准確取得陣列元素個數
}
13. 函式內 new 出來的空間記得要讓主程式的指標接住
對指標不熟習的利用者會以為以下 翻譯程式碼是相符預期的
void newArray(int* local, int size) {
local = (int*) malloc( size * sizeof(int) );
}
int main() {
int* ptr;
newArray(ptr, 10);
}
接著就會找了好久的 bug，最後仍然搞不懂為什麼 ptr 沒有指向方才拿到的正當空間
讓我們再回首一次，並且用圖暗示 (感謝Hazukashiine板友供應圖解)
┌────┐ ┌────┐ ┌────┐ ┌────┐
Heap │ │ │ │ │ 新配置 │ │ 已泄露 │
│ │ │ │ │ 的空間 ＜─┐ │ 翻譯空間 │
│ │ │ │ │(allocd)│ │ │(leaked)│
│ │ │ │ ├────┤ │ ├────┤
│ │ │ │ │ ： │ │ │ │
│ │ │ │ │ ： │ │ │ ： │
│ │ ├────┤ ├────┤ │ │ ： │
│ │ │ local ├─┐ │ local ├─┘ │ │
├────┤ ├────┤ │ ├────┤ ├────┤
Stack │ ptr ├─┐ │ ptr ├─┤ │ ptr ├─┐ │ ptr ├─┐
└────┘ ╧ └────┘ ╧ └────┘ ╧ └────┘ ╧
未初始化 函式呼喚 設置裝備擺設空間 函式返回
int *ptr; local = ptr; local = malloc();
用圖看應當一切就都理解了，我也不需冗言解釋
或許有人會想問，指標不是傳址嗎？
正確來講，指標也是傳值，只不外該值是一個位址 (ex: 0xfefefefe)
local 接到了 ptr 指向的誰人位置，接著函式內 local 要到了新的位置
可是 ptr 指向的位置照樣沒變 翻譯，是以分開函式後就似乎事什麼都沒産生
( 嚴厲說起來還産生了 memory leak )
以下是一種解決設施
int* createNewArray(int size) {
return (int*) malloc( size * sizeof(int) );
}
int main() {
int* ptr;
ptr = createNewArray(10);
}
改成如許亦可 ( 為何用 int** 就能夠？想一想他會傳什麼曩昔給local )
void createNewArray(int** local 翻譯公司 int size) {
*local = (int*) malloc( size * sizeof(int) );
}
int main() {
int *ptr;
createNewArray(&ptr, 10);
}
假如是 C++，別忘了可以善用 Reference
void newArray(int*& local, int size) {
local = new int[size];
}
跋文：從「古時刻」傳播下來一篇文章
"The Ten Commandments for C Programmers"(Annotated Edition)
by Henry Spencer
http://www.lysator.liu.se/c/ten-commandments.html
一方面它不是針對 C 的初學者，一方面它特意模擬中古英文
聖經的用語，寫得文謅謅。所以我目下當今別的寫了這篇，進展
能涵蓋最主要 翻譯觀念和初學甚至內行最易犯 翻譯毛病。
作者：潘科元(Khoguan Phuann) (c)2005. 感激 ptt.cc BBS 的 C_and_CPP
看板眾多網友供給珍貴定見及程式實例。
nowar100 多次加以修改收拾整頓，擴充至 13 項，而且製作成動畫版 翻譯社
wtchen 應板友要求移除動畫並根據C/C++標準點竄內容(Ver.2016)
如發現 Bug 請推文回報，謝謝您
引用自: https://www.ptt.cc/bbs/C_and_CPP/M.1465304337.A.9F2.html有關翻譯的問題歡迎諮詢天成翻譯社
留言列表
