C++程序設(shè)計
成都創(chuàng)新互聯(lián)是一家專業(yè)提供魚臺企業(yè)網(wǎng)站建設(shè),專注與成都做網(wǎng)站、成都網(wǎng)站制作、H5場景定制、小程序制作等業(yè)務。10年已為魚臺眾多企業(yè)、政府機構(gòu)等服務。創(chuàng)新互聯(lián)專業(yè)網(wǎng)絡公司優(yōu)惠進行中。
之前學過C++課程，但是時間有點久，忘了很多，這里做一個簡單的回顧。
網(wǎng)站推薦： C++在線編譯器
學習C++之前，您可以先了解C語言。
c++的擴展名一般為cpp（cplusplus）。
補充： 這里介紹了如何編譯和執(zhí)行C++文件，即一般需要下面的步驟：
在文件的外面shift + 右鍵單擊，選擇cmd打開文件（cpp的外層文件）
g++ 文件名.cpp -o test
test
通過這三步就可以編譯C++文件了。
注意：1. 每次如果修改了文件，都需要在g++ 文件名.cpp -o test來重新編譯文件得到文件名.exe可執(zhí)行文件，然后在執(zhí)行即可。這時新的可執(zhí)行文件就可以覆蓋舊的可執(zhí)行文件。
2. 在notepad++中的設(shè)置-> 語言設(shè)置中將語言設(shè)置為C++
第一部分： 面向?qū)ο蟪绦蛟O(shè)計概述
1 面向過程的程序設(shè)計和面向?qū)ο蟮某绦蛟O(shè)計
面向?qū)ο蟪绦蛟O(shè)計與面向過程程序設(shè)計有著本質(zhì)的區(qū)別。
面向過程程序設(shè)計是以功能為中心，數(shù)據(jù)和操作數(shù)據(jù)的函數(shù)（或過程）相分離，程序的基本構(gòu)成單位是函數(shù)。
而面向?qū)ο蟪绦蛟O(shè)計是以數(shù)據(jù)為中心，數(shù)據(jù)和操作數(shù)據(jù)的函數(shù)被封裝成一個對象，與外界向分隔，對象之間通過消息進行通信，使得各對象完成相應的操作，程序的基本構(gòu)成單位是對象。
簡單地說，面向過程的程序設(shè)計是以函數(shù)為基本構(gòu)成單位； 而面向?qū)ο蟮某绦蛟O(shè)計是以對象為基本構(gòu)成單位。
2. 為什么C++是面向?qū)ο蟮某绦蛟O(shè)計？ 面向過程的程序設(shè)計有什么不足呢？
面向過程的程序設(shè)計是圍繞功能進行的，用一個函數(shù)實現(xiàn)一個功能。 所有的數(shù)據(jù)都是公用的，一個函數(shù)可以使用任何一組數(shù)據(jù)，而一組數(shù)據(jù)又可以被多個函數(shù)所使用。 當程序規(guī)模較大時、數(shù)據(jù)很多時，程序設(shè)計者往往感到難以應付。 所以面向過程的程序設(shè)計往往只適用于規(guī)模較小的程序。
面向過程的程序設(shè)計其數(shù)據(jù)是公有的，誰也沒有辦法限制其他的程序員不去修改全局數(shù)據(jù)，也不能限制其他程序員在函數(shù)中定義與全局數(shù)據(jù)同名的全局變量，故很不安全。
由于面向過程程序設(shè)計的基本單位是函數(shù)，所以代碼重用的最大粒度就是函數(shù)，對于今天的軟件開發(fā)來說，程序修改的難度很大。
基于以上面向過程的程序設(shè)計的不足，人們提出了面向?qū)ο蟮某绦蛟O(shè)計。
3. 面向?qū)ο蟮木幊趟枷?/strong>
（1）客觀世界中的事物都是對象（object），對象之間存在一定的關(guān)系。
（2）用對象的屬性（attribute）描述事物的靜態(tài)特征，用對象的操作（operation）描述事物的行為（動態(tài)特征）。
（3）把對象的屬性和操作結(jié)為一體，形成一個相對獨立、不可分的實體。對象對外屏蔽其內(nèi)部細節(jié)，只留下少量接口，以便和外界聯(lián)系。
（4）通過抽象對對象進行分類，把具有相同屬性和相同操作的對象歸為一類，類是這些對象的描述，每個對象是其所屬類的一個實例。
（5）復雜的對象可以使用簡單的對象作為其構(gòu)成部分。
（6）通過在不成程度上運用抽象的原則，可以得到一般類和特殊類。特殊類可以繼承一般類的屬性和操作，從而簡化系統(tǒng)的構(gòu)造過程。
（7）對象之間通過傳遞消息進行通信，以實現(xiàn)對象之間的動態(tài)聯(lián)系。
（8）通過關(guān)聯(lián)表達類之間的靜態(tài)關(guān)系。
4. 面向?qū)ο蟮幕靖拍?/p>
1. 對象
從現(xiàn)實角度來說， 現(xiàn)實世界中的任何一個事物都可以看做一個對象，如汽車、房屋等，這些都是有形的；又如文章、計劃等，這些都是無形的。對象有大有小，如一個軍隊是一個對象，一個螞蟻也是一個對象。
任何一個對象都具有兩個基本要素：屬性和行為。屬性是用來描述對象的靜態(tài)特征。行為是用來描述事物的動態(tài)特征。 如一個人是一個對象，其身高、性別就可以看做屬性，其可以走路、說話、打球就可以看做其行為。
且在對象之間一定要有聯(lián)系，如電視這個對象被人這個對象按了一下開機按鈕， 電視這個對象就開機了，這就是對象與對象之間的聯(lián)系。
總結(jié)：對象具有表示靜態(tài)特征的屬性和表示動態(tài)特征的行為，對象與對象之間需要傳遞信息來聯(lián)系。
2. 類
類是對客觀世界中具有相同屬性和行為的一組對象的抽象，它為屬于該類的全部對象提供了統(tǒng)一的對象描述，其內(nèi)容同樣包括對象和屬性。
那么什么是抽象呢？ 抽象就是指忽略事物的非本質(zhì)特征，只注意那些和當前目標有關(guān)的本質(zhì)特征，從而找出事物的共性。比如人就可以看做一個類，即人類，其中他是世界上所有實體人如張三、李四、王五的抽象。
總結(jié)：類是對象的抽象，而對象則是類的實例，或者說是類的具體表現(xiàn)形式。
3. 封裝
日常生活中的封裝很多，如錄像機，從外面來看他就是一個黑盒子，在他的表面有幾個按鍵，而其內(nèi)部的電路板和機械控制部件在外面是看不到的。
這樣做的好處在于大大降低了人們操作對象的復雜程度，使用對象的人完全不需要知道對象內(nèi)部的具體細節(jié)，只需要了解其外部功能即可自如地操作對象。
在面向?qū)ο蠓椒ㄖ?，所謂“封裝”即包括兩方面的含義：（1）用對象把屬性和操縱這些屬性的操作保證起來，形成一個基本單位，各個對象之間相互獨立，互不干擾； （2）將對象中某些部分對外影藏，即影藏其內(nèi)部細節(jié)，只留下少量的接口，以便于和外部聯(lián)系，接受外界的消息。
4. 繼承
所謂繼承是特殊類自動地擁有或者是隱含地復制其一般類的全部屬性和操作。
集繼承具有‘是一種’的含義，如卡車“是一種”汽車，“轎車”是一種汽車，二者作為特殊類繼承了一般類 --汽車類的所有的屬性和操作。
我們也可以一個特殊類繼承多個一般類，這就是多繼承的概念。如繼承了“銷售”類和“經(jīng)理”類就是“銷售經(jīng)理”。
C++提供的繼承機制，就可以很方便的在一個已有的類的基礎(chǔ)上建立一個新類，這就是常說的“軟件重用”的思想。
5. 消息
對象之間通過消息進行通信，實現(xiàn)了對象之間的動態(tài)聯(lián)系。 在C++中，消息就是函數(shù)調(diào)用。
6. 關(guān)聯(lián)
關(guān)聯(lián)是兩個多多個類之間的一種靜態(tài)關(guān)系。 如一個教室類可以管理一個學生類
7. 組合
組合描述的類和類之間的整體和部分之間的關(guān)系。如汽車和發(fā)動機之間的關(guān)系就是組合。 其實，組合是關(guān)聯(lián)的一種。
8. 多態(tài)性
如某個董事長出差，他把這個消息告訴了身邊的人： 妻子、司機、秘書。 這些人聽到之后會有不同的反應：他的妻子給他準備行李、秘書為他確認考察地安排住宿、司機會為他準備車輛。 這就是多態(tài)。
在面向?qū)ο蠓椒ㄖ校^多態(tài)性是指由繼承而產(chǎn)生的相關(guān)而不同的類，其對象對同一個消息會做出不同的響應。
第二部分：基礎(chǔ)知識
1. C++是什么？
C++ 是一種靜態(tài)類型的、編譯式的、通用的、大小寫敏感的、不規(guī)則的編程語言，支持過程化編程、面向?qū)ο缶幊毯头盒途幊獭?/p>
C++ 被認為是一種中級語言，它綜合了高級語言和低級語言的特點。
C++ 是由 Bjarne Stroustrup 于 1979 年在新澤西州美利山貝爾實驗室開始設(shè)計開發(fā)的。C++ 進一步擴充和完善了 C 語言，最初命名為帶類的C，后來在 1983 年更名為 C++。
C++ 是 C 的一個超集，事實上，任何合法的 C 程序都是合法的 C++ 程序。
注意：使用靜態(tài)類型的編程語言是在編譯時執(zhí)行類型檢查，而不是在運行時執(zhí)行類型檢查。
2. 基本結(jié)構(gòu)
#include std;
// main main ()
{
cout << ; ;
}
C++定義了一些有用的頭文件，我們必須引入, 否則類似cout和cin 的輸入輸出都是不可用的。
using namespace std;這是一個語句，所以一定要用分號結(jié)尾。 這是C++中的命名空間，js中是沒有的。
// main 其中// 表示單行注釋，這里所在的語句表示程序開始的地方，我們寫代碼一般都是要在這里寫的。
下一行 int main() 是主函數(shù)，程序從這里開始執(zhí)行。
cout一定要和<<配合使用，指的是輸出。
return 0; 表示終止函數(shù)，在C++中一般都是這樣來寫的。當然， return 8; return 45;什么的都是可以的。
注意：C++中和js一樣，都是使用;分號來表示語句的結(jié)束，但是和js不同的是，js某些情況下可以省略，但是C++中永遠都不可以。
注意：我們也可以不適用 using namespace std; 但是在程序中我們?nèi)绻褂胏in和cout就必須在其前面添加 std::如下所示：
#include int main()
{ static int zhu = 15;
std::cout << zhu ;
}
最終會輸出 15
3. C++中的標識符
在C++中，可以使用字母、下劃線作為首字母，而后可以跟字母、下劃線和數(shù)字。 注意：c++中是不支持$的，這點需要格外注意。 且C++是區(qū)分大小寫的。
4. 和js一樣，C++中也有一些保留字，我們再給變量命名的時候，是不能使用的。
5. C++中的數(shù)據(jù)類型有哪些？
bool 布爾型
char 字符型
int 整型
float 浮點型
double 雙浮點型
void 無類型
wchar_t 寬字符型
上面是七種基本類型，每一種基本類型還可以使用一個多多個類型修飾符進行修飾。類型修飾符如下：
不同的類型所占的內(nèi)存是不同的，我們可以使用sizeof()方法來輸出，如下所示：
#include using namespace std;int main()
{
cout << sizeof(int) << endl << sizeof(char) << endl << sizeof(bool) << endl << sizeof(double); return 0;
}
如上面的代碼會得到 4 1 1 8，可以看出double所占的字節(jié)數(shù)是最多的。
http://www.cnblogs.com/BeyondAnyTime/archive/2012/08/23/2652696.html C++中的四種類型轉(zhuǎn)化方式。
6. typedef
C++中typedef 的作用是將一個已有的類型的名稱修改,def即定義的意思，如下所示：
typedef int zhu;
zhu vari;
那么這時的vari就是整型變量。
7. 變量的聲明和初始化
int a;
bool b;
char c;
上述都是變量的聲明。我們還可以在聲明的同時初始化。
int a = 15;
bool b = true;
char c = "good";
int e = 15, f = 45;
我們還可以看到，我們可以一次聲明并且初始化多個變量。
注意： 變量的初始化是一個好習慣，我們最好每次再定義變量的時候都要初始化；
看下面的例子：
#include using namespace std;
int main ()
{ int zhu = 20;
cout << zhu << endl ;
return 0;
}
最終會輸出20。
我們再看一個函數(shù)調(diào)用的例子。
#include using namespace std;int add();int main ()
{
add(); return 0;
}int add()
{ int zhu = 10;
cout << zhu;
}
最終會輸出20.
注意：
8. c++中的變量
一般，在c++中可以有三個地方聲明變量，一個是 代碼塊內(nèi)部聲明變量，此即局部變量。 還可以在函數(shù)的參數(shù)中聲明變量，這是形式參數(shù)。 也可以在函數(shù)外面聲明變量，這是全局變量。
其中局部變量只能在代碼塊中使用，全局變量可以在函數(shù)內(nèi)也可以在函數(shù)外，即全局變量一旦聲明，在整個程序中都是可用的。且和js一樣，可以在代碼塊中聲明和全局變量相同的名字，只是在代碼塊中使用會覆蓋全局變量。
如下：
#include using namespace std;
// 全局變量聲明int g = 20;
int main ()
{ // 局部變量聲明
int g = 10;
cout << g;
return 0;
}
最后輸出的是 10。
9. 定義常量
在C++中，定義常量有兩種方式，一種是使用 #define 常量名 常量值 顯然使用這種方式常量值的類型是不確定的。 還有一種可以確定常量值的類型的，就是使用 const 類型 變量名 = 變量值； 舉例如下：
#include using namespace std;#define zhu 100int main() { const int he = 99;
cout << zhu << endl << he;
}
此代碼最終就會輸出 100 99。
10. C++存儲類
C++中的存儲類用于定義其變量（函數(shù)）的聲明周期和范圍（可見性）。下面主要介紹幾種：
#include using namespace std;int main()
{
auto zhu = 15;
auto z = 'h';
cout << zhu << endl << z;
}
最終輸出 15（int類型）和 h（字符）
#include using namespace std;int main()
{
register int zhu = 15;
cout << zhu ;
}
#include using namespace std;int main()
{ static int zhu = 15;
cout << zhu ;
}
最終會輸出 15
11. C++中的運算符
在C++中，和其他語言一樣，都有自己的運算符，如 + - / * 等等，指的注意的是，判斷是否相等，使用 == 即可，不像js中使用 === 的情況。
想要了解更多，點擊這里。
12. C++函數(shù)
什么是函數(shù)？ 函數(shù)就是很多語句組合在一起可以做某一件事情的東西。 這就是函數(shù)。每個 C++ 程序都至少有一個函數(shù)，即主函數(shù) main() ，所有簡單的程序都可以定義其他額外的函數(shù)。
另外：C++標準庫還提供了大量的我們可以直接使用的內(nèi)置函數(shù)， 如 strcat()用于拼接兩個字符串等等。
和js的函數(shù)不同的是，C++的函數(shù)直接使用 int 即可，當然最后在函數(shù)內(nèi)部你也要返回相應的int值，如return 0; 另外就是在傳遞參數(shù)的時候要使用 int類似的類型確定其類型，舉例如下：
int max(int num1, int num2)
{ // 局部變量聲明
int result;
if (num1 > num2)
result = num1; else
result = num2;
return result;
}
這就是一個很常見的函數(shù)了， int確定函數(shù)的類型， max為函數(shù)名，我們調(diào)用函數(shù)的時候就使用該函數(shù)名。 傳入兩個參數(shù)，必須使用 類型聲明。 最后返回一個int類型的值。
當然這個是函數(shù)定義，我們也可以在前面先聲明，即 int max(int, int); 可以發(fā)現(xiàn)這里省略了 num1和num2，因為這些都是不重要的， 類型正確即可。
13. 函數(shù)參數(shù)
c++中的函數(shù)參數(shù)是形式參數(shù)，其和函數(shù)內(nèi)的其他局部變量實際上是一樣的。即在進入時被創(chuàng)建， 執(zhí)行結(jié)束被銷毀。
如下所示：
即一般情況下我們使用的是傳值調(diào)用，即這是把實際值復制給了函數(shù)的形式參數(shù)，所以，在這種情況下，修改函數(shù)內(nèi)部的形式參數(shù)對實際值沒有影響。
#include using namespace std;int a = 15;int b = 20;int modify(int, int);int main()
{
modify(a, b);
cout << "主函數(shù)的a：" <
結(jié)果如下：
函數(shù)內(nèi)部的a：100函數(shù)內(nèi)部的b：40主函數(shù)的a：15主函數(shù)的b：20
可以看到： 在函數(shù)內(nèi)部修改了傳進來的參數(shù)，只是修改了clone版本，并沒有修改真正的a和b。 這也就是傳值調(diào)用。
在C++的函數(shù)中，我們也可以使用 參數(shù)的默認值，即如果傳入了該參數(shù)，那么就是用； 如果沒有傳入，就是用默認值，如下所示：
int sum(int a, int b=20)
{ int result;
result = a + b;
return (result);
}
14. C++中的數(shù)字運算
我們可以引入 cmath庫，然后使用C++自帶的數(shù)字運算的函數(shù)，舉例如下:
#include
#include using namespace std;int main()
{int a = -10;double b = 4.54;float c = 45.2;
cout << abs(a) << endl << sqrt(b) <
注意：這里必須引用 cmath庫，即 #include 然后就可以使用諸如 sqrt() abs() pow() floor() sin() cos() tan()之類的函數(shù)了。
15. 數(shù)組
在C++中聲明數(shù)組的方法很簡單，即：
int numbers[10];
其中int也可以換成其他你需要的類型，如 double等 。 在變量名后面的數(shù)字一定要大于0，這里為10表示這個數(shù)組中可以放下長度為10的數(shù)。
我們還可以初始化數(shù)組，只是這里初始化數(shù)組使用的是{}，在數(shù)組的定義和初始化方面C++和js的差別較大。如下所示：
#include
using namespace std;
int main()
{
int numbers[8] = {45, 12, 85, 56};
cout << numbers[0] << endl<< numbers[1] << endl<< numbers[2] << endl<< numbers[3] << endl;
}
最終的輸出結(jié)果： 45， 12， 85， 56
我們也可以不限制數(shù)組的長度： 如 int numbers[] = {45, 12, 85, 56};
16. C++字符串
在C++中，由于字符串的特殊性，一般情況下，我們是需要單獨來將字符串的。在C++中有兩種方式表示，一種是引入的C語言風格的，另一種是C++特有的。
char str[] = {'h', 'e', 'l', 'l','o', '\0'};
字符串實際上是使用 null 字符 '\0' 終止的一維字符數(shù)組。因此，一個以 null 結(jié)尾的字符串，包含了組成字符串的字符。 可以看出，這里字符串的寫法與數(shù)組非常相似。
還可以寫成下面這種形式：
char str[] = "hello";
上面兩種方式的字符串的效果是一樣的。
最終的存儲形式就是這樣，最后一位是使用null占位表示結(jié)束。
在C++中，有大量的處理字符串的內(nèi)置函數(shù)，如果希望使用這樣函數(shù)，需要引入cstring（正如數(shù)學運算引入了cmath一樣）舉例如下所示：
#include
#include using namespace std;int main()
{ char str1[] = "zhuzhenwei"; char str2[] = "hetingting";
cout << strlen(str1) << endl << strlen(str2) << endl;
cout << strcat(str1, str2) << endl;
}
最終輸出：10 10 zhuzhenweihetingting
上面所說的都是C語言中字符串的實現(xiàn)，下面的是C++的。
C++ 標準庫提供了 string 類類型，支持上述所有的操作，另外還增加了其他更多的功能。
看下面的例子:
#include
#include using namespace std;int main ()
{ string str1 = "Hello"; string str2 = "World"; string str3; int len ; // 復制 str1 到 str3
str3 = str1;
cout << "str3 : " << str3 << endl; // 連接 str1 和 str2
str3 = str1 + str2;
cout << "str1 + str2 : " << str3 << endl; // 連接后，str3 的總長度
len = str3.size();
cout << "str3.size() : " << len << endl; return 0;
}
值得注意的是： 這里引入的是：#include 而不再是 #include , 兩者的區(qū)別在哪呢？
顯然，cstring是c語言中的string，而string就是C++中類string，所以這里我們用到了鏈式調(diào)用，可以看出面向?qū)ο蟮腃++使用起來多么方便，如果js也可以這樣隨便引入，就太好了。
17. C++指針
C++中比較有特色的當然就是指針了。這也是我復習C++的一個理由~ 看完這個就要睡覺啦~ 好困啊
哈哈，讓我們先來看一看教程的說法：
學習 C++ 的指針既簡單又有趣。通過指針，可以簡化一些 C++ 編程任務的執(zhí)行，還有一些任務，如動態(tài)內(nèi)存分配，沒有指針是無法執(zhí)行的。所以，想要成為一名優(yōu)秀的 C++ 程序員，學習指針是很有必要的。
恩，加油吧，撿起來這一部分內(nèi)容，先看看下面的代碼：
#include using namespace std;int main ()
{ int var1; char var2[10];
cout << "var1 變量的地址： ";
cout << &var1 << endl;
cout << "var2 變量的地址： ";
cout << &var2 << endl; return 0;
}
這和之前的有什么區(qū)別的？ 恩，就是多了個&， 這在C++中是用來取地址的，即你這個變量住在哪？（變量的內(nèi)存地址） 看看輸出的結(jié)果：
var1 變量的地址： 0x7fff9d7403ec
var2 變量的地址： 0x7fff9d7403f0
0X是指16進制的數(shù)字。
那么什么是指針呢？
指針是一個變量，其值為另一個變量的地址，即，內(nèi)存位置的直接地址。聲明指針的方式如下：
type *name;
如 int *p; 這里就聲明了一個p指針，注意：這里帶有*, 是說我聲明了一個指針，但是并不是說*p是指針，因為p才是真正的指針，而*p是指這個p指針所指向地址的值。 *和指針是密切相關(guān)的。如下面的聲明方式都是有效的指針聲明：
int *ip; /* 一個整型的指針 */double *dp; /* 一個 double 型的指針 */float *fp; /* 一個浮點型的指針 */char *ch /* 一個字符型的指針 */
看看這個在C++中使用指針的例子：
#include
using namespace std;int main ()
{ int var = 20; // 實際變量的聲明
int *ip; // 指針變量的聲明
ip = &var; // 在指針變量中存儲 var 的地址，因為指針的值是地址！?。。。。。。。。?nbsp;而&var 就是在取變量var 的地址。
cout << "Value of var variable: ";
cout << var << endl; // 輸出在指針變量中存儲的地址
cout << "Address stored in ip variable: ";
cout << ip << endl; // 訪問指針中地址的值
cout << "Value of *ip variable: ";
cout << *ip << endl; // 這里ip是指針，它的值就是地址，而*ip是地址所在的值，故最終是20
return 0;
}
結(jié)果如下：
Value of var variable: 20
Address stored in ip variable: 0x7fff99a46294
Value of *ip variable: 20
18. C++引用
引用變量是一個別名，也就是說，它是某個已存在變量的另一個名字。一旦把引用初始化為某個變量，就可以使用該引用名稱或變量名稱來指向變量。
首先需要明白的是：引用不同于指針。
通俗的講（個人理解），引用就是一個人的小名?？?，比如指明了我這個大名：
int zzw = 8;
即8是我的身體，而zzw是代表我這個身體的大名 。
但是我還可以起一個小名，如下：
int& pig = zzw;
也就是說無論是大名zzw還是小名pig都指得是我自己， 叫我什么我都答應。
實例如下：
#include
using namespace std;int main ()
{ int zzw = 8; int& pig = zzw;
cout << zzw << endl << pig << endl;
cout << "對引用進行修改" <
最終的結(jié)果如下所示：
88對引用進行修改2020
可以看到叫我小名我也答應你了（修改一個變量的引用，實際上就是修改它自己）。
19. C++數(shù)據(jù)結(jié)構(gòu)
在C和C++的數(shù)組中可以定義存儲相同數(shù)據(jù)類型的變量。 但是在C++中還提供了數(shù)據(jù)結(jié)構(gòu)，在這個數(shù)據(jù)結(jié)構(gòu)里我們可以定義不同類型的變量。
具體應用舉例如下：
#include
#include
using namespace std;
// 聲明一個結(jié)構(gòu)體類型 Books struct Books
{ char title[50]; char author[50]; char subject[100]; int book_id;
};
int main( )
{
Books Book1; // 定義結(jié)構(gòu)體類型 Books 的變量 Book1
Books Book2; // 定義結(jié)構(gòu)體類型 Books 的變量 Book2
// Book1 詳述
strcpy( Book1.title, "C++ 教程");
strcpy( Book1.author, "Runoob");
strcpy( Book1.subject, "編程語言");
Book1.book_id = 12345;
// Book2 詳述
strcpy( Book2.title, "CSS 教程");
strcpy( Book2.author, "Runoob");
strcpy( Book2.subject, "前端技術(shù)");
Book2.book_id = 12346;
// 輸出 Book1 信息
cout << "第一本書標題 : " << Book1.title <
另外，數(shù)據(jù)結(jié)構(gòu)也可以作為參數(shù)傳遞進去，如下所示：
#include
#include
using namespace std;
void printBook( struct Books book );
// 聲明一個結(jié)構(gòu)體類型 Books struct Books
{ char title[50]; char author[50]; char subject[100]; int book_id;
};
int main( )
{
Books Book1; // 定義結(jié)構(gòu)體類型 Books 的變量 Book1
Books Book2; // 定義結(jié)構(gòu)體類型 Books 的變量 Book2
// Book1 詳述
strcpy( Book1.title, "C++ 教程");
strcpy( Book1.author, "Runoob");
strcpy( Book1.subject, "編程語言");
Book1.book_id = 12345;
// Book2 詳述
strcpy( Book2.title, "CSS 教程");
strcpy( Book2.author, "Runoob");
strcpy( Book2.subject, "前端技術(shù)");
Book2.book_id = 12346;
// 輸出 Book1 信息
printBook( Book1 );
// 輸出 Book2 信息
printBook( Book2 );
return 0;
}
void printBook( struct Books book )
{
cout << "書標題 : " << book.title <
20. C++中的函數(shù)重載
文章C++的函數(shù)重載無疑是非常棒的，這里僅僅摘錄一部分做一個簡單的了解，日后必定深入。
1. 什么是函數(shù)重載？
函數(shù)重載是指在同一作用域內(nèi)，可以有一組具有相同函數(shù)名，不同參數(shù)列表的函數(shù)，這組函數(shù)被稱為重載函數(shù)。重載函數(shù)通常用來命名一組功能相似的函數(shù)，這樣做減少了函數(shù)名的數(shù)量，避免了名字空間的污染，對于程序的可讀性有很大的好處。
下面就是函數(shù)重在的例子，即實現(xiàn)一個打印函數(shù)：
#includeusing namespace std;void print(int i)
{
cout<<"print a integer :"<
最終的輸出如下：
print a integer :12print a string :hello world!
即我們調(diào)用函數(shù)名相同的函數(shù)（實現(xiàn)的功能也大抵相似）返回的值確實不同的。
2.為 什么要函數(shù)重載？
試想如果沒有函數(shù)重載機制，如在C中，你必須要這樣去做：為這個print函數(shù)取不同的名字，如print_int、print_string。這里還只是兩個的情況，如果是很多個的話，就需要為實現(xiàn)同一個功能的函數(shù)取很多個名字，如加入打印long型、char*、各種類型的數(shù)組等等。這樣做很不友好！
類的構(gòu)造函數(shù)跟類名相同，也就是說：構(gòu)造函數(shù)都同名。如果沒有函數(shù)重載機制，要想實例化不同的對象，那是相當?shù)穆闊?/p>
操作符重載，本質(zhì)上就是函數(shù)重載，它大大豐富了已有操作符的含義，方便使用，如+可用于連接字符串等。
補充：
http://www.cnblogs.com/lzjsky/archive/2011/01/24/1943199.html
靜態(tài)數(shù)據(jù)成員介紹
結(jié)束，有時間了再繼續(xù)...
2017年3月31日更新（C++進階）
今天剛剛使用MinGW 和 nodepad++ 來編譯和執(zhí)行文件了，和visual C++ 6.0是一樣的可以cin也可以cout，還是非常激動的，趁此就多復習一些知識吧。
1. 下面這是一個含有類和對象的最簡單的例子：
#include using namespace std;class Person // L類的定義{public: void SetInfo()
{
cout<<"Input info to name,sex,age"<>name>>sex>>age;
} void Show()
{
cout<<"name:"<
其中class Person用來定義一個名為Person的類，可以把類看做一個模子，然后我們用這個模子就可以創(chuàng)造形形×××的對象來了。值得注意的是，在class定義了之后，需要使用分號作為結(jié)束。
另外，使用public是說其中的內(nèi)容是公有的，可以被調(diào)用的，而privite是私有的，只能在內(nèi)部被調(diào)用。這就體現(xiàn)了著名的封裝性的特點。
這就是面向?qū)ο?，它引入了類和對象的概念，類是用戶自定義的數(shù)據(jù)類型，對象是該數(shù)據(jù)類型的變量。
2. 注意使用#define 定義常變量時，只是將變量進行了簡單的替換，如下所示：
int x=1; int y=2; #define R x+y #define PI 3.1415926 cout<而如果我們使用const float PI = 3.14；也是類似的作用，也可以寫成 float const PI = 3.14; 兩者是等效的。
3、空指針和野指針
int *p = 0; 或者是 int *p = NULL; 那么這里的p就是空指針。
而int *q; 僅僅聲明了這個指針q，但是不知道它指向了哪里，所以說是野的，即野指針。
兩者是不同的，引入空指針的目的是為了防止使用指針出錯，如果出現(xiàn)了空指針就會報錯，情況：動態(tài)分配內(nèi)存malloc()函數(shù)或new運算符的成功使用不會返回空指針，但是失敗了就會返回空指針。
如果定義了一個野指針，我們就不知道它到底會指向何處，為了避免不知指針指向了何處，在C++中一般習慣是定義了指針變量后立即初始化為空指針，然后在使用指針之前再給指針變量賦值，使指針有了具體指向之后再使用指針。
4. 指針與const
const int *p;(int const *p; 和前者是一樣的） 這個的意思p是常量，即我們不能通過 *p 來修改p所指向的值，但是可以直接修改p所指向的值， 也可以修改p的指向。
#include using namespace std;int main()
{ const int *p = NULL; int a = 20; int b = 30;
p = &a;
p = &b;
*p = 50; // error: assignment of read-only location "*p"
cout<<*p;
}
我們可以修改b的值，這樣*p會改變，也可以修改p的指向，但是如果通過*p來修改指向的值就報錯，提示*p是只讀的。
int *const p; 這里是指p指針是const的，一旦定義了，就不能修改p的指向。
#include using namespace std;int main()
{ int *const p = NULL; int a = 20; int b = 30;
p = &a; // 報錯
cout<<*p;
}
這里我已經(jīng)定義p為空指針了，那么后面p又指向a就會報錯。
const int *const p; 這里就是上述的綜合，即不能修改p的指向也不能通過*p來修改p所指向的值。
5. void和void指針
先說void ， 函數(shù) int func(void){return 0;} 和int func(){return 0;}在C++中都表示不接受任何參數(shù)，如果使用func(2)就會報錯。但是在c語言中，如果我們使用func(2)就不會報錯，所以，為了更加嚴謹，最好使用void表示不接受參數(shù)。 另外我們不能使用void a;這種形式來聲明變量，因為void表示無類型的，如果你聲明了這個變量，那么分配多少內(nèi)存呢？ 對吧。
但是void是可以聲明一個指針的。 答案是可以的。使用void聲明一個指針，我們就稱為“無類型指針”，或者就稱為void指針。 我們知道，一個類型的指針必須指向相同類型的變量，但是void指針就厲害了，它可以指向任意類型的變量。但是void類型的指針在讀取值和指針的賦值過程中需要進行強制類型轉(zhuǎn)換，原因如下：
不難想象，無論是什么類型的指針，它指向一個變量的首地址總是一樣的，所以我們才可以使用void指針，但問題是： 如果我們希望通過這個指針來訪問他所指向的變量，就得知道這個變量的類型啊，因為不同類型的變量的內(nèi)存大小是不一樣的，所以得強制類型轉(zhuǎn)化，告訴它這個變量的大小是多少，才可以讀取。
#include using namespace std;int main()
{ void *p; int a = 5; double b = 10;
p = &a;
cout<< *(int *)p;
}
如上，必須進行強制類型轉(zhuǎn)換才能正確的輸出p所指向的變量，注意：強制類型轉(zhuǎn)換是(int *)因為這是一個指針。
6. 使用new和delete動態(tài)管理內(nèi)存單元
和聲明一個變量不同，使用new一般是用來申請指針的內(nèi)存單元的，并且前者是在編譯過程中分配的內(nèi)存，而后者是在程序的執(zhí)行過程中才分配的內(nèi)存，所以是動態(tài)分配內(nèi)存。 另外，new之后一定要delete，因為聲明的方式可以自動地清除內(nèi)存，但是new的方式只能使用delete來清除內(nèi)存。
#include using namespace std;int main()
{ int *p = NULL;
p = new int;
delete p;
cout<<*p;
}
最終輸出的是16323288， 注意這是new到的一個內(nèi)存，所以這是一個隨機數(shù)。 且new和delete必須要成對存在。我們還可以在new的時候初始化，即p = new int(20); 那么*p就是20了。
那我們怎么申請連續(xù)空間的內(nèi)存呢？ 方法也很簡單，就是p = new int[20]; 這樣就可以申請到長度為20的連續(xù)空間了。
7. 引用，如 int &a = b;這就是a對b的引用，可以看做a是b的另外一個名字，但是他們指向的同一個內(nèi)存單元，所以對他們?nèi)我庖粋€的修改都是有效的。 下面我們看三個典型的例子，分別是值傳遞、指針傳遞和引用傳遞。
#include using namespace std;int fun(int a, int b)
{ int temp;
temp = a;
a = b;
b = temp;
}int main()
{ int x = 5, y = 10;
cout<<" x:"<
最后的結(jié)果都是x為5，y為10。這就是典型的值傳遞，即穿進去之后，內(nèi)部的改變不會影響外面的。
#include using namespace std;int fun(int *a, int *b)
{ int temp;
temp = *a;
*a = *b;
*b = temp;
}int main()
{ int x = 5, y = 10;
cout<<" x:"<
最后的結(jié)果是： x:5,y:10 后面是x:10,y:5 可以發(fā)現(xiàn)這個交換就完成了。 這就是典型的指針傳遞或地址傳遞。這樣，在內(nèi)部修改的*a和*b實際上就在修改x和y。
#include using namespace std;int fun(int &a, int &b)
{ int temp;
temp = a;
a = b;
b = temp;
}int main()
{ int x = 5, y = 10;
cout<<" x:"<
最后的結(jié)果是： x:5,y:10 后面是x:10,y:5 可以發(fā)現(xiàn)這個交換就完成了。 這就是典型的引用傳遞，兩者都是指向同樣的內(nèi)存，所以可以完成修改。
值得注意的是，在引用中，還是有const的，如const int &a = b;表示a這個引用是不能被修改的，即不能通過a來修改他和b共有的內(nèi)存，即a的權(quán)利只是讀。如下：
#include using namespace std;int main()
{ int x=10; const int &b = a;
b = 20;
cout<
編譯過程中就會提示b是只讀的。
8. 函數(shù)的相關(guān)問題
在c++中，無論你寫了多少，總是從main函數(shù)中開始執(zhí)行，并且在調(diào)用一個函數(shù)之前，我們必須進行函數(shù)聲明（函數(shù)聲明和函數(shù)定義不同，所以說需要用分號作為結(jié)尾），另外，main函數(shù)是最重要的，我們強烈建議將函數(shù)定義寫在main函數(shù)之后，另外， 在函數(shù)聲明的時候我們只需要將函數(shù)的類型聲明即可， 名稱不重要，編譯時不會檢查。
除此之外，我們還可以提供默認的參數(shù)，即如果沒有傳遞該參數(shù)，我們就使用默認的。且默認的參數(shù)可以使其中的一個或幾個（當然可以使全部），但是如果不是全部時， 默認的參數(shù)需從最右邊開始。
#include using namespace std;int main()
{ int add(int,int,int =50); //int add(int,int,int c=50); // 這個也是有效的，在函數(shù)什么聲明的過程中，不需要制定名字。
cout<
值得注意的是，如果使用默認參數(shù)，那么定義和聲明都需要指明默認的值，否則就會報錯。 雖然我們可以直接寫在int main()的上面，這樣就不需要聲明了，但是這并不是我們所推薦的。
函數(shù)重載： 即函數(shù)參數(shù)的類型不同或個數(shù)不同或函數(shù)參數(shù)的類型和個數(shù)都不相同。函數(shù)的返回值可以相同也可以不同，但是絕不能函數(shù)的參數(shù)形同而只有返回值不同，這不是函數(shù)的重載。如下：
#include using namespace std;int main()
{ int add(int,int); int add(int,int,int); int a = 5,b = 8; int x = 14,y = 15, z =45;
cout<
一個輸出的是13，另一個輸出的是74。
9. 詳解名字空間
我之前所寫的所有代碼中都包括： using namespace std; 不難理解，這一定和命名空間是由關(guān)系的。下面我將從頭說起。。。
（1）為什么要使用名字空間？
簡單的說，使用名字空間是為了解決程序中名字沖突的問題，即在程序運行過程中遇到相同名字的變量，系統(tǒng)不能正確的區(qū)分它們。
在一個小型系統(tǒng)里，只要我們注意一下變量就不會重復，但是對于一個大型的系統(tǒng)，由多人合作完成，我們通過#include的方式來引入不同的開發(fā)人員所編寫的程序，那就難免會遇到重名的情況，這樣就導致類全局名字空間污染。
正是為了避免這樣的問題，后來引入了名字空間的機制。（在早期的C++中，也是沒有名字空間的概念的）。
（2）什么是名字空間？
所謂名字空間就是一個由程序設(shè)計者命名的內(nèi)存區(qū)域。他可以根據(jù)需要建立一些有名字的命名空間域，把一些全局標識符分別放在不同的名字空間中，這樣就可以解決變量沖突的問題了。 就向一個文件下有一個目錄，每個子目錄又有一堆文件，那么各個目錄下的文件是可以重名的，于是就解決了問題。
（3）如何使用名字空間？
語法如下：
namespace 名字空間名
{
定義成員
}
其中成員的類型包括：常量、變量、函數(shù)、結(jié)構(gòu)體、類、模板等，還可以是名字空間，即名字空間的嵌套。如下：
本文名稱：C++程序設(shè)計
轉(zhuǎn)載來源：http://weahome.cn/article/gchodh.html
重慶分公司
重慶分公司
