規則：
應該將修飾符*  和 &緊靠變量名。例如：int  *a;  int &a;
類的版式：
類可以將數據和函數封裝起來，其中函數是表示類的行為。也可以稱為是服務。類提供了關鍵字public ,protect ,private用于聲明哪些是公共的，哪些是保護的，哪些是 私有的。這樣可以讓類隱藏必要的東西。
類的版式主要有兩種版式:
 (1):第一種將privte類型的數據 寫在前面，將public類型的數據寫在后面。采用這種版式的程序員主張“以數據為中心，”重點關注類的結構。
 (2):第二種版式是將public類型寫在前面。將private寫在后面。這種版式的程序員主張“以行為為中心”。重點關注的是類應該提供什么樣的接口（或者服務）。
我建議大家采用“以行為為中心的”的這種類的 版式。因為這樣設計類的時候。首先考慮的類可以提供什么洋的服務。而且方便用戶閱讀。

空行：
空行起著分隔程序段落的作用。
(1):在給個類的聲明之后，函數的定義之后，都要加上空行。
(2):在一個函數體內，邏輯關系密切的相關語句之間不可以加上空行。
代碼行：
(1):一行代碼指做一件事情。例如:只聲明一個變量。
(2)；if ,for while,do等語句自占一行。執行語句不能緊跟其后。
建議：在定義變量的同時。初始化該變量。
如果變量的引用和定義的地方比較遠，那么很容易就會忘記了變量的初始化。如果引用了一個沒有初始化的變量，那么很有可能就會引起錯誤。
代碼行內的空格：
(1)；關鍵字之后要有空格。向const ,virtual,case等關鍵字后面至少要留一個空格。否則的話，無法辨認關鍵字。象if.while, for等關鍵字后面緊跟一個空格在跟“（”以顯示關鍵字的。
(2):函數名之后不要留空格，緊跟“（”以和關鍵字區別。
對齊：
程序的分界符“{”和"}"應該獨占一行并且位于一列。

頭文件由三部分組成：
1：頭文件開頭出的版本和版權的 聲明。
2：預處理塊。
3：函數和類的結構聲明等。
規則：
(1): 為了防止頭文件被重復的引用，應該使用#ifndef/define/endif結構產生與處理模塊。
(2):用#include<filename.h>來引用標準庫的頭文件（編譯器將從標準庫目錄開始搜索）。
(3):用#include"filename.h"來引用非標準庫的頭文件（編譯器將從用戶工作的目錄開始搜索）
建議：頭文件中一般只存放“聲明”，而不存放“定義”

定義文件的結構：

定義文件的 內容有由三部分組成：
(1):  定義文件開頭處的版本和版權；
(2):對一些頭文件的引用；
(3):程序的實現體（包括數據和代碼）

頭文件的作用：
(1):通過頭文件來調用庫功能。在很多場合源代碼不能（或者不準）提供給用戶。只提供給用頭文件或者二進制的庫。用戶只需要按照頭文件中的接口的聲明來調用庫功能。而不必關心接口是如何實現的。編譯器會從庫中提取相應的代碼。
(2): 頭文件可以用來加強類型安全檢查。如果某個接口被實現或者被實用的時候，其方式和在頭文件中的聲明不一致的時候，編譯器就會報錯。這一簡單的規則可以大大的減輕程序員調試和改錯的負擔。
目錄結構：
如果一個軟件的頭文件比較多（超過10個），就應該把頭文件和定義文件分開。分別保存在不同的目錄之中。以便于維護。
例如：可以將頭文件保存在inluude目錄之中。將定義文件保存在source文件之中。
如果某些頭文件是私有的，不會被程序直接引用，為了加強信息隱藏。那么可以把這些頭文件和定義文件放在同一目錄之中。

指針中存有另一個對象的地址，使我們可以間接的操作這個對象。
指針的典型用法是構建一個連接的數據結構，例如：鏈表(list)和數(tree)。并管理在程序運行的過程中動態分配的對象。以及作為函數參數類型。主要用來傳遞數組和大型類的對象。
每個指針都有相關的類型。
不同數據類型的指針之間的區別不在于指針的表示上，也不是指針所持有的值（地址）。——對于所有類型的指針這兩個方面都是一樣的。不同之處在于指針所指的對象的類型上。針織類型可以指定編譯器咋樣解釋特定內存上的指定的內容，以及該內存區域因該跨越多少內存單元。

變量名，即變量的標識符，可以由字符，數字，以及下劃線來組成。他必須以字符或者下劃線來開頭，并且區分大小寫。
語言本身沒有對變量名做什么限制。但是為了用戶著想，他不應過長。
c++保留了一些詞用作關鍵字。關鍵字標識符不能在作為標識符在程序中使用了。
對于命名對象有很多已經普遍接受的習慣。主要考慮的因素的是程序的可讀性。
第一：對象的命名一般用小寫。
第二：標識符通常用容易記憶的名字。
第三：對于多詞構成的標識符一般在詞的中間加上下劃線。
對象的定義：
一個簡單的對象的定義由一個類型指示符后面加上一個名字構成，以分號結束。
例如： int aaaaa;
當同類型的多個標識符被定義的時候，我們可以在類型指示符后面用逗號隔開。
一個簡單的定義指定了變量的類型和標識符。他并不提供初始值。
如果一個變量是在全局域（globe scope）中定義的,那么系統會保證給他一個初始值0。如果一個變量是在一個局部域中定義的，或者通過一個new 動態分配的，那么系統不會向它提供初始值0。這些對象被稱為未初始化（uninitialized）,未初始化的對象不是沒有值，而是對象的值未被定義。
因為使用未初始化的對象是個很常見的  錯誤，并且很難被發現。所以建議為每個定義的對象進行初始化。
類機制通過缺省構造函數提供了類對象的自動初始化。
例如：
int  main()
{
int val；////////未被初始化的值。
string  project；//////通過string類的缺省的構造函數進行了初始化。
}


val是一個未被初始化的局部變量。
但是project是一個已經被初始化的類對象——被string類缺省的構造函數自動初始化。
初始化一個值可以在對象定義的時候進行。
c++支持兩種形式的初始化。
第一種是使用賦值符號的現實的操作。
如：
int val=111;
string  project="ssssss";
隱式形式中，初始化值被放在括號中。
int val(111);
string project("sssssss");
在對象的定義之中，當對象的標識符在定義中出現后，對象名馬上就是可見的了。因此用對象初始化他自己是合法的，只是這樣做不是明智的。
例如：int val=val;///////合法，但是不是明智的。
另外，每種內置數據類型都支持一種特殊的構造函數。可將對象初始化為0。
/////設置val為0。設置dval為0.0。
int val =int();
double dval=double();
下列的定義中：
int()
vector <int>ival(10);
函數int()自動被應用到ival包含的10個元素上。
對象可以用任意復雜的表達式來初始化，也可以用返回值

變量為我們提供了一個有名字的內存存貯空間。可以通過程序對其進行 讀寫，處理操作。
c++中給個符號變量都有一個符號類型與之對應。這個類型決定了相關內存的大小，類型，布局，能夠存貯在該內存值的范圍。以及可以以用到其上的操作集。我們也可以把變量說成是對象（object）
。
變量和文字常量都有存貯區，并且都有相關的類型。區別在于變量是可以尋址的（adressable）常量文字是不可以尋址的（nonadressable）,每一個變量都有兩個值與之聯系著，
1：數據值。存貯在內存的某個存貯區之中。有時候這個數據值也被稱為是右值（rvalue）.我們可以認為右值是被讀取的值。文字常量和變量都可以被用來做右值。
2：它的地址值。即存貯它數據值的那塊內存的地址。它有時候被稱為左值（lvalue）。我們也可以認為左值的意思是位置值。文字常量不能被用作左值。
變量的定義會引起相關內存的分配。因為一個對象只能有一個存貯位置，所以一個對象只能被定義一次。如果在一個文件中定義的對象需要在另一個文件中被訪問，那么就會出現問題。
在c++中，對象在使用之前必須知道對象，引用一個未知的對象會引起編譯器的錯誤。
如果一個對象在另一個  文件中聲明著，我們想在這個文件中來使用這個對象，但是又不能在這個文件中在聲明相同的對象。那么我們可以使用extern關鍵字來聲明這個對象。
例如; file module.c
 string aaaaa;
///定義了對象aaaaa



file  module1.c
////需要使用對象aaaaa.，
////聲明對象aaaaa，使程序知道它。但是又不能引入第二個定義。
extern string aaaaa;
對象聲明是使程序知道對象的類型和名字。它由關鍵字extern后面跟對象的類型和對象的名字構成。
聲明不是定義，不會引起內存的分配。實際上它只是說明了在程序之外的某處有這個變量的定義。
雖然一個程序中只能包含一個對象的定義，但是可以包含很多的對象聲明。
比較好的做法是:   不是在每個要使用的文件中都單獨提供一個聲明。而是在在頭文件中聲明這個對象，然后在需要聲明這個對象的時候包含這個頭文件就好了。按照這個做法。如果需要修改對象的聲明只需要修改一次。就能維持多個使用這個對象的聲明文件的一致性。

面相對象的程序設計擴展了給予對象的程序設計。可以提供類型和子類型的關系。這個是通過一種稱作繼承（inheritance）的機制來實現的。

c++預定了一組數值數據類型。可以用來表示整型，浮點型和單個字符。此外還預定了表示字符串的字符數組。
1：字符型char:通常用來表示單個字符和小整數。它可以用一個機器字節來表示（即8位表示）。
2：整型int  短整型short ，長整型long分別表示不同長度的整數值。典型的情況下：short用半個字表示（即16位）。int 用一個字表示（即32位。）long用一個或者兩個字表示。（在32位的機器中通常int 和long的通常長度相同。）
3：浮點型flont ,雙精度double和長雙精度。長雙精度long double 。分別表示單精度浮點數。雙精度浮點數和擴展精度的浮點數。典型的情況下，float用一個字表示。double用兩個字表示，long double用三個或者四個字表示。
char ,int, float , long 稱為整值類型（intergral  type）。整值類型可以有符號也可以沒有符號。在有符號的類型中。最左邊的位是符號為。余下的位代表數值。。在無符號的類型中，所有的位表示數值位。
如果符號為被設置為1。那么數值被解釋為負數。如果符號為被設置為0。那么數值位被解釋為正數。
一個8位有符號的char 表示-128---127之間的值。而一個無符號的char則表示0--255之間的值。
當一個值。例如1。出現在程序的時候，我們稱它為文字常量。稱他為“文字”是因為我們只能以他的值的形式來指代它。稱之為常量是因為它的值不能被改變。每個文字都有相應的類型。文字常量是不可尋址的（nonadressable）。盡管他的值也被存儲在機器的某個內存之中。但是我們沒有辦法來尋找它的地址。
整數文字常量可以被寫成十進制。八進制，十六進制的形式。（這不會改變該整數的位序列）。例如：20可以寫成以下的方式：
20/////////十進制形式
024/////八進制
0x14////十六進制。
在整型常量前面加上0。該值將被解釋成一個八進制數。而在整形常量的前面加上0x，則該值將會被解釋成十六進制數。
在缺省的情況下，整形常量被當作一個int的有符號的整數。
我們可以在一個文字常量的后面加上一個“L”或者"l"，將其指定為long類型。
類似的，我們在文字常量的后面加上“u”或者“U”。表示一個無符號的數。
此外，我們還可以指定無符號long類型的數。例如： 1UL.
單詞true 和false是bool型的文字常量。
可以打印的文字常量可以用單引號''括起來例如：
'A','S'...等。
不能夠直接打印的字符，單引號，雙引號，和反斜杠就i可以用轉義序列來來表示（轉移序列用反斜杠來開頭）。
\n 換行符
\t水平制表符
\v垂直制表符
\b退格符
\r回車鍵
\a響鈴建
\\反斜杠鍵
\?問號
\'單引號
\""雙引號
另外字符文字前面可以加上“L
例如：L'a'
這個稱為寬字符文字，類型為wchar_t.寬字符常量用來支持某些語言字符的集合。例如：漢語，日語等
這些語言中的某些字符不能用單個的字符來表示。
字符串常量由零個或者許多個由雙引號括起來的 字符
不可以打印的字符由相應的轉移序列來表示，而一個字符串文字可以擴展到多行。在一行的最后加上一個\，表示字符串文字在下一行繼續。
如："fdfdf fdfdf\dfdfdfsdffdfdfdf"
字符串文字的類型是常量字符數組。字符文字本身和 編譯器加上的表示結束的(NULL),字符構成。
例如：'a'表示一個單個的字符a
"a"則表示一個字符a和一個空字符，
空字符是c和c++用來標記字符串結束的符號
正如寬字符文字。L'a'

也有寬字符串文字L"aaaaaaa"
寬字符串文字的類型是常量的寬字符數組。他也有一個等價的寬空字符作為結束的標記。
如果兩個字符串和或者寬字符串在程序中相鄰。c++就會把它們連接起來。并且在最后加上一個空字符，
例如："one" "two" 則輸出的結果為onetwo.
如果把一個字符串常量和一個寬字符串常量鏈接起來，那么結果會是如何呢？
"aa" L"SSS"
結果是未定義(undefine)------即沒有這種這兩種不同類型鏈接標定義行為。
使用未定義的程序被稱為是不可以移植的。
雖然程序可以在當前的編譯器下可以執行，但是不能保證相同的程序在不同的編譯器下，或者在當前的白一起的以后的版本中，還能夠正確的編譯通過。
在本來可以正常運行的程序中來尋找這些是件很令人心煩的事情，所以我們建議不要使用未定義的程序特征。

正如我們看到的，盡管c++的數組支持容器機制。但是它不支持容器抽象的語義。為了在這個層次上編寫程序。在標準c++之前。要么我們從某個途徑獲取這樣的類。要么我們自己編寫這樣的類。
在標準c++中。數組類是c++標準庫中的一部分。現在它不叫數組了，而叫向量(vector)、

當然向量是一個類模板，我們可以這樣寫：
vector<int> ivec(10);
vector<string>svec(10);
上面的代碼分別定義了包含10個整型的對象的向量，和定義了包含10個字符串的對象的向量。
在我們實現的Array類模板和vector類模板的實現中有兩個不同的區別;
vector類模板支持“向現有的數組元素賦值”的概念以及“插入附件元素的”概念---------即vector數組可以在運行時動態的增長。（如果程序員愿意使用這個特征的話。）
第二個區別是 ： 更加廣泛。代表了設計方法的重要改變。vector類不是提供一個巨大的“可以適用于向量”的操作集。如;store(),min().max()等。而是只是提供一個最小集；如：等于，小于，size(),empty()等操作。而一些通用的操作如：sort(),min().max(),find()。等操作是作為獨立的泛型算法（generic algorthem）被提供的。
要定義一個向量我們必須包含相關的頭文件。
#include<vector>
下面都是vector對象的合法定義。
vector<int>vecto;///////空的vector
const int size=8;
const int value=1024;
//size為8的vector
///每個元素都被初始化為0
vector<int>vecto(size);

//size為8的vector
///每個元素都被初始化為1024
vector<int>vecto(size ,value);
////vector3的size為8
///vector3的初始化值為ia 的4個值
int ia[4]={0,1,1,2};
vector<int>vector3(ia,ia+4);

////vector4是vector2的拷貝。
vector<int>vector4(vector2);
既然定義了向量，那么我們就必須遍歷里面的元素。
與Array類模板一樣。標準的vector類模板也支持使用下面的操作符。
例如：
#include<vector>
extern int getsiz();
void mumble()
{
  int size=getsize();
vector<int>vec(size);
for(int i=0;i<=size;i++)
{
 vec[i]=i;
/////,.............................
}
}

名字空間允許我們封裝名字，否則的話，這些名字就有可能污染到全局的名字空間（pollute teh global namespce）.一般來說，只有我們希望我們的代碼被外部軟件開發部門使用的時候。才會用到名字空間。
例如;我們可以這樣來封裝Array類，
namespace cplacple_primer_3E
{
 template <calss eyemly>
 calss Array{,,,,,,,,,};
////////////////////////

}
namespce后面的名字標明了一個名字空間。它獨立于全局名字空間。我們可以在里面放一些希望聲明在函數和類之外的實體。名字空間并不改變他們的聲明意義。只是改變了它們的可視性。如果名字空間中的聲明對于程序來說不是立即可見的。那么我們雜樣來訪問他們呢？我們就要用到限定修飾名字符.
格式如下：
namespce_idenerfier::entrityname
名字空間別名（namespce alias）允許用一個可替代的，短的，或者跟一般的名字來和名字空間來關聯起來。
例如：
//提供一個更一般化的名字
namespce lib=cplacple_primer_3E
然后這個名字就會稱為原始名字空間的同義詞。
#include "cplacple.h"
int main()
{
 lib::Array{...........}

 }
別名也可以 用來封裝正在使用的實際的名字空間。在這種情況下，我們可以通過改變別名的名字空間。
來改變所使用的聲明集。而無需改變“通過別名來訪問這些聲明”。的實際代碼。
using 指示符使名字空間中的所有的聲明都是可見得。這樣這些聲明可以不加任何的限定的使用。
using和namespce都是關鍵字。被引用的名字空間必須已經被聲明了。否則的話，會引起編譯的錯誤。

using 聲明提供了更為精細的名字可視化機制。它允許使名字空間中的單個的聲明可見。
例如：
#include"IBM_Canada_Labaraory.h"
using  namespace IBM_Canada_Labaraory::Matriy
int main()
{
 //ok; IBM_Canada_Labaraory::Matriy

Matriy met(4,5);
//fail,錯誤。IBM_Canada_Labaraory::Array不可見
Array array(4,5);
}
為了防止標準的c++庫組件污染用戶定義的名字空間。所有的c++庫組件都聲明在一個稱為std的名字空間中。
所以即使我們在我們的文本文件中已經包含了c++庫頭文件，頭文件中聲明的內容在我們的文本文件中也是不可見的。
例如：
在c++中下面的代碼是不能被編譯通過的。
#include<string>
///錯誤。string 是不可見的
string  current_string="asdf dfdff";
在string 頭文件中所有的聲明都包含在std名字空間中。
我們可以用“#include 指示符后面加上using 的辦法使在<string>中的，在std中聲明的組件，對于我們的文本文件是可見得。
例如：
#include<string>
 using namespace std
int main()
{
 //////////正確。string 是可見的。
  string current_string="asd fdfdf"
}
為了使在std中，聲明的組件和名字在我們的文本文件中可見。using指示符通常被看作是一種比較差的選擇方案。
在上面的例子中。指示符using ，使在string頭文件中聲明的，并且在std名字空間中的  組件在我們的文本文件中都是可見的。這又將全局名字空間污染問題帶回來了。而這個問題就是std名字空間首先要努力避免的。
它增加了“c++標準庫組件的名字”與“我們程序中聲明的全局名字”沖突的機會。
現在有兩種機制可以替代using指示符。來引用隱藏在std名字空間中的名字string.
第一種方法：
 可以使用限定的名字。
  #include<string>
/////正確。使用限定的名字
   std:: string current_string="afdfdfsdfs";
第二種方法：
 如下使用using 聲明；
#include<string>
 using std::string;
 /////ok.上面的using聲明使string可見。
 string=“dfdfdfafsdf”;
為了使用名字空間中的聲明的名字。最好使用帶有精細選擇功能的 using聲明替代using 指示符。