- 相關推薦
計算機二級《C++》考點解析：堆和類數組
為幫助同學們更好更有準備地復習計算機二級C++，以下是百分網小編搜索整理的計算機二級《C++》考點解析：堆和類數組，供參考復習，希望對大家有所幫助!想了解更多相關信息請持續關注我們應屆畢業生考試網!
一、構造函數和析構函數
前面的例子已經運用了new和來為類對象分配和釋放內存。當使用new為類對象分配內存時，編譯器首先用new運算符分配內存，然后調用類的構造函數;類似的，當使用來釋放內存時，編譯器會首先調用淚的析構函數，然后再調用運算符。
#include iostream.h
class Date
{
int mo,da,yr;
public:
Date() { cout < ~Date() { cout< }
int main()
{
Date* dt = new Date;
cout < dt;
return 0;
}
程序定義了一個有構造函數和析構函數的Date類，這兩個函數在執行時會顯示一條信息。當new運算符初始化指針dt時，執行了構造函數，當運算符釋放內存時，又執行了析構函數。
程序輸出如下：
Date constructor
Process the date
Date destructor
二、堆和類數組
前面提到，類對象數組的每個元素都要調用構造函數和析構函數。下面的例子給出了一個錯誤的釋放類數組所占用的內存的例子。
#include iostream.h
class Date
{
int mo, da, yr;
public:
Date() { cout < ~Date() { cout< }
int main()
{
Date* dt = new Date[5];
cout < dt; //這兒
return 0;
}
指針dt指向一個有五個元素的數組。按照數組的定義，編譯器會讓new運算符調用Date類的構造函數五次。但是被調用時，并沒有明確告訴編譯器指針指向的Date對象有幾個，所以編譯時，只會調用析構函數一次。下面是程序輸出;
Date constructor
Date constructor
Date constructor
Date constructor
Date constructor
Process the date
Date destructor
為了解決這個問題，C++允許告訴運算符，正在刪除的那個指針時指向數組的，程序修改如下：
#include iostream.h
class Date
{
int mo, da, yr;
public:
Date() { cout < ~Date() { cout< }
int main()
{
Date* dt = new Date[5];
cout < [] dt; //這兒
return 0;
}
最終輸出為：
Date constructor
Date constructor
Date constructor
Date constructor
Date constructor
Process the date
Date destructor
Date destructor
Date destructor
Date destructor
Date destructor
三、重載new和運算符
前面已經介紹了如何用new和運算符函數來動態第管理內存，在那些例子中使用的都是全局的new和運算符。我們可以重載全局的new和運算符，但這不是好的想法，除非在進行低級的系統上或者嵌入式的編程。
但是，在某個類的內部重載new和運算符時可以的。這允許一個類有它自己的new和運算符。當一個類需要和內存打交道時，采用這種方法來處理其中的細節，可以獲得很搞的效率，同時避免了使用全局new和運算符帶來的額外開銷。因為全局堆操作時調用操作系統函數來分配和釋放內存，這樣效率很低。
如果確定某個類在任何時候，其實例都不會超過一個確定的值，那么就可以一次性為類的所有實例分配足夠的內存，然后用該類的new和運算符來管理這些內存。下面的程序說明了如何對new和進行重載。
#include iostream.h
#include string.h
#include stddef.h
#include new.h
const int maxnames = 5;
class Names
{
char name[25];
static char Names::pool[];
static bool Names::inuse[maxnames];
public:
Names(char* s) { strncpy(name,s,sizeof(name)); }
void* operator new(size_t) throw(bad_alloc);
void operator (void*) throw();
void display() const { cout < };
char Names::pool[maxnames * sizeof(Names)];
bool Names::inuse[maxnames];
void* Names::operator new(size_t) throw(bad_alloc)
{
for(int p=0; p {
if(!inuse[p])
{
inuse[p] = true;
return pool+p*sizeof(Names);
}
}
throw bad_alloc();
}
void Names::operator (void* p) throw()
{
if(p!=0)
inuse[((char*)p - pool)/sizeof(Names)] = false;
}
int main()
{
Names* nm[maxnames];
int i;
for(i=0; i {
cout < char name[25];
cin >> name;
nm[i] = new Names(name);
}
for(i=0; i {
nm[i]- >display();
nm[i];
}
return 0;
}
上面的程序提示輸入5個姓名，然后顯示它們。程序中定義了名為Names的類，它的構造函數初始化對象的name值。這個類定義了自己的new和運算符。這是因為程序能保證不會一次使用超過maxnames個姓名，所以可以通過重載默認的new和運算符來提高運行速度。
Names類中的內存池是一個字符數組，可以同時容納程序需要的所有姓名。與之相關的布爾型數組inuse為每個姓名記錄了一個true和false值，指出內存中的對應的項是否正在使用。
重載的new運算符在內存池中尋找一個沒有被使用的項，然后返回它的地址。重載的運算符則標記那些沒有被使用的項。
在類定義中重載的new和運算符函數始終是靜態的，并且沒有和對象相關的this指針。這是因為編譯器會在調用構造函數之前調用new函數，在調用析構函數后調用函數。
new函數是在類的構造函數之前被調用的。因為這時內存中還不存在類的對象而且構造函數也沒有提供任何初始化值，所以它不可以訪問類的任何成員。同理，運算符是在析構函數之后被調用的，所以它也不可以訪問類的成員。
四、異常監測和異常處理
1.檢測異常
上面的例子還缺少必要的保護機制。比如，重載的運算符函數并沒有檢查它的參數，確認其是否落在內存池內部。如果你絕對相信自己編的程序中不會傳遞錯誤的指針值給運算符，那么可以省掉合法性檢查以提高效率，特別是在優先考慮效率的程序中。否則應該使用預編譯的條件語句。在軟件的測試版本中加入這些檢測，在正式的發行版本中去掉這些檢查。
2.重載new和中的異常處理
上面的兩個重載運算符函數都是用了異常處理。異常處理是C++的新內容之一，目前還沒有講到。在這里不必關心它是如何工作的。上面程序中，當試圖分配超過內存池容量的Names緩沖區，重載的new運算符函數就會拋出異常，終止程序。
--------------------------------------------------------------------------------
五、重載new[]和[]
對于上面的程序，假如有下面的語句:
Names *nms=new Names[10]
...
[] nms;
那么，這些語句會調用全局new和運算符，而不是重載過的new和。為了重載能為對象數組分配內存的new和運算符，必須像下面的程序一樣，對new[]和[]也進行重載。
#include iostream.h
#include string.h
#include stddef.h
#include new.h
const int maxnames = 5;
class Names
{
char name[25];
static char Names::pool[];
static bool Names::inuse[maxnames];
public:
Names(char* s) { strncpy(name,s,sizeof(name)); }
void* operator new(size_t) throw(bad_alloc);
void operator (void*) throw();
void display() const { cout < };
char Names::pool[maxnames * sizeof(Names)];
bool Names::inuse[maxnames];
void* Names::operator new[](size_t size) throw(bad_alloc)
{
int elements=size/sizeof(Names);
int p=-1;
int i=0;
while((i {
if(!inuse[i]) p=i;
++i;
}
// Not enough room.
if ((p==-1) || ((maxnames-p) for(int x=0; x return pool+p*sizeof(Names);
}
void Names::operator [](void* b) throw()
{
if(b!=0)
{
int p=((char*)b- pool)/sizeof(Names);
int elements=inuse[p];
for (int i=0; i }
}
int main()
{
Names* np = new Names[maxnames];
int i;
for(i=0; i {
cout < char name[25];
cin >> name;
*(np + i) = name;
}
for(i=0; idisplay();
[] np;
return 0;
}
重載new[]和[]要比重載new和考慮更多的問題。這是因為new[]運算符時為數組分配內存，所以它必須記住數組的大小，重載的[]運算符才能正確地把緩沖區釋放回內存池。
上面的程序采用的方法比較簡單，吧原來存放緩沖區使用標志的布爾型數組換成一個整型數組，該數組的每個元素記錄new[]運算符分配的緩沖區個數，而不再是一個簡單的true。
當[]運算符函數需要把緩沖區釋放回內存池時，它就會用該數組來確認釋放的緩沖區個數
【計算機二級《C++》考點解析：堆和類數組】相關文章：
2017計算機二級C++考點類的轉換05-20
計算機二級C++考點：C++語言概述07-17
計算機二級C++函數考點07-22
2017計算機二級C++考點習題及答案07-07
計算機二級C++考點：基本控制結構01-25
計算機二級C++程序題及答案解析12-29
2016年計算機二級C++復習資料：類對象數組和靜態成員08-04
計算機二級C++模擬題及解析201603-10