2008年6月23日

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

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

          posted @ 2008-08-01 15:32 清流琴音 閱讀(135) | 評論 (0)編輯 收藏
           
          頭文件由三部分組成:
          1:頭文件開頭出的版本和版權(quán)的 聲明。
          2:預處理塊。
          3:函數(shù)和類的結(jié)構(gòu)聲明等。
          規(guī)則:
          (1): 為了防止頭文件被重復的引用,應該使用#ifndef/define/endif結(jié)構(gòu)產(chǎn)生與處理模塊。
          (2):用#include<filename.h>來引用標準庫的頭文件(編譯器將從標準庫目錄開始搜索)。
          (3):用#include"filename.h"來引用非標準庫的頭文件(編譯器將從用戶工作的目錄開始搜索)
          建議:頭文件中一般只存放“聲明”,而不存放“定義”

          定義文件的結(jié)構(gòu):

          定義文件的 內(nèi)容有由三部分組成:
          (1):  定義文件開頭處的版本和版權(quán);
          (2):對一些頭文件的引用;
          (3):程序的實現(xiàn)體(包括數(shù)據(jù)和代碼)

          頭文件的作用:
          (1):通過頭文件來調(diào)用庫功能。在很多場合源代碼不能(或者不準)提供給用戶。只提供給用頭文件或者二進制的庫。用戶只需要按照頭文件中的接口的聲明來調(diào)用庫功能。而不必關心接口是如何實現(xiàn)的。編譯器會從庫中提取相應的代碼。
          (2): 頭文件可以用來加強類型安全檢查。如果某個接口被實現(xiàn)或者被實用的時候,其方式和在頭文件中的聲明不一致的時候,編譯器就會報錯。這一簡單的規(guī)則可以大大的減輕程序員調(diào)試和改錯的負擔。
          目錄結(jié)構(gòu):
          如果一個軟件的頭文件比較多(超過10個),就應該把頭文件和定義文件分開。分別保存在不同的目錄之中。以便于維護。
          例如:可以將頭文件保存在inluude目錄之中。將定義文件保存在source文件之中。
          如果某些頭文件是私有的,不會被程序直接引用,為了加強信息隱藏。那么可以把這些頭文件和定義文件放在同一目錄之中。
          posted @ 2008-08-01 15:13 清流琴音 閱讀(167) | 評論 (0)編輯 收藏
           
          指針中存有另一個對象的地址,使我們可以間接的操作這個對象。
          指針的典型用法是構(gòu)建一個連接的數(shù)據(jù)結(jié)構(gòu),例如:鏈表(list)和數(shù)(tree)。并管理在程序運行的過程中動態(tài)分配的對象。以及作為函數(shù)參數(shù)類型。主要用來傳遞數(shù)組和大型類的對象。
          每個指針都有相關的類型。
          不同數(shù)據(jù)類型的指針之間的區(qū)別不在于指針的表示上,也不是指針所持有的值(地址)。——對于所有類型的指針這兩個方面都是一樣的。不同之處在于指針所指的對象的類型上。針織類型可以指定編譯器咋樣解釋特定內(nèi)存上的指定的內(nèi)容,以及該內(nèi)存區(qū)域因該跨越多少內(nèi)存單元。
          posted @ 2008-07-08 14:43 清流琴音 閱讀(177) | 評論 (0)編輯 收藏
           
          變量名,即變量的標識符,可以由字符,數(shù)字,以及下劃線來組成。他必須以字符或者下劃線來開頭,并且區(qū)分大小寫。
          語言本身沒有對變量名做什么限制。但是為了用戶著想,他不應過長。
          c++保留了一些詞用作關鍵字。關鍵字標識符不能在作為標識符在程序中使用了。
          對于命名對象有很多已經(jīng)普遍接受的習慣。主要考慮的因素的是程序的可讀性。
          第一:對象的命名一般用小寫。
          第二:標識符通常用容易記憶的名字。
          第三:對于多詞構(gòu)成的標識符一般在詞的中間加上下劃線。
          對象的定義:
          一個簡單的對象的定義由一個類型指示符后面加上一個名字構(gòu)成,以分號結(jié)束。
          例如: int aaaaa;
          當同類型的多個標識符被定義的時候,我們可以在類型指示符后面用逗號隔開。
          一個簡單的定義指定了變量的類型和標識符。他并不提供初始值。
          如果一個變量是在全局域(globe scope)中定義的,那么系統(tǒng)會保證給他一個初始值0。如果一個變量是在一個局部域中定義的,或者通過一個new 動態(tài)分配的,那么系統(tǒng)不會向它提供初始值0。這些對象被稱為未初始化(uninitialized),未初始化的對象不是沒有值,而是對象的值未被定義。
          因為使用未初始化的對象是個很常見的  錯誤,并且很難被發(fā)現(xiàn)。所以建議為每個定義的對象進行初始化。
          類機制通過缺省構(gòu)造函數(shù)提供了類對象的自動初始化。
          例如:
          int  main()
          {
          int val;////////未被初始化的值。
          string  project;//////通過string類的缺省的構(gòu)造函數(shù)進行了初始化。
          }


          val是一個未被初始化的局部變量。
          但是project是一個已經(jīng)被初始化的類對象——被string類缺省的構(gòu)造函數(shù)自動初始化。
          初始化一個值可以在對象定義的時候進行。
          c++支持兩種形式的初始化。
          第一種是使用賦值符號的現(xiàn)實的操作。
          如:
          int val=111;
          string  project="ssssss";
          隱式形式中,初始化值被放在括號中。
          int val(111);
          string project("sssssss");
          在對象的定義之中,當對象的標識符在定義中出現(xiàn)后,對象名馬上就是可見的了。因此用對象初始化他自己是合法的,只是這樣做不是明智的。
          例如:int val=val;///////合法,但是不是明智的。
          另外,每種內(nèi)置數(shù)據(jù)類型都支持一種特殊的構(gòu)造函數(shù)。可將對象初始化為0。
          /////設置val為0。設置dval為0.0。
          int val =int();
          double dval=double();
          下列的定義中:
          int()
          vector <int>ival(10);
          函數(shù)int()自動被應用到ival包含的10個元素上。
          對象可以用任意復雜的表達式來初始化,也可以用返回值
          posted @ 2008-07-08 14:26 清流琴音 閱讀(701) | 評論 (0)編輯 收藏
           
          變量為我們提供了一個有名字的內(nèi)存存貯空間。可以通過程序?qū)ζ溥M行 讀寫,處理操作。
          c++中給個符號變量都有一個符號類型與之對應。這個類型決定了相關內(nèi)存的大小,類型,布局,能夠存貯在該內(nèi)存值的范圍。以及可以以用到其上的操作集。我們也可以把變量說成是對象(object)

          變量和文字常量都有存貯區(qū),并且都有相關的類型。區(qū)別在于變量是可以尋址的(adressable)常量文字是不可以尋址的(nonadressable),每一個變量都有兩個值與之聯(lián)系著,
          1:數(shù)據(jù)值。存貯在內(nèi)存的某個存貯區(qū)之中。有時候這個數(shù)據(jù)值也被稱為是右值(rvalue).我們可以認為右值是被讀取的值。文字常量和變量都可以被用來做右值。
          2:它的地址值。即存貯它數(shù)據(jù)值的那塊內(nèi)存的地址。它有時候被稱為左值(lvalue)。我們也可以認為左值的意思是位置值。文字常量不能被用作左值。
          變量的定義會引起相關內(nèi)存的分配。因為一個對象只能有一個存貯位置,所以一個對象只能被定義一次。如果在一個文件中定義的對象需要在另一個文件中被訪問,那么就會出現(xiàn)問題。
          在c++中,對象在使用之前必須知道對象,引用一個未知的對象會引起編譯器的錯誤。
          如果一個對象在另一個  文件中聲明著,我們想在這個文件中來使用這個對象,但是又不能在這個文件中在聲明相同的對象。那么我們可以使用extern關鍵字來聲明這個對象。
          例如; file module.c
           string aaaaa;
          ///定義了對象aaaaa



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



          posted @ 2008-07-08 10:49 清流琴音 閱讀(190) | 評論 (0)編輯 收藏
           

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

          posted @ 2008-07-07 10:33 清流琴音 閱讀(181) | 評論 (0)編輯 收藏
           

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

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

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

          當然向量是一個類模板,我們可以這樣寫:
          vector<int> ivec(10);
          vector<string>svec(10);
          上面的代碼分別定義了包含10個整型的對象的向量,和定義了包含10個字符串的對象的向量。
          在我們實現(xiàn)的Array類模板和vector類模板的實現(xiàn)中有兩個不同的區(qū)別;
          vector類模板支持“向現(xiàn)有的數(shù)組元素賦值”的概念以及“插入附件元素的”概念---------即vector數(shù)組可以在運行時動態(tài)的增長。(如果程序員愿意使用這個特征的話。)
          第二個區(qū)別是 : 更加廣泛。代表了設計方法的重要改變。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;
          /////,.............................
          }
          }
          posted @ 2008-06-30 15:18 清流琴音 閱讀(293) | 評論 (0)編輯 收藏
           

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

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

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

          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的名字空間中。
          所以即使我們在我們的文本文件中已經(jīng)包含了c++庫頭文件,頭文件中聲明的內(nèi)容在我們的文本文件中也是不可見的。
          例如:
          在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++標準庫組件的名字”與“我們程序中聲明的全局名字”沖突的機會。
          現(xiàn)在有兩種機制可以替代using指示符。來引用隱藏在std名字空間中的名字string.
          第一種方法:
           可以使用限定的名字。
            #include<string>
          /////正確。使用限定的名字
             std:: string current_string="afdfdfsdfs";
          第二種方法:
           如下使用using 聲明;
          #include<string>
           using std::string;
           /////ok.上面的using聲明使string可見。
           string=“dfdfdfafsdf”;
          為了使用名字空間中的聲明的名字。最好使用帶有精細選擇功能的 using聲明替代using 指示符。

          posted @ 2008-06-30 11:15 清流琴音 閱讀(238) | 評論 (0)編輯 收藏
           
          異常(exception)是指在運行的時刻程序出現(xiàn)反情況。比如:數(shù)組下標越界。打開文件夾失敗,動態(tài)創(chuàng)建內(nèi)存失敗等。程序員一般有自己的異常處理方式。這導致個各種編碼方式,。所以很難整合到一個程序中。
          異常處理(exception  handing ), 為“響應運行時刻的程序“提供了一個標準語言級的設施。它支持統(tǒng)一的語法和風格,也允許每個程序員進行微調(diào)。異常處理                不需要我們在程序中處處顯示的測試異常狀態(tài)。從而可以將測試代碼顯示的抽取出來,放在指定的 標記的代碼塊中。因此 異常處理設施大大的 簡化了程序的長度和復雜度。
          異常處理機制主要構(gòu)成如下:
          1: 程序中異常出現(xiàn)的點。一旦識別出程序的異常,就會拋出異常(throw)。當異常被拋出的時候,程序就會被掛起,知道異常被處理完畢了。c++中,異常的處理有throw表達式來執(zhí)行。
          2:程序中異常被處理的點. 典型的程序的異常拋出和處理位于獨立的 函數(shù)或者成員函數(shù)中。找到異常處理代碼一般要展開程序調(diào)用棧(progam call stack ).一旦異常被處理完畢,及恢復程序的正常執(zhí)行。但是不是在出現(xiàn) 異常的地方恢復,而是在處理異常的地方恢復執(zhí)行過程。在c++中異常的處理用catch表達式來執(zhí)行。
          catch和try字句相關聯(lián)。一個try塊用一個或者多個catch子句將一條或者多條語句組織起來。
          系統(tǒng)根據(jù)被拋出的異常和catch子句的異常類型的匹配的情況來選擇catch子句。
          系統(tǒng)把控制傳遞給catch子句體,其中的語句將順序執(zhí)行。完成后后,除非子句體中還拋出異常,否則的話,控制將會被傳到程序的當前點上。
          posted @ 2008-06-27 14:58 清流琴音 閱讀(193) | 評論 (1)編輯 收藏
           
          c++的模板提供了一種機制,它能夠把函數(shù)和類內(nèi)部的數(shù)據(jù)和值參數(shù)化。這些參數(shù)在其他地方不變的代碼中用作占位符。以后,這些參數(shù)會綁定在實際的數(shù)據(jù)類型中。可能是內(nèi)置的數(shù)據(jù)類型,也可以是用戶自定義的 類型。
          posted @ 2008-06-27 14:51 清流琴音 閱讀(111) | 評論 (0)編輯 收藏
           
          在c++ 中,被繼承的類稱為基類(base class)新類  被稱為從基類中派生(derived)來的。我們把它叫做派生類或基類的子類。子類和基類共享公共的接口(common interface--)-----共有操作的公共集.由于共享公共接口,就允許子類和基類在程序內(nèi)部可以互換使用。而無需考慮對象的類型。從某種意義上說,公共接口接口封裝了子類型中與類型相關的細節(jié)。類之間的類型和子類型形成了繼承和派生層次關系。
          在繼承的機制下有多個  類的提供者:一個提供基類的實現(xiàn)(可能還提供一些派生類的實現(xiàn)。另外一個或者多個提供者在集成生命周期內(nèi)提供派生類)。子類的提供者經(jīng)常要訪問(并不總是)基類的實現(xiàn),為了提供這種能力,同時也為了能夠還要防止對積累的一般性的訪問,c++中提供了另一種訪問級別:保護。在類的保護區(qū)域的成員函數(shù)和數(shù)據(jù)成員只提供給它的派生類使用,放在基類的數(shù)據(jù)成員和數(shù)據(jù)成員只能被它自己使用,它的派生類也不能使用使用它。

                       
          posted @ 2008-06-27 10:41 清流琴音 閱讀(122) | 評論 (0)編輯 收藏
           

          更一般的,c++支持函數(shù)重載(funtion  overloding)的機制。c++允許兩個或者兩個以上的函數(shù)具有相同的命名字。限制條件是參數(shù)的不同,可以是參數(shù)的類型或者數(shù)目的不同。根據(jù)不同的參數(shù)表。編譯器就可以區(qū)分開調(diào)用哪個函數(shù)。
          重載函數(shù)和非重載函數(shù)在運行時刻的行為是一樣的。只是重載函數(shù)在運行的時候,會花費時間來決定到底用哪個函數(shù)。如果c++不支持函數(shù)重載的話。那么我們就必須為每個函數(shù)設置不相同的名字。
          如果在類的體外進行成員函數(shù)的定義的時候,就必須指出這個成員函數(shù)屬于哪個類。這個可以通過類的域操作符(calss  scope operator)來實現(xiàn)。
          例如:Inarry::
          ":"冒號操作符被稱為域操作符。
          當與一個類相連接的時候。它就成為一個域操作符了。
          我們可以非正式的把與看作是一個可視的窗口。非全局域的文件在它的這個文件中都是可見的,在一個函數(shù)體內(nèi)定義的對象是局域的,它只在這個函數(shù)體內(nèi)可見。每個類維持一個域。在這個域之外,它的成員是不可見的。類域操作符告訴編譯器。域操作符后面的內(nèi)容是可以在這個域中找到的。
          引用:引用是一種沒有指針語法的指針。與指針一樣,引用提供對對象的間接訪問。
          類機制還支持特殊析構(gòu)成員函數(shù)(destructor member funtion )每一個類對象在最后一次被使用之后,析構(gòu)函數(shù)就會被自動調(diào)用。
          我們在析構(gòu)函數(shù)前面加上~線來標識。一般來說,析構(gòu)函數(shù)釋放類對象和在構(gòu)造函數(shù)中所獲得的資源。

          posted @ 2008-06-26 11:56 清流琴音 閱讀(163) | 評論 (0)編輯 收藏
           

          基于支持對象的類的形式為:
          class classname
          {
           public////////公有操作集合
          private:
          //////私有實現(xiàn)代碼

          }
          這里的class,  pulic。和private 是c++的關鍵字。classname是一個標識符,用來命名類名。以便以后引用該類。
          類名代表著一種新型的數(shù)據(jù)類型,我們可以像定義內(nèi)置的數(shù)據(jù)類型一樣來定義對象。

          例如:
          Inarry    inaaay;////定義一個單個類Inarry的對象inaaay;
          Inrry *inarry=new Inrry;///////定義一個指向Inrry類的對象的指針。
          類的定義包含兩個部分:
          類頭( class head)有關鍵字class和類名組成。類體(class boday)有花括號括起來。以分號結(jié)束。
          類頭本身也做類的聲明。
          類體包含成員定義和訪問標簽。如:public和private。成員定義主要包括:“該類主要實現(xiàn)什么洋的功能,”以及   “代表類抽象所需要的數(shù)據(jù)”這些操作稱為成員函數(shù)(member funtion)。或者稱為方法(methord)。
          程序設計中一個常見的錯誤是使用先前沒有正確被初始化的對象。實際上這是一個十分常見的錯誤。所以c++為用戶定義的類提供了一種自動初始化機制:類的構(gòu)造函數(shù)(calss  constructor)
          構(gòu)造函數(shù)是一種特殊的成員函數(shù)。專門用于初始化對象,如果構(gòu)造函數(shù)被定義了。那么每個對象在應用的時候,該構(gòu)造函數(shù)就會被自動的應用到該對象上。構(gòu)造函數(shù)由類的提供者來定義。既我們提供類的定義的時候。就必須定義類的構(gòu)造函數(shù)。
          為一個類定義一個構(gòu)造函數(shù)是類設計必不可少的一部分。
          為了定義一個構(gòu)造函數(shù)。我們只要  給出一個和 類名字相同的函數(shù)就可以了。
          不能指定構(gòu)造函數(shù)有返回值。可以定義很多的構(gòu)造函數(shù)在一個類中。
          盡管她們具有相同的名字,但是只要編譯器可以根據(jù)參數(shù)區(qū)分他們就可以了。
          更一般的





          posted @ 2008-06-24 14:22 清流琴音 閱讀(179) | 評論 (0)編輯 收藏
           
          在c++中,內(nèi)存可以是靜態(tài)分配的——編譯器在處理源代碼的時候就分配,也可以是動態(tài)分配的---程序在 運行的時候調(diào)用所需要得庫函數(shù)進行分配。這兩種分配方式各有個的優(yōu)點。由于靜態(tài)內(nèi)存分配是在程序運行之前就分配了內(nèi)存,所以執(zhí)行的效率就很高。但是缺乏靈活性。它要求知道程序在之前就知道內(nèi)存的類型和數(shù)目。
          例如:
          利用靜態(tài)分配的字符串數(shù)組,我們就無法很容易的處理和存貯任意的文本文件。一般來說存貯未知的的數(shù)目的元素,需要動態(tài)分配內(nèi)存的靈活性。
          例如:以下的定義:
          int ival=1024;
          指示編譯器分配足夠的內(nèi)存來存貯一個整型值。該存儲區(qū)與名字ival相關聯(lián)。然后用1024區(qū)初始化該存貯區(qū),這些都是在程序之前完成的。
          c++支持用指針類型來存放對象的內(nèi)存地址值。
          例如:
          為了聲明一個存放ival內(nèi)存地址的的指針類型。我們可以聲明如下:
          int *print;//////一個指向int類型的指針。
          c++預定一個專門取地址的操作符(&),當他應用于一個對象上的時候,返回的是該對象的地址。
          因此,為了將ival的地址值賦值給print,我們可以寫為:
          int*print;
          print=&ival;///把ival的地址值賦值給print
          為了訪問print所指向的內(nèi)容。我們必須先用解引用(dereference)操作符(*),來先解除的引用。
          例如:我們通過print間接的給ival加1;
          *print=*print+1;
          等價于:
          直接對 ival進行操作
          ival=ival+1;
          在c++中指針主要是用來管理和分配動態(tài)分配的內(nèi)存。
          對象的分配可以通過兩個不同的版本來實現(xiàn)。
          第一個版本用于分配特定類型的單個對象。
          int*print=new int 1024);
          分配了一個沒有名字的int類型的對象,對象的初始化值為1024。然后表達式返回對象在內(nèi)存中的地址。
          接著這個地址用來初始化指針對象print.    對于動態(tài)分配的內(nèi)存。唯一的訪問方式是通過指針來訪問。
          例如:
          new的第二個版本,用于分配特定的類型和維數(shù)的數(shù)組。
          int *pia=new int[4];
          分配了一個含有4個元素的整型數(shù)組。不幸的是我們沒有辦法給動態(tài)分配的數(shù)組每個值顯示的指定一個初始值。
          分配動態(tài)數(shù)組,一個常令人困惑的問題是,返回值只是一個指針。與分配單一對象的返回值是相同的。
          posted @ 2008-06-24 10:11 清流琴音 閱讀(564) | 評論 (0)編輯 收藏
           
          數(shù)組是一組具有相同數(shù)據(jù)類型的元素的集合。
          c++為基本算術數(shù)據(jù)類型提供了內(nèi)置的支持。同時他也支持雙精度和單精度的數(shù)據(jù)支持。除此之外c++還支持布爾類型,以及用來存放字符集中單個元素的字符支持。
          在內(nèi)置數(shù)據(jù)類型和標準庫類類型之間的是復合數(shù)據(jù)類型(compuond type)特別是指針和數(shù)組類型。
          數(shù)組(array)是一個順序的容器.它包含單一類型的元素。
          例如:序列
          0 1 1 2 3 5 8 13 21
          代表菲波那契序列的前9個數(shù)。(只要給出前兩個數(shù)據(jù),后面的數(shù)據(jù)就是前兩個數(shù)據(jù)的之和。)
          a[8]={0,1,2,3,4,5,6,7}
          當a[9]的時候,就會出現(xiàn)一位偏移錯誤(off-by-one):
          通常我們用循環(huán)來遍歷數(shù)組中的元素。
          例如:下面的程序初始化了一個數(shù)組。前9為分別為0---9
          int main()
          {
            int ia[10];
            int idex;
           for(idex=0;idex<10;idex++)
          {
           ia[idex]=idex;
          }
          for(idex=9;idex>=0;idex--)
          {
           cout<<ia[idex]<<"";
          cout<<endl;
          }
          }
          c++雖然對數(shù)據(jù)類型提供了內(nèi)置的支持。但是這種支持只是限定于“讀寫單個數(shù)組元素”。c++不支持數(shù)組的抽象(abstracion),也不支持對整個數(shù)組的操作.我們有時候希望對整個的數(shù)組進行操作。例如:把一個數(shù)組賦值給另一個數(shù)組。對兩個數(shù)組進行比較。。想知道數(shù)組的大小。
          例如:給出兩個數(shù)組,我們不能直接用賦值操作符,把一個數(shù)組的值拷貝到另一個數(shù)組中去。
          比如:
          ia1[10], ia2[10]
          ia1[10]=ia2[10];/////錯誤。不能直接把一個數(shù)組的值通過賦值運算符賦值給另一個數(shù)組。
          如果想把一個數(shù)組的值賦值給另一個數(shù)組我們必須自己編寫程序。
          for(int idex=0;idex<10;idex++)
          {
            ia1[idex]=ia2[idex];

          }

          而且數(shù)組類型并沒有自己的意識。它并不知道自己的長度,我們必須另外記錄數(shù)組的信息。當我們希望把一個數(shù)組作為參數(shù)傳遞給一個函數(shù)的時候,問題就出現(xiàn)了。在c++中,數(shù)組不同于整型類型和浮點類型,它不是c++的一等公民(first——class),它是從c語言中繼承而來的,它反映了數(shù)據(jù)與對其進行操作的算法的分離。這正是過程話程序的特點。
          posted @ 2008-06-23 10:28 清流琴音 閱讀(219) | 評論 (1)編輯 收藏
           
          主站蜘蛛池模板: 外汇| 江口县| 乃东县| 马尔康县| 麻栗坡县| 莒南县| 博白县| 远安县| 和龙市| 佛坪县| 潜江市| 教育| 上高县| 萨迦县| 龙里县| 贵南县| 桦南县| 丹江口市| 陆川县| 东山县| 北安市| 营口市| 寻甸| 普安县| 黄浦区| 麻阳| 桑植县| 藁城市| 青川县| 太湖县| 通渭县| 嵊泗县| 雷波县| 门头沟区| 阳新县| 南涧| 赤城县| 同江市| 盐城市| 南京市| 阿拉善右旗|