Haste Makes Waste.

@dell
會導致什么問題？怎么讓人困惑？說話別不明不白的

@volnet
用mail吧，不習慣聊天

@volnet
互相學習，互相促進而已。你到我的博客文章里去找聯系方式吧，哈哈

@volnet
兩個風牛馬不相及的東西被你說成相似——熊貓和小熊貓。

感覺你自己的理解還是比較混亂。

1、……到其所在*編譯單元*的結束。如果“到其所在（待編譯）的文件的末尾結束”，那頭文件中定義的外部變量就會……基本沒有作用。

2、extern表示被聲明的variable或者函數在其他地方定義并分配存儲空間了。如果使用了extern，就有可能不必include相應的頭文件。

3、“如果外部變量的定義與變量的使用不在同一個源文件中，則必須在相應的變量聲明中強制地使用關鍵字extern。”——聲明/定義變量時，無論是全局還是局部變量，不帶extern永遠是定義。

“通常在對個別文件作出修改后，我們只需要重新編譯那個文件”——這更多的是模塊間的依賴問題。

“這一點給人的感覺static非常像C++/C#/Java中的private修飾符，即僅對當前文件（其它語言中可能并非文件）有效。”——你該好好理解一下OO了。static在C++中一種意思就是與C一樣。C#有assembly的概念，其internal更像static，但又不完全像。Java我不熟，不過也絕不是你說的這樣。private是訪問權限修飾符（access permission modifier），而static是存儲說明（storage class specifier），兩者是*完全*不同的概念。——強烈要求你仔細閱讀相關書籍以免誤導大家。

char repeatVariableWithoutDefinition1; /*declear thrice no hurt*/——真的no hurt嗎？

強調一點：編譯單元和源文件是有區別的。

地方大人少，當然可以一人一間，哈哈。

@楊粼波
同意。博主牛。

覺得模塊劃分粒度不夠細。可以分成兩個類，這樣復用程度高一點：
1、m_szFreeList的每個表項可以封裝成一個類。策略很多，找一個合適的就行。比如：
｜ｈｅａｄ
ｖ
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
｜ｓｉｚｅ｜　　　　｜／／／／｜ｓｉｚｅ｜　　　　｜／／／／｜ｓｉｚｅ｜
｜－－－－｜ｆｒｅｅ｜／／／／｜－－－－｜ｆｒｅｅ｜／／／／｜－－－－｜ｆｒｅｅ
｜ｎｅｘｔ｜　　　　｜／／／／｜ｎｅｘｔ｜　　　　｜／／／／｜ｎｅｘｔ｜
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
　　　｜　　　　　　　　　　　︿　｜　　　　　　　　　　　　︿　｜
　　　｜　　　　　　　　　　　｜　｜　　　　　　　　　　　　｜　ｖ
　　　　－－－－－－－－－－－　　　－－－－－－－－－－－－　　ＮＵＬＬ
當然，復雜性會有很大的增加，比如合并內存碎片。
2、用你的hash表來組織第一個類的對象。

最好不要用單件。

可以使用簡化的slab來做內存池/對象池——雖然不支持可變長度對象，但其使用范圍更廣也更靈活。

怎么可能一樣？
你試試成員是其他類對象的情況看看。如A和B兩個類示范的。

還有各種資源比如打開的文件，進程描述符，線程描述符等等。

表達式的lvalue是不可修改的，可修改的只有其rvalue。因為當一個表達式具有lvalue時，它在內存中的位置是固定的，也就是lvalue是固定的。所謂修改表達式的值只是通過其lvalue來修改其rvalue。
比如
int i = 10;
假定i的地址為0x1000，那么i的lvalue是0x1000，rvalue是10，
i = 100;
則表示0x1000存放的內容也就是rvalue被修改成100，而不是i的lvalue——0x1000被修改成別的值，其內容為100。

如果：
“* 操作符應用與左值表達式，以表達式左值為地址，取出表達式類型的值，作為右值返回。”

那么：
int foo(int *p)
{
return (*p)++; // Or *p += 1;
}
如何解釋？

還有內核里的spinlock

沒看過apue吧

tar xvfz *.tgz
OR:
gzip -d *.tgz | tar xvf -

正準備寫一篇類似的東西。被你搶先了……
還有沒有必要寫呢？

