當品味完一部作品后，一定對生活有了新的感悟和看法吧，讓我們好好寫份讀后感，把你的收獲感想寫下來吧。如何才能寫出一篇讓人動容的讀后感文章呢？以下是小編為大家搜集的讀后感范文，僅供參考，一起來看看吧

c程序設計讀后感 C語言程序設計讀后感3000字篇一

轉載▼

標簽：

it

c++本身并沒有提供任何多線程機制，但是在windows下，我們可以調用sdk win32 api來編寫多線程的程序，下面就此簡單的講一下：

創建線程的函數

handle createthread（lpsecurity_attributes lpthreadattributes, // sd

size_t dwstacksize,// initial stack size

lpthread_start_routine lpstartaddress,// thread function

lpvoid lpparameter,// thread argument

dword dwcreationflags,// creation option

lpdword lpthreadid// thread identifier);

在這里我們只用到了第三個和第四個參數，第三個參數傳遞了一個函數的地址，也是我們要指定的新的線程，第四個參數是傳給新線程的參數指針。

eg1:

#include

dword winapi fun(lpvoid lpparamter)

{

while(1){ cout<<“fun display!”<

}

int main()

{

handle hthread = createthread(null, 0, fun, null, 0, null);

closehandle(hthread);

while(1){ cout<<“main display!”<

return 0;

}

我們可以看到主線程（main函數）和我們自己的線程（fun函數）是隨機地交替執行的，但是兩個線程輸出太快，使我們很難看清楚，我們可以使用函數

void sleep（dword dwmilliseconds// sleep time);

來暫停線程的執行，dwmilliseconds表示千分之一秒，所以

sleep(1000);

表示暫停1秒

eg2:

#include

dword winapi fun(lpvoid lpparamter)

{

while(1){ cout<<“fun display!”<

}

int main()

{

handle hthread = createthread(null, 0, fun, null, 0, null);

closehandle(hthread);

while(1){ cout<<“main display!”<

return 0;

}

執行上述代碼，這次我們可以清楚地看到在屏幕上交錯地輸出fun display!和main display!，我們發現這兩個函數確實是并發運行的，細心的讀者可能會發現我們的程序是每當fun函數和main函數輸出內容后就會輸出換行，但是我們看到的確是有的時候程序輸出換行了，有的時候確沒有輸出換行，甚至有的時候是輸出兩個換行。這是怎么回事？下面我們把程序改一下看看：

eg3:

#include

dword winapi fun(lpvoid lpparamter)

{

while(1){ cout<<“fun display!n”;sleep(1000);}

}

int main()

{

handle hthread = createthread(null, 0, fun, null, 0, null);

closehandle(hthread);

while(1){ cout<<“main display!n”;sleep(2000);}

return 0;

}

我們再次運行這個程序，我們發現這時候正如我們預期的，正確地輸出了我們想要輸出的內容并且格式也是正確的。下面我就來講一下此前我們的程序為什么沒有正確的運行。多線程的程序時并發地運行的，多個線程之間如果公用了一些資源的話，我們并不能保證這些資源都能正確地被利用，因為這個時候資源并不是獨占的，舉個例子吧：

eg4:

加入有一個資源 int a = 3

有一個線程函數 selfadd()該函數是使 a += a;

又有一個線程函數 selfsub()該函數是使a-= a;

我們假設上面兩個線程正在并發欲行，如果selfadd在執行的時候，我們的目的是想讓a編程6，但此時selfsub得到了運行的機會，所以a變成了0，等到selfadd的到執行的機會后，a += a，但是此時a確是0，并沒有如我們所預期的那樣的到6，我們回到前面eg2，在這里，我們可以把屏幕看成是一個資源，這個資源被兩個線程所共用，加入當fun函數輸出了fun display!后，將要輸出endl（也就是清空緩沖區并換行，在這里我們可以不用理

解什么事緩沖區），但此時main函數確得到了運行的機會，此時fun函數還沒有來得及輸出換行就把cpu讓給了main函數，而這時main函數就直接在fun display!后輸出main display!，至于為什么有的時候程序會連續輸出兩個換行，讀者可以采用同樣的分析方法來分析，在這里我就不多講了，留給讀者自己思考了。

那么為什么我們把eg2改成eg3就可以正確的運行呢？原因在于，多個線程雖然是并發運行的，但是有一些操作是必須一氣呵成的，不允許打斷的，所以我們看到eg2和eg3的運行結果是不一樣的。

那么，是不是eg2的代碼我們就不可以讓它正確的運行呢？答案當然是否，下面我就來講一下怎樣才能讓eg2的代碼可以正確運行。這涉及到多線程的同步問題。對于一個資源被多個線程共用會導致程序的混亂，我們的解決方法是只允許一個線程擁有對共享資源的獨占，這樣就能夠解決上面的問題了。

handle createmutex（lpsecurity_attributes lpmutexattributes,// sd

bool binitialowner,// initial owner

lpctstr lpname// object name);

該函數用于創造一個獨占資源，第一個參數我們沒有使用，可以設為null，第二個參數指定該資源初始是否歸屬創建它的進程，第三個參數指定資源的名稱。

handle hmutex = createmutex(null,true,“screen”);

這條語句創造了一個名為screen并且歸屬于創建它的進程的資源

bool releasemutex（handle hmutex// handle to mutex);

該函數用于釋放一個獨占資源，進程一旦釋放該資源，該資源就不再屬于它了，如果還要用到，需要重新申請得到該資源。申請資源的函數如下

dword waitforsingleobject（handle hhandle,// handle to object

dword dwmilliseconds// time-out interval);

第一個參數指定所申請的資源的句柄，第二個參數一般指定為infinite，表示如果沒有申請到資源就一直等待該資源，如果指定為0，表示一旦得不到資源就返回，也可以具體地指定等待多久才返回，單位是千分之一秒。好了，該到我們來解決eg2的問題的時候了，我們可以把eg2做一些修改，如下

eg5：

#include

handle hmutex;

dword winapi fun(lpvoid lpparamter)

{

while(1){

waitforsingleobject(hmutex, infinite);

cout<<“fun display!”<

sleep(1000);

releasemutex(hmutex);

}

}

int main()

{

handle hthread = createthread(null, 0, fun, null, 0, null);hmutex = createmutex(null, false, “screen”);

closehandle(hthread);

while(1){

waitforsingleobject(hmutex, infinite);

cout<<“main display!”<

sleep(2000);

releasemutex(hmutex);

}

return 0;

}

運行代碼正如我們所預期的輸出的內容。

c程序設計讀后感 C語言程序設計讀后感3000字篇二

1.數組

1.1數組定義時的注意點

1在c++中不提供可變化大小的數組，○即數組定義中的常量表達式不能包含變量。（來源：c++書6.1.1）

int n;cin>>n;float t[n];上例在定義數組t時，變量n沒有確定的值，即在程序執行之前，無法知道數組t的元素個數，所以這種聲明不被允許。但是可以用new動態分配,如： int n;cin>>n;float *t;t=new float[n];

2在定義數組時，可以不直接指定數組的大小，由c++編譯器根據初值表中元素的個數來自○動確定數組元素的個數。例如： int z[]={0,1,2,3,4,5,6,7,8} 3c++語言規定只能對數組中的元素進行賦值或引用，不能把整個數組作為一個整體進行賦○值或引用。（2.3是一個實例）（來源：c++書4同類型的數組之間不能相互賦值 ○如int a[5],b[5];a=b;//錯誤

strcpy(b,a);//正確

6.1.1）

1.2數組和指針的關系（來源：c++書8.2節8.2.1）

char s[5];在c++中說明了一個數組后，數組名可以作為一個指針來使用，因此s可作為一個指針使用（但它不同于指針,不能賦值運算、算術運算等）。

2.字符數組

2.1輸入字符數據 char c;cin>>c;// cin不能將輸入的空格賦給字符型變量。

();//可獲得鍵盤上輸入的每一個字符，包括空格和回車鍵。

2.2字符數組的輸入/輸出（來源：c++書6.2.4）2.2.1逐個字符輸入 char c[10];for(int i=0;i<10;i++)cin>>c[i];2.2.2字符串輸入 方法1 char c[10];cin>>c;//即在輸入輸出時只給數組名

此法在輸入字符串時，遇到空格和回車就認為一個字符結束。方法2 e(字符數組名，允許輸入的最大字符個數)此法可把輸入的一行作為一個字符串送到字符數組中。

2.3字符數組和字符指針的初始化 2.3.1字符數組初始化 char tx[5]=“";2.3.2字符指針初始化 char *ptx=new char[5];ptx[0]='';2.4字符串賦值

方法1 char tx[4]=”abcd“;方法2 char tx[4];//tx=”abcd“;//錯誤，tx是數組名，不分配內存空間，不可以進行賦值操作；但是數組名可當指針使用（c++書8.2.1）。strcpy(tx,”abcd“);以上兩種方法是數組

方法3是指向數組的指針方法 方法3 char *tx;tx=new char[4];tx=”abcd“ 方法4 char *tx=”abcde“;//這相當于根據數組元素的個數，確定數組的大小。tx指針指向這個數組。

//下面實例告訴我們，不僅字符數組與字符指針有區別，用new給定內存空間大小的字符指針與沒給定內存空間大小的字符指針也是有區別的 voidmain(){

/*char s[6]=”“;

strcpy(s,”abcd“);cout<

/*char *s=new char[5];strcpy(s,”abcd“);

} cout<

char *s=”“;//分配了內存空間，但不知道大小 strcpy(s,”abcd“);//錯誤，使用時要注意！！cout<

3.指針

3.1指針可執行的運算

指針可以進行賦值運算、算術運算、關系運算。

1可以將與指針變量同類型的任一變量的地址賦給指針○2在c++中，可以（1）賦值運算：○

3同類型的指針變量之間可以將0賦給任一指針變量，其含義是初始化指針變量，使其為空○相互賦值，不同類型的經強制轉換后也可以，通常也沒意義。（2）算術運算：指針變量執行“++”或“——”，其含義是使指針變量指向下一個或上一個元素

3.2指針和數組（同1.2）3.3指向數組的指針變量

char(*p)[10];(*p)指明p是一個指針變量，再與[10]結合，表示該指針變量所指向的數據是一個一維數組，該數組由10個元素組成。3.4指針數組

由若干個同類型的指針所組成的數組稱為指針數組，數組的每個元素都是一個指針變量。定義指針數組的格式：如char *p[10];由于“[]”的優先級比“*”高，p[10]構成一個數組，再與“*”結合，指明是一個指針數組。3.5指向指針的指針變量 char **pp;3.6 new運算符

注意點：

用new運算符分配的內存空間的指針值必須保存起來，以便于delete運算符歸還已動態分配的內存，否則會出現不可預測的錯誤。3.6.1指向數組的指針 char* m_p1;m_p1=new char[10];//指針m_p1指向含有10個元素的數組空間。for(i=0;i<10;i++)m_p2[i]表示這10個數組元素。

voidmain(){ char *p1;//char b;p1=newchar[5];

//p1=”abcde“;//直接給p1賦字符串，下面for循環中是給每個元素賦值。for(inti=0;i<5;i++){ //b='c';

} p1[i]='a';//p1[i]是數組元素，不是指針

cout<

3.6.2指向指針的指針變量 char**m_p2;//指向指針的指針

m_p2=new char*[10];//指針m_p2指向含有10個元素的指針數組。for(i=0;i<10;i++)m_p2[i]表示這10個指針。

void main(){ char *p1;char **pp;p1=new char[5];pp=new char*[5];for(int i=0;i<5;i++){

p1[i]='a';=&p1[i];//pp[i]是指針

cout<

cout<

3.7 delete運算符

delete釋放的不是指針本身，而是指針所指的對象。

4.容器類std::string #include

#include

std::string str=”abc“;

std::string::iterator cit=();

for(;cit!=null;++cit)//null比較，我估計肯定不對，雖然你說是可以通過編譯

{

std::cout<<*cit<

}

return 0;}

4.容器類vector 4.1迭代器和指針的區別

有時需要使用指向vector的一個指針，我們可以這樣來做。

vector

v;

如果你在一個不好的環境中，()代替&v[0]，因為（這些討厭的家伙將會告訴你）begin返回指向vector內部的迭代器，而對于vector，其迭代器實際上是指針。那經常是正確的，但正如條款50所說，并不總是如此，你不該依賴于此。

begin的返回類型是iterator，而不是一個指針，當你需要一個指向vector內部數據的指針時絕不該使用begin。()，就應該鍵入&*()，因為這將會產生和&v[0]相同的指針。

這表明迭代器的內容*()才是vector中第一個元素。

4.2 容器vector的函數clear（）

清空vector里所有的元素。因此，如amprocesslist析構函數里一個個刪除vector中所有的元素是多此一舉。

5.關鍵字operator 它是說明符，用于重載運算符。

6.函數可以將一個處理的結果值通過函數的return語句返回，也可以通過參數將處理的多個結果帶給調用者。

c++語言在處理函數調用時，參數是自右向左依次入棧的

7.類的前置聲明

char* bjarne在他的the c++ programming language里面給出過一個助記的方法： 把一個聲明從右向左讀。

char * constcp;(* 讀成 pointer to)cp is a const pointer to char--->cp是一個指向字符char的固定指針

const char * ptr;ptr is a pointer to const char;--->ptr是一個指向固定字符char的指針

char const * p;--->無此形式 也就是說,cp和ptr都是指針,cp的值是不可改變的cp指向的內容是可變的;而ptr的值是可以改變的,ptr指向的內容是不可變的

轉化為constchar*,const char*轉化為char* 1.在string里面string.c_str()函數把string轉換為了const char*.○代碼如下：

stringa=”abcd“;const char*p=a.c_str();2const_cast

將const char*轉換為char*.○ char*p=const_cast

(a.c_str());

char *p;char *s=”“;char *t=null;p沒分配內存，s分配了內存，t為空，11.變量的初始化 1指針需要初始化； ○2基本數據類型聲明的變量需要初始化；如double m_dvalue；m_dvalue=0； ○3類聲明的對象不需要初始化。○

12.派生類中的一般成員函數和虛函數 classa { public: voidsolid(){cout<<”基類實函數“<<'n';} virtualvoidvir(){cout<<”基類虛函數“<<'n';} };classaa:publica { public: voidsolid(){cout<<”派生類實函數“<<'n';} virtualvoidvir(){cout<<”派生類虛函數“<<'n';} };

voidmain(){ a* a=newa;aa* aa=newaa;a=aa;

a->vir();//vir()是虛函數。它是運行時的多態性，即在程序運行時，根據具體的執行情況來動態的確定。因此輸出”派生類虛函數“，而不是“基類虛函數”

a->solid();//solid()是一般成員函數。它是編譯時的多態性，即程序編譯時就覺得會調用哪個函數。因為a是a類對象的指針，即使派生類aa對象的指針aa賦給a，在編譯是已經覺得調用基類a的solid函數，因此輸出“基類虛函數”而不是“派生類虛函數”

aa->vir();aa->solid();

aa->a::solid();aa->a::vir();}

button newbtn = new button();on = new (128, 110); = ”newbtn“; = new (75, 23); = ”button2";ualstylebackcolor = true;(newbtn);

///清除新生成的btn (newbtn);

cbutton* ctexteditorview::newmybutton(int nid,crect rect,int nstyle){ cstring m_caption;ring(nid);//取按鈕標題 cbutton *p_button = new cbutton();assert_valid(p_button);p_button->create(m_caption, ws_child | ws_visible | bs_pushbutton | nstyle, rect, this, nid);//創建按鈕 return p_button;}

c程序設計讀后感 C語言程序設計讀后感3000字篇三

unit one對象的演化

oop技術能夠很容易地將大量問題歸納為一個簡單的解，這一發現產生了大量的oop語言，其中最著名的是smalltalk—c++之前最成功的oop語言。

繼承表示了基本類型和派生類型之間的相似性，程序員創建一個基本類型以描述系統中一些對象的思想核心。由這個基本類型派生出其他類型，表達了認識該核心的不同途徑。

早捆綁意味著編譯器對特定的函數名產生調用，而連接器確定調用執行代碼的絕對地址。對于。oop采用動態綁定。當給對象發送消息時，在程序運行之前不去確定被調用的代碼。編譯器保證這個被調用的函數存在，并完成參數和返回值的類型檢查，但是它不知道將執行的準確代碼。為了實現晚捆綁，編譯器在真正調用的地方插入一段特殊的二進制代碼。通過使用存放在對象自身中的信息，這段代碼在運行時計算被調用函數的地址。這樣，每個對象就能根據一個指針的內容有不同的行為。當一個對象接收到消息時，它根據這個消息判斷應當做什么。

程序員可以用關鍵字v i r t u a l表明他希望某個函數有晚捆綁的靈活性，而并不需要懂得v i r t u a l的使用機制。沒有它，就不能用c + +做面向對象的程序設計。vi r t u a l函數（虛函數）表示允許在相同家族中的類有不同的行為。這些不同是引起多態行為的原因。

用c 語言編寫的過程程序就是一些數據定義和函數調用。要理解這種程序的含義，程序員必須掌握函數調用和函數實現的本身。這就是過程程序需要中間表示的原因。中間表示容易引起混淆，因為中間表示的表述是原始的，更偏向于計算機，而不偏向于所解決的問題。

通常，面向對象程序需要較少的代碼，因為問題中的許多部分都可以用已存在的庫代碼。

c+ +成功的原因是經濟上的：轉變到o o p需要代價，而轉變到c + +所花的代價較小。盡可能地為程序員提供最大便利。

為c + +堵塞了c語言中的一些漏洞，并提供更好的類型檢查和編譯時的分析。程序員必須先說明函數，使編譯器能檢查它們的使用情況。預處理器虛擬刪除值替換和宏，這就減少了查找疵點的困難。c + +有一個性能，稱為r e f e r e n c e s(引用)，它允許對函數參數和返回值的地址進行更方便的處理。函數重載改進了對名字的處理，使程序員能對不同的函數使用相同的名字。另外，名字空間也加強了名字的控制。許多性能使c的更安全。面向對象的c + +程序的速度與用c寫的程序速度相差在± 1 0 %之內，而且常常更接近。用o o p方法設計的程序可能比c的對應版本更有效。

c+ +的主要目標是讓程序員能更容易地使用庫，這是通過將庫轉換為新數據類型（類）來完成的。引入一個庫，就是向該語言增加一個新類型。編譯器負責這個庫如何使用，保證適當的初始化和清除，保證函數被正確地調用。

? 模板的源代碼重用

一些重要的類型要求修改源代碼以便有效地重用。模板可以自動完成對代碼的修改，因而是重用庫代碼特別有用的工具。用模板設計的類型很容易與其他類型一起工作。因為模板對程序員隱藏了這類代碼重用的復雜性，所以特別好用。

c + +的異常處理（見第1 7章的內容）保證能檢查到錯誤并進行處理。

c語言同樣有這樣的限制，例如當程序超過50 000行時，名字沖突就開始成為問題。簡言之，程序員用光了函

數和變量名。設計c + +的目的是為了輔助大程序設計，也就是說，去掉小程序和大程序之間復雜性的分界。

程序設計有兩個原則：

1)內部原則體現在程序自身的結構中，機靈而有見解的程序員可以通過程序設計語言的表達方式了解這種內部原則。

2)外部原則體現在程序的源信息中，一般被描述為“設計文檔”（不要與產品文檔混淆）。

過程語言：為科學工作者使用的f o rt r a n（f o r m u l a-t r a n s l a t i o n）和為商業者使用的c o b o l

（common business-oriented language）。純計算機科學中很成功的語言是l i s p（l i s t-p r o c e s s i n g），而面向數學的語言應當是a p l（a programming l a n g u a g e）。

1.3.4 對象設計的五個階段

1)對象發現這個階段出現在程序的最初分析期間。可以通過尋找外部因素與界線、系統中的元素副本和最小概念單元而發現對象。如果已經有了一組類庫，某些對象是很明顯的。類之間的共同性（暗示了基類和繼承類），可以立刻出現或在設計過程的后期出現。

2)對象裝配我們在建立對象時會發現需要一些新成員，這些新成員在對象發現時期未出現過。對象的這種內部需要可能要用新類去支持它。

3)系統構造對對象的更多要求可能出現在以后階段。隨著不斷的學習，我們會改進我們的對象。與系統中其它對象通訊和互相連接的需要，可能改變已有的類或要求新類。

4)系統擴充當我們向系統增添新的性能時，可能發現我們先前的設計不容易支持系統擴充。這時，我們可以重新構造部分系統，并很可能要增加新類。

5)對象重用這是對類的真正的重點測試。如果某些人試圖在全新的情況下重用它，他們會發現一些缺點。當我們修改一個類以適應更新的程序時，類的一般原則將變得更清楚，直到我們有了一個真正可重用的對象。

對象開發原則

1)讓特殊問題生成一個類，然后在解其他問題時讓這個類生長和成熟。

2)記住，發現所需要的類，是設計系統的主要內容。如果已經有了那些類，這個項目就不困難了。

3)不要強迫自己在一開始就知道每一件事情，應當不斷地學習。

4)開始編程，讓一部分能夠運行，這樣就可以證明或反駁已生成的設計。不要害怕過程語言風格的細面條式的代碼—類分割可以控制它們。壞的類不會破壞好的類。

5)盡量保持簡單。具有明顯用途的不太清楚的對象比很復雜的接口好。我們總能夠從小的和簡單的類開始，當我們對它有了較好地理解時再擴展這個類接口，但不可能簡化已存在的類接口。

第2章數據抽象

庫，簡單地說就是一些人已經寫的代碼，按某種方式包裝在一起。通常，最小的包是帶有擴展名如l i b的文件和向編譯器聲明庫中有什么的一個或多個頭文件。連接器知道如何在l i b文件中搜索和提取相應的已編譯的代碼。但是，這只是提供庫的一種方法。在跨越多種體系結構的平臺上，例如u n i x，通常，提供庫的最明智的方法是用源代碼，這樣在新的目標機上它能被重新編譯。而在微軟wi n d o w s上，動態連接庫是最明智的方法，這使得我們能夠利用新發布的d d l經常修改我們的程序，我們的庫函數銷售商可能已經將新d d l發送給我們了。

2.1 聲明與定義

“聲明”向計算機介紹名字，它說，“這個名字是什么意思”。而“定義”為這個名字分配存儲空間。無論涉及到變量時還是函數時含義都一樣。無論在哪種情況下，編譯器都在“定義”處分配存儲空間。對于變量，編譯器確定這個變量占多少存儲單元，并在內存中產生存放它們的空間。對于函數，編譯器產生代碼，并為之分配存儲空間。函數的存儲空間中有一個由使用不帶參數表或帶地址操作符的函數名產生的指針。定義也可以是聲明。如果該編譯器還沒有看到過名字a，程序員定義int a，則編譯器馬上為這個名字分配存儲地址。聲明常常使用于e x t e r n關鍵字。如果我們只是聲明變量而不是定義它，則要求使用e x t e r n。對于函數聲明，e x t e r n是可選的，不帶函數體的函數名連同參數表或返回值，自動地作為一個聲明。

c+ +要求必須寫出函數原型（的全部信息），因為它增加了一個重要的安全層。

c程序設計讀后感 C語言程序設計讀后感3000字篇四

c++編程書評

最近一段時間都在看c++編程，想讓自己對計算機有更多的了解，和更好的運用，這也是對自我的一種知識面的一種提升。更多的可能還是出于自己對這方面的熱愛吧。那我就把我讀后對書本的了解，不過大多數都是書上的一些重點還有一些專業術語。主要也是對這本書的大概介紹吧！

用c 語言編寫的過程程序就是一些數據定義和函數調用。要理解這種程序的含義，程序員必須掌握函數調用和函數實現的本身。這就是過程程序需要中間表示的原因。中間表示容易引起混淆，因為中間表示的表述是原始的，更偏向于計算機，而不偏向于所解決的問題。

通常，面向對象程序需要較少的代碼，因為問題中的許多部分都可以用已存在的庫代碼。

c+ +成功的原因是經濟上的：轉變到o o p需要代價，而轉變到c + +所花的代價較小。盡可能地為程序員提供最大便利。

為c + +堵塞了c語言中的一些漏洞，并提供更好的類型檢查和編譯時的分析。程序員必須先說明函數，使編譯器能檢查它們的使用情況。預處理器虛擬刪除值替換和宏，這就減少了查找疵點的困難。c + +有一個性能，稱為r e f e r e n c e s(引用)，它允許對函數參數和返回值的地址進行更方便的處理。函數重載改進了對名字的處理，使程序員能對不同的函數使用相同的名字。另外，名字空間也加強了名字的控制。許多性能使c的更安全。面向對象的c + +程序的速度與用c寫的程序速度相差在± 1 0 %之內，而且常常更接近。用o o p方法設計的程序可能比c的對應版本更有效。

c+ +的主要目標是讓程序員能更容易地使用庫，這是通過將庫轉換為新數據類型（類）來完成的。引入一個庫，就是向該語言增加一個新類型。編譯器負責這個庫如何使用，保證適當的初始化和清除，保證函數被正確地調用。

模板的源代碼

一些重要的類型要求修改源代碼以便有效地重用。模板可以自動完成對代碼的修改，因而是重用庫代碼特別有用的工具。用模板設計的類型很容易與其他類型一起工作。因為模板對程序員隱藏了這類代碼重用的復雜性，所以特別好用。c語言同樣有這樣的限制，例如當程序超過50 000行時，名字沖突就開始成為問題。簡言之，程序員用光了函數和變量名。設計c + +的目的是為了輔助大程序設計，也就是說，去掉小程序和大程序之間復雜性的分界。

程序設計有兩個原則

1)內部原則體現在程序自身的結構中，機靈而有見解的程序員可以通過程序設計語言的表達方式了解這種內部原則。

2)外部原則體現在程序的源信息中，一般被描述為“設計文檔”（不要與產品文檔混淆）。

對象設計的五個階段

1)對象發現這個階段出現在程序的最初分析期間。可以通過尋找外部因素與界線、系統中的元素副本和最小概念單元而發現對象。如果已經有了一組類庫，某些對象是很明顯的。類之間的共同性（暗示了基類和繼承類），可以立刻出現或在設計過程的后期出現。

2)對象裝配我們在建立對象時會發現需要一些新成員，這些新成員在對象發現時期未出現過。對象的這種內部需要可能要用新類去支持它。

3)系統構造對對象的更多要求可能出現在以后階段。隨著不斷的學習，我們會改進我們的對象。與系統中其它對象通訊和互相連接的需要，可能改變已有的類或要求新類。

4)系統擴充當我們向系統增添新的性能時，可能發現我們先前的設計不容易支持系統擴充。這時，我們可以重新構造部分系統，并很可能要增加新類。

5)對象重用這是對類的真正的重點測試。如果某些人試圖在全新的情況下重用它，他們會發現一些缺點。當我們修改一個類以適應更新的程序時，類的一般原則將變得更清楚，直到我們有了一個真正可重用的對象。

對象開發讓特殊問題生成一個類，然后在解其他問題時讓這個類生長和成熟。2 記住，發現所需要的類，是設計系統的主要內容。如果已經有了那些類，這個項目就不困難了。不要強迫自己在一開始就知道每一件事情，應當不斷地學習。

4開始編程，讓一部分能夠運行，這樣就可以證明或反駁已生成的設計。不要害怕過程語言風格的細面條式的代碼—類分割可以控制它們。壞的類不會破壞好的類。盡量保持簡單。具有明顯用途的不太清楚的對象比很復雜的接口好。我們總能夠從小的和簡單的類開始，當我們對它有了較好地理解時再擴展這個類接口，但不可能簡化已存在的類接口。

庫

簡單地說就是一些人已經寫的代碼，按某種方式包裝在一起。通常，最小的包是帶有擴展名如l i b的文件和向編譯器聲明庫中有什么的一個或多個頭文件。連接器知道如何在l i b文件中搜索和提取相應的已編譯的代碼。但是，這只是提供庫的一種方法。在跨越多種體系結構的平臺上，例如u n i x，通常，提供庫的最明智的方法是用源代碼，這樣在新的目標機上它能被重新編譯。而在微軟wi n d o w s上，動態連接庫是最明智的方法，這使得我們能夠利用新發布的d d l經常修改我們的程序。

聲明與定義

“聲明”向計算機介紹名字，它說，“這個名字是什么意思”。而“定義”為這個名字分配存儲空間。無論涉及到變量時還是函數時含義都一樣。無論在哪種情況下，編譯器都在“定義”處分配存儲空間。對于變量，編譯器確定這個變量占多少存儲單元，并在內存中產生存放它們的空間。對于函數，編譯器產生代碼，并為之分配存儲空間。函數的存儲空間中有一個由使用不帶參數表或帶地址操作符的函數名產生的指針。定義也可以是聲明。如果該編譯器還沒有看到過名字a，程序員定義int a，則編譯器馬上為這個名字分配存儲地址。聲明常常使用于e x t e r n關鍵字。如果我們只是聲明變量而不是定義它，則要求使用e x t e r n。對于函數聲明，e x t e r n是可選的，不帶函數體的函數名連同參數表或返回值，自動地作為一個聲明。

或許你看過后或許懂了一點，也對編程有了初步的了解，希望我的書評對你能有所幫助!