答案：輸出8。由于在pPoint->z的前面加上了取地址符號，運行到此時的時候，會在pPoint的指針地址上加z在類型Point3D中的偏移量8。由于pPoint的地址是0，因此最終offset的值是8。
&(pPoint->z)的語意是求pPoint中變量z的地址（pPoint的地址0加z的偏移量8），并不需要訪問pPoint指向的內存。只要不訪問非法的內存，程序就不會出錯。
題目（七）：運行下列C++代碼，輸出什么？
class A
{
public:
A()
{
Print();
}
virtual void Print()
{
printf("A is constructed.\n");
}
};
class B: public A
{
public:
B()
{
Print();
}
virtual void Print()
{
printf("B is constructed.\n");
}
};
int _tmain(int argc, _TCHAR* argv[])
{
A* pA = new B();
delete pA;
return 0;
}
答案：先后打印出兩行:A is constructed. B is constructed. 調用B的構造函數時，先會調用B的基類及A的構造函數。然后在A的構造函數里調用Print。由于此時實例的類型B的部分還沒有構造好，本質上它只是A的一個實例，他的虛函數表指針指向的是類型A的虛函數表。因此此時調用的Print是A::Print，而不是B::Print。接著調用類型B的構造函數，并調用Print。此時已經開始構造B，因此此時調用的Print是B::Print。
同樣是調用虛擬函數Print，我們發現在類型A的構造函數中，調用的是A::Print，在B的構造函數中，調用的是B::Print。因此虛函數在構造函數中，已經失去了虛函數的動態綁定特性。
題目（12）：運行下圖中的C++代碼，輸出是什么？
#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。請選擇正確答案并分析原因。
#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++代碼，輸出是什么？
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);
return 0;
}
答案：4, 1, 100, 4。pString1是一個指針。在32位機器上，任意指針都占4個字節的空間。*pString1是字符串pString1的第一個字符。一個字符占一個字節。pString2是一個數組，sizeof(pString2)是求數組的大小。這個數組包含100個字符，因此大小是100個字節。而在函數SizeOf中，雖然傳入的參數是一個字符數組，當數組作為函數的參數進行傳遞時，數組就自動退化為同類型的指針。因此size4也是一個指針的大小，為4.
題目（15）：運行下圖中代碼，輸出的結果是什么？這段代碼有什么問題？
#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。用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++代碼，輸出是什么？
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。
這一題的關鍵在于理解確定缺省參數的值是在編譯的時候，但確定引用、指針的虛函數調用哪個類型的函數是在運行的時候。
問題（16）：運行如下的C++代碼，輸出是什么？
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。
這一題的關鍵在于理解確定缺省參數的值是在編譯的時候，但確定引用、指針的虛函數調用哪個類型的函數是在運行的時候。
問題（19）：運行下圖中C代碼，輸出的結果是什么？
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的值，會是相同的。