@cuigang
謝謝！可我數學不行怎么辦？

@cuigang
你強烈推薦的一定要試試！
不過不知道需要什么預備知識？我對于SICP沒有概念。另外，這本書全名是什么？

4)越早讓你的程序投入調試越好.
東拼西湊最容易導致調試時間過長。
這點我基本不同意。

1)程序不會出錯,出錯的肯定是人;如果程序出錯了,那也一定是人的錯誤.
強烈同意！！！newbie與professional的區別之一就是newbie總認為是系統的錯，professional總從自身找原因。

剛才吃西瓜時突然想到：base* p1=&derived(); 后，臨時對象已不復存在，然而編譯器依然會將該臨時對象的內存區解析為base，然而vtbl中的內容依然指向derived::Print()，為base加上析構，這樣vtbl先是指向derived::Print()，而后調用~base()時，該臨時對象的類型變成了base，vtbl表項被糾正為指向base::Print()。

@control
同意你的觀點。
博主曾說自己的C/C++水平足以應付工作。然而，我不得不說，有很多理解是錯的，表面看起來可以工作，且例子也能論證你的觀點，那只不過是碰巧了而已。而且總是以C的觀點來看待C++，這是很危險的。

@創
“C++對我而言就是有STL帶class能處理多態,繼承的C. ”
最初的C++大體是這樣，除了STL。
然而，現在還這么想的話，犯下這個錯誤是必然——C++的對象模型遠不止C那么簡單，背后有很多事情需要注意的。甚至，有時候構造函數是否為inline就決定了代碼是否為二進制兼容。

我喜歡第六條！

@路緣
也沒啥問題了——我沒有仔細考慮，時間緊，我只拿了5分鐘來寫這個。

@路緣
看來沒有唬住你。你的理解是沒錯的，呵呵。
除了del_substr()，別的還有問題嗎？

你傳遞的是引用，上哪生成臨時對象去？所以不是臨時變量的問題，而是類型檢查的事。如果提供了隱式轉換，你的代碼就沒有問題，所以KDEVELOP不會抱怨。

這幾行代碼里面有寫錯誤，不知道你看出來了沒有？呵呵。希望你能改掉這些錯誤。

感覺博主對于傳參方式（傳值）沒有理解。
函數原型有錯誤：無法返回該字符串。感覺下面會好一點：
char* del_substr(char* str, const char * substr);
說不用字符串操作函數，我就hack一把——自己寫操縱字符串的庫函數，呵呵……：
ssize_t Strlen(const char* str)
{
ssize_t len = 0;
while (*str++) ++len;
return len;
}

int StrCmp(const char* str1, const char* str2, ssize_t len)
{
for (int i = 0; i < len; ++i)
{
if (*(str1 + i) != *(str2 + i))
return (*(str1 + i) - *(str2 + i));
}
return 0;
}

char* del_substr(char* str, const char * substr)
{
char* temp = NULL;
ssize_t len = Strlen(substr);
while (*substr++ && *str++)
{
if (*substr == *str)
{
if (!StrCmp(substr, str, len))
{
temp = str + len;
while (*temp++)
{
*str++ = *temp;
}
break;
}
}
}
return str;
}

觀點狹隘。我身邊的程序員可都是高智商高情商的——與人打交道不夠圓滑那是因為沒有把所有的精力放到這上面。

C++ "*"三種意思:
1. 乘號
2. dereference運算符
3. 復合類型中聲明/定義指針變量

關于多態：
編譯時：模板、重載
運行時：通過虛表
運行時多態相關的概念：靜態類型、動態類型。
個人觀點，僅供參考

@嘯天豬
數組名是lvalue。但lvalue不是object with name，而是內存區域的引用。這個問題我更傾向于cuigang的說法，雖然他用的是地址。
臨時對象是右值，呵呵。
我對于lvalue和rvalue的理解基本上是錯誤的，呵呵，多謝cuigang和豬了。

@cuigang
仔細查閱了一些資料，發現對于lvalue和rvlaue的說明各有不同。找了兩個比較經典的說法，共同參考一下。下面是在comp.lang.c++.moderated上找到的（為避免斷章取義，貼全文）：
The simplest explanation I know is that an rvalue, in current C++, is an *expression* that produces a value, e.g. 42, and an lvalue is an *expression* that just refers to some existing object or function[1]. Hence the acronym "locator value"[2], which however is still misleading because an lvalue is simply not a value. Better would be *rexpression* versus *lexpression*, and even better, just value versus reference (unfortunately the term "reference" is already hijacked).

