【原文鏈接】
http://www.cnblogs.com/hellogiser/p/100-interview-questions-of-cplusplus-basics-11-20.html
【題目11】
運行下面中的C#代碼，輸出是什么？
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
namespace
StringValueOrReference { class Program { internal static void ValueOrReference(Type type) { String result = "The type " + type.Name; if (type.IsValueType) Console.WriteLine(result + " is a value type." ); else Console.WriteLine(result + " is a reference type." ); } internal static void ModifyString(String text) { text = "world" ; } static void Main( string [] args) { String text = "hello" ; ValueOrReference(text.GetType()); ModifyString(text); Console.WriteLine(text); } } } |
【分析】
輸出兩行。第一行是The type String is reference type. 第二行是hello。類型String的定義是public sealed class String {...}，既然是class，那么String就是引用類型。在方法ModifyString里，對text賦值一個新的字符串，此時改變的不是原來text的內容，而是把text指向一個新的字符串"world"。由於參數text沒有加ref或者out，出了方法之后，text還是指向原來的字符串，因此輸出仍然是"hello".
【題目12】
運行下圖中的C++代碼，輸出是什么？
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
#include
<iostream> class A { private : int n1; int n2; public : A(): n2( 0 ), n1(n2 + 2 ) { } void Print() { std::cout << "n1: " << n1 << ", n2: " << n2 << std::endl; } }; int _tmain( int argc, _TCHAR *argv[]) { A a; a.Print(); return 0 ; } |
【分析】
輸出n1是一個隨機的數字，n2為0。在C++中，成員變量的初始化順序與變量在類型中的申明順序相同，而與它們在構造函數的初始化列表中的順序無關。因此在這道題中，會首先初始化n1，而初始n1的參數n2還沒有初始化，是一個隨機值，因此n1就是一個隨機值。初始化n2時，根據參數0對其初始化，故n2=0。
【題目13】
編譯運行下圖中的C++代碼，結果是什么？（A）編譯錯誤；（B）編譯成功，運行時程序崩潰；（C）編譯運行正常，輸出10。請選擇正確答案並分析原因。
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
#include
<iostream> class A { private : int value; public : A( int n) { value = n; } A(A other) { value = other.value; } void Print() { std::cout << value << std::endl; } }; int _tmain( int argc, _TCHAR *argv[]) { A a = 10 ; A b = a; b.Print(); return 0 ; } |
【分析】
編譯錯誤。在復制構造函數中傳入的參數是A的一個實例。由於是傳值，把形參拷貝到實參會調用復制構造函數。因此如果允許復制構造函數傳值，那么會形成永無休止的遞歸並造成棧溢出。因此C++的標准不允許復制構造函數傳值參數，而必須是傳引用或者常量引用。在Visual Studio和GCC中，都將編譯出錯。
【題目14】
運行下圖中的C++代碼，輸出是什么？
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
#include
"stdafx.h"
int SizeOf( char pString[]) { return sizeof (pString); } int _tmain( int argc, _TCHAR *argv[]) { char *pString1 = "google" ; int size1 = sizeof (pString1); int size2 = sizeof (*pString1); char pString2[ 100 ] = "google" ; int size3 = sizeof (pString2); int size4 = SizeOf(pString2); printf( "%d, %d, %d, %d" , size1, size2, size3, size4); // 4,1,100,4 return 0 ; } |
【分析】
4, 1, 100, 4。pString1是一個指針。在32位機器上，任意指針都占4個字節的空間。*pString1是字符串pString1的第一個字符。一個字符占一個字節。pString2是一個數組，sizeof(pString2)是求數組的大小。這個數組包含100個字符，因此大小是100個字節。而在函數SizeOf中，雖然傳入的參數是一個字符數組，當數組作為函數的參數進行傳遞時，數組就自動退化為同類型的指針。因此size4也是一個指針的大小，為4。
【題目15】
運行下圖中代碼，輸出的結果是什么？這段代碼有什么問題，如何改正？
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
#include
"stdafx.h"
#include <iostream> class A { public : A() { std::cout << "A is created." << std::endl; } ~A() { std::cout << "A is deleted." << std::endl; } }; class B : public A { public : B() { std::cout << "B is created." << std::endl; } ~B() { std::cout << "B is deleted." << std::endl; } }; int _tmain( int argc, _TCHAR *argv[]) { A *pA = new B(); delete pA; return 0 ; } /* A is created. B is created. A is deleted. */ |
【分析】
輸出三行，分別是：A is created. B is created. A is deleted。會導致內存泄露，在A的析構函數前加上virtual關鍵字。
用new創建B時，回調用B的構造函數。在調用B的構造函數的時候，會先調用A的構造函數。因此先輸出A is created. B is created.接下來運行delete語句時，會調用析構函數。由於pA被聲明成類型A的指針，同時基類A的析構函數沒有標上virtual，因此只有A的析構函數被調用到，而不會調用B的析構函數。
由於pA實際上是指向一個B的實例的指針，但在析構的時候只調用了基類A的析構函數，卻沒有調用B的析構函數，這會導致內存泄露。如果在類型B中創建了一些資源，比如文件句柄、內存等，在這種情況下都得不到釋放，從而導致資源泄漏。
【題目16】
運行如下的C++代碼，輸出是什么？
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
#include
"stdafx.h"
#include <iostream> class A { public : virtual void Fun( int number = 10 ) { std::cout << "A::Fun with number " << number; } }; class B: public A { public : virtual void Fun( int number = 20 ) { std::cout << "B::Fun with number " << number; } }; int main() { B b; A &a = b; a.Fun(); } |
【分析】
輸出B::Fun with number 10。由於a是一個指向B實例的引用，因此在運行的時候會調用B::Fun。但缺省參數是在編譯期決定的。在編譯的時候，編譯器只知道a是一個類型a的引用，具體指向什么類型在編譯期是不能確定的，因此會按照A::Fun的聲明把缺省參數number設為10。這一題的關鍵在於理解確定缺省參數的值是在編譯的時候，但確定引用、指針的虛函數調用哪個類型的函數是在運行的時候。
【題目17】
運行如下的C代碼，輸出是什么？
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
#include
"stdafx.h"
char *GetString1() { char p[] = "Hello World" ; return p; } char *GetString2() { char *p = "Hello World" ; return p; } int _tmain( int argc, _TCHAR *argv[]) { printf( "GetString1 returns: %s. \n" , GetString1()); printf( "GetString2 returns: %s. \n" , GetString2()); return 0 ; } |
【分析】
輸出兩行，第一行GetString1 returns: 后面跟的是一串隨機的內容，而第二行GetString2 returns: Hello World. 兩個函數的區別在於GetString1中是一個數組，而GetString2中是一個指針。
當運行到GetString1時，p是一個數組，會開辟一塊內存，並拷貝"Hello World"初始化該數組。接着返回數組的首地址並退出該函數。由於p是GetString1內的一個局部變量，當運行到這個函數外面的時候，這個數組的內存會被釋放掉。因此在_tmain函數里再去訪問這個數組的內容時，結果是隨機的。當運行到GetString2時，p是一個指針，它指向的是字符串常量區的一個常量字符串。該常量字符串是一個全局的，並不會因為退出函數GetString2而被釋放掉。因此在_tmain中仍然根據GetString2返回的地址得到字符串"Hello World"。
【題目18】
運行下圖中C代碼，輸出的結果是什么？
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
#include
"stdafx.h"
int _tmain( int argc, _TCHAR *argv[]) { char str1[] = "hello world" ; char str2[] = "hello world" ; char *str3 = "hello world" ; char *str4 = "hello world" ; if (str1 == str2) printf( "str1 and str2 are same.\n" ); else printf( "str1 and str2 are not same.\n" ); if (str3 == str4) printf( "str3 and str4 are same.\n" ); else printf( "str3 and str4 are not same.\n" ); return 0 ; } |
【分析】
輸出兩行。第一行是str1 and str2 are not same，第二行是str3 and str4 are same。
str1和str2是兩個字符串數組。我們會為它們分配兩個長度為12個字節的空間，並把"hello world"的內容分別拷貝到數組中去。這是兩個初始地址不同的數組，因此比較str1和str2的值，會不相同。str3和str4是兩個指針，我們無需為它們分配內存以存儲字符串的內容，而只需要把它們指向"hello world“在內存中的地址就可以了。由於"hello world”是常量字符串，它在內存中只有一個拷貝，因此str3和str4指向的是同一個地址。因此比較str3和str4的值，會是相同的。
【題目19】
運行下圖中的C++代碼，打印出的結果是什么？
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
#include
"stdafx.h"
bool Fun1( char *str) { printf( "%s\n" , str); return false ; } bool Fun2( char *str) { printf( "%s\n" , str); return true ; } int _tmain( int argc, _TCHAR *argv[]) { bool res1, res2; res1 = (Fun1( "a" ) && Fun2( "b" )) || (Fun1( "c" ) || Fun2( "d" )); res2 = (Fun1( "a" ) && Fun2( "b" )) && (Fun1( "c" ) || Fun2( "d" )); return res1 || res2; } |
【分析】
打印出4行，分別是a、c、d、a。
在C/C++中，與、或運算是從左到右的順序執行的。在計算rest1時，先計算Fun1(“a”) && Func2(“b”)。首先Func1(“a”)打印出內容為a的一行。由於Fun1(“a”)返回的是false, 無論Func2(“b”)的返回值是true還是false，Fun1(“a”) && Func2(“b”)的結果都是false。由於Func2(“b”)的結果無關重要，因此Func2(“b”)會略去而不做計算。接下來計算Fun1(“c”) || Func2(“d”)，分別打印出內容c和d的兩行。
在計算rest2時，首先Func1(“a”)打印出內容為a的一行。由於Func1(“a”)返回false，和前面一樣的道理，Func2(“b”)會略去不做計算。由於Fun1(“a”) && Func2(“b”)的結果是false，不管Fun1(“c”) && Func2(“d”)的結果是什么，整個表達式得到的結果都是false，因此Fun1(“c”) && Func2(“d”)都將被忽略。
【題目20】
運行下面的C++代碼，打印的結果是什么？
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
#include
"stdafx.h"
#include <iostream> using namespace std; class Base { public : void print() { doPrint(); } private : virtual void doPrint() { cout << "Base::doPrint" << endl; } }; class Derived : public Base { private : virtual void doPrint() { cout << "Derived::doPrint" << endl; } }; int _tmain( int argc, _TCHAR *argv[]) { Base b; b.print(); Derived d; d.print(); return 0 ; } |
【分析】
輸出兩行，分別是Base::doPrint和Derived::doPrint。在print中調用doPrint時，doPrint()的寫法和this->doPrint()是等價的，因此將根據實際的類型調用對應的doPrint。所以結果是分別調用的是Base::doPrint和Derived::doPrint2。如果感興趣，可以查看一下匯編代碼，就能看出來調用doPrint是從虛函數表中得到函數地址的。
【參考】
http://zhedahht.blog.163.com/blog/static/2541117420111169592105/
http://zhedahht.blog.163.com/blog/static/254111742011299219769/
http://zhedahht.blog.163.com/blog/static/25411174201171214133316/
【原文鏈接】
http://www.cnblogs.com/hellogiser/p/100-interview-questions-of-cplusplus-basics-11-20.html