"object" versus "value": in C++ the basic definition of "object" is a region of storage, i.e. anything that actually occupies storage, while a pure value such as 42 doesn't necessarily occupy any storage. A value (an rvalue) can be an object, though. If it is, then it's a temporary object.

C++ allows you to call member functions on a class type rvalue, i.e. on a temporary class type object.

The ability to call member functions on (class type) rvalues, together with C++'s treatment of assignment operator as a member function (automatically generated if needed and none defined), means that you can assign to class type rvalues. However, C++ does not regard that rvalue to be *modifiable*: to be
well-defined, the assignment must do something else than modifiying the object assigned to (and typically we indicate that by declaring the assignment operator const). §3.10/14 "A program that attempts to modify an object through a nonmodifyable lvalue or rvalue expression is ill-formed".

Fine point: §3.10/14 means that rvalue-ness transfers to parts of an rvalue, which are thereby also considered rvalues. However, at least the two compilers I use don't seem to know that rule. Comeau Online does.

I'm not sure if the explanation above holds up with respect to C++0x rvalue references. rvalue versus lvalue got a lot more complicated in C++ than in original C. Perhaps it's even more complicated in C++0x, I don't know. :-)

Cheers, & hth.,
- Alf

Notes:
[1] Amazingly that's also the general definition the standard starts out with, before going into details: §3.10/2 "An lvalue refers to an object or function", however, it would have helped much if the word "expression" was explicitly included there, not just by being mentioned in the preceding paragraph.
[2] Unfortunately the C++ standard doesn't use or even mention the acronym "locator value". This acronym comes from the current C standard. And ironically the C++ standard mentions, by contextual placement, the original old C acronym of "left hand value", in §3.10/4: "built-in assignment operators all expect their left hand operands to be lvalues".

Programming Cpp的解釋：
http://etutorials.org/Programming/Programming+Cpp/Chapter+3.+Expressions/3.1+Lvalues+and+Rvalues/

你的解釋更接近真相，呵呵，不過我還是不同意地址一說，用引用會比較好一些。要不你整理一下，就lvalue和rvalue專門寫一篇？

看來俺還得多看看標準啊。
我的C++標準丟了，給發一個？raof01@gmail.com。

@cuigang
我始終不同意這句話：“表達式的左值是它的地址，右值是該地址所存儲的內容。”因為無論地址還是內容，都是對象。而且按照你這句話，x = x + 1;第一個x是個地址，第二個x是其內容，假設x是T類型，那么上述表達式就應該理解為=左邊是個地址，也就是T*，對吧？矛盾就來了，你把T類型的值賦給了T*。
“雖然言語之中仍然為自己辯護，不過大家觀點畢竟更加接近了”——剛才又仔細看了一遍你的文章，我堅持我第一個評論里的觀點，除了“&操作符能作用于左值和右值”這個錯誤。
我認為：因為你的第一個觀點是全文的核心，所以我們之間還存在巨大的分歧。

@cuigang
你別無奈啊，給個理由先。
我的依據是：左/右值指的是表達式。單純就x這個表達式來說，它是個左值，無論在=左邊還是右邊。

@cuigang
你舉的例子x=x+1;其中x無論是在左邊還是右邊都是左值，表達式"x+1"才是右值。

@cuigang
請注意我的用詞（有咬文嚼字之嫌，見諒）：返回、對象、表達式。對象包括很多：指針、字面常量、臨時對象……我認為我們之間的分歧在于你把我說的對象細分了。

“但 & 操作符的確只能應用于有左值的表達式”——你是對的，我的錯誤。

“至于你鏈接的文章，請恕我未能洞悉，不知里面哪里提到 解引用操作符可以用于右值，或者隱含此意味。”——實際我想說明的就是“但是間接尋址（indirection）反而說明了你的觀點，它是將指針變量的右值作為地址來訪問指向物，類似的有‘.’，‘->’運算符。”，因為我把指針當作對象的一種。

“我說指向數組的指針費解，不是說我不理解，只是說大多數人實際中難以見到，不好理解，如果你可以理解，你可以說說它和多維數組 arr[][] 的 指針 arr[2] 有什么區別。”我相信你理解了，否則也不會寫出這么有深度的文章。T arr[]中arr的類型是T[]，&arr的類型就是T(*)[]；但是，T arr[][]中arr的類型是T * arr[]，&arr的類型是T**——最后這點是因為C中二位數組是線性存儲的，不是我們所理解的二維矩陣。

——向你的認真致敬！呵呵

sorry，上面有個錯誤：a[10] = x; 改為 a[0] = x;

@嘯天豬
"左值未必都是可修改的，例如數組名就是不可修改的左值"：數組名不是左值。注意我說的話：*返回*可修改對象……數組名是一個* const，不是左值。簡言之：int a[10];可以有int * p = a; a[10] = x;但不能有a = p;
“但是對于user defined type 的右值，在某些情況下是允許被修改;例如對于函數返回的臨時對象，調用non-const member function是合法的”：臨時對象不一定是右值。*返回*不可修改對象……
討論就是討論，沒有罵人的，看來大家都是好人。哈哈，這里不錯。

雖然你的想法已經有很多人這么做了，不過我覺得你自己想出來也很了不起，敬仰啊。

幾個錯誤：
左值：返回一個可修改對象的表達式稱為左值
右值：返回一個不可修改對象的表達式稱為右值
*操作符返回的對象可能是左值也可能是右值
&操作符可用于左值和右值
*操作符的操作數可以是右值（請參考“映射設備寄存器到內存”http://blog.chinaunix.net/u/12783/showart_385250.html）
arr是T [100]，那么&arr就是T (*)[100]，沒什么費解的

類型轉換（非引用）必然會產生一個臨時對象。所有的一切問題都可以歸結到這里：
((TestStr)(*p_ts)).SetId(9);//產生non-const臨時對象，SetId()操作的是臨時對象，因此原對象不變
((TestStr&)(*p_ts)).SetId(9);//去掉原對象的const。可以寫成const_cast<TestStr&>(*p_ts)).SetId(9)
((TestStr)(*p_ts)).id = 9; //GCC可以編譯
(&((TestStr)(*p_ts)))->id = 9; //編譯通過

不錯。不過我認為xObjectCreator不需要繼承xBaseCreator——已經通過模板來得到一定的多態性了。

@某Programmer
你的說法有失偏頗。有些時候可以通過一些技術上的細節問題來考interviewee，此時并不是要考他的記憶，而是看他的思考方式。也就是那句話：你的答案是錯的，但我喜歡你的思考方式。

有很多人學過幾天C++，就敢在簡歷上寫“精通C++”，這種人被BS了活該。另：應用程序員對于library的實現還是很陌生的，考慮的也不會很多，博主要求有點高。

打著C++旗號的C

//時空性能還行，比樓主的代碼難看多啦~~
template <size_t N1, size_t N2>
void Convert(int (&array)[N1][N2])
{
int all = N1 * N2;
int i = 0;
int j = -1;
int direction = 0;
int val = 0;
while(val < all)
{
if (0 == direction)
{
++j;
if (j < N2 && -1 == array[i][j])
{
array[i][j] = val;
}
else
{
direction = 1;
--j;
}
}
if (1 == direction)
{
++i;
if (i < N1 && -1 == array[i][j])
{
array[i][j] = val;
}
else
{
direction = 2;
--i;
}
}
if (2 == direction)
{
--j;
if (j >= 0 && -1 == array[i][j])
{
array[i][j] = val;
}
else
{
direction = 3;
++j;
}
}
if (3 == direction)
{
--i;
if (i >= 0 && -1 == array[i][j])
{
array[i][j] = val;
}
else
{
direction = 0;
++i;
--val;
}
}
++val;
}
}

先逆序再輸出比遞歸高效。
N個節點，遞歸就存在N次函數調用，而先逆序再輸出就2次調用（分兩個函數寫的話）——當然不包括調用其他函數。其他函數如print()調用次數是固定的。假設N巨大，還有可能出現棧問題，而先做逆序僅僅是指針的賦值循環。

實際上，引用的底層實現就是指針。可以將引用看作無需dereference就可使用指向的內存的指針。

樓主——麻煩你給出解題思路好不好？光看代碼太費勁了，而且我不喜歡看代碼。