2008年3月14日

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

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

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

          定義文件的結構:

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

          頭文件的作用:
          (1):通過頭文件來調用庫功能。在很多場合源代碼不能(或者不準)提供給用戶。只提供給用頭文件或者二進制的庫。用戶只需要按照頭文件中的接口的聲明來調用庫功能。而不必關心接口是如何實現的。編譯器會從庫中提取相應的代碼。
          (2): 頭文件可以用來加強類型安全檢查。如果某個接口被實現或者被實用的時候,其方式和在頭文件中的聲明不一致的時候,編譯器就會報錯。這一簡單的規則可以大大的減輕程序員調試和改錯的負擔。
          目錄結構:
          如果一個軟件的頭文件比較多(超過10個),就應該把頭文件和定義文件分開。分別保存在不同的目錄之中。以便于維護。
          例如:可以將頭文件保存在inluude目錄之中。將定義文件保存在source文件之中。
          如果某些頭文件是私有的,不會被程序直接引用,為了加強信息隱藏。那么可以把這些頭文件和定義文件放在同一目錄之中。
          posted @ 2008-08-01 15:13 清流琴音 閱讀(167) | 評論 (0)編輯 收藏
           
          指針中存有另一個對象的地址,使我們可以間接的操作這個對象。
          指針的典型用法是構建一個連接的數據結構,例如:鏈表(list)和數(tree)。并管理在程序運行的過程中動態分配的對象。以及作為函數參數類型。主要用來傳遞數組和大型類的對象。
          每個指針都有相關的類型。
          不同數據類型的指針之間的區別不在于指針的表示上,也不是指針所持有的值(地址)。——對于所有類型的指針這兩個方面都是一樣的。不同之處在于指針所指的對象的類型上。針織類型可以指定編譯器咋樣解釋特定內存上的指定的內容,以及該內存區域因該跨越多少內存單元。
          posted @ 2008-07-08 14:43 清流琴音 閱讀(177) | 評論 (0)編輯 收藏
           
          變量名,即變量的標識符,可以由字符,數字,以及下劃線來組成。他必須以字符或者下劃線來開頭,并且區分大小寫。
          語言本身沒有對變量名做什么限制。但是為了用戶著想,他不應過長。
          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個元素上。
          對象可以用任意復雜的表達式來初始化,也可以用返回值
          posted @ 2008-07-08 14:26 清流琴音 閱讀(702) | 評論 (0)編輯 收藏
           
          變量為我們提供了一個有名字的內存存貯空間。可以通過程序對其進行 讀寫,處理操作。
          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后面跟對象的類型和對象的名字構成。
          聲明不是定義,不會引起內存的分配。實際上它只是說明了在程序之外的某處有這個變量的定義。
          雖然一個程序中只能包含一個對象的定義,但是可以包含很多的對象聲明。
          比較好的做法是:   不是在每個要使用的文件中都單獨提供一個聲明。而是在在頭文件中聲明這個對象,然后在需要聲明這個對象的時候包含這個頭文件就好了。按照這個做法。如果需要修改對象的聲明只需要修改一次。就能維持多個使用這個對象的聲明文件的一致性。



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

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

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

          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)------即沒有這種這兩種不同類型鏈接標定義行為。
          使用未定義的程序被稱為是不可以移植的。
          雖然程序可以在當前的編譯器下可以執行,但是不能保證相同的程序在不同的編譯器下,或者在當前的白一起的以后的版本中,還能夠正確的編譯通過。
          在本來可以正常運行的程序中來尋找這些是件很令人心煩的事情,所以我們建議不要使用未定義的程序特征。
          posted @ 2008-07-04 15:35 清流琴音 閱讀(201) | 評論 (0)編輯 收藏
           

          正如我們看到的,盡管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;
          /////,.............................
          }
          }
          posted @ 2008-06-30 15:18 清流琴音 閱讀(293) | 評論 (0)編輯 收藏
           

          名字空間允許我們封裝名字,否則的話,這些名字就有可能污染到全局的名字空間(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 指示符。

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

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

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

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

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

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

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





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

          }

          而且數組類型并沒有自己的意識。它并不知道自己的長度,我們必須另外記錄數組的信息。當我們希望把一個數組作為參數傳遞給一個函數的時候,問題就出現了。在c++中,數組不同于整型類型和浮點類型,它不是c++的一等公民(first——class),它是從c語言中繼承而來的,它反映了數據與對其進行操作的算法的分離。這正是過程話程序的特點。
          posted @ 2008-06-23 10:28 清流琴音 閱讀(219) | 評論 (1)編輯 收藏
           
          c++的輸入輸出功能是由輸入輸出流(iostream)庫提供的,輸入輸出流庫是c++面向對象類層次的一個結構,也是c++庫的一部分。
          終端的輸入也稱作是標準的輸入(standard input ),與預定義的iostream 對象sin 綁定在一起。
          終端輸出,也稱作是標準輸出(standard output ),與預定義的iosream的對象cout 綁定在 一起。
          第三那個預定義對象cerr,也稱為標準錯誤。也終端綁定。cerr通常用來給程序用戶提示錯誤的 信息,以警告的信息。
          任何想使用iostream庫的文件都要包含,相關的頭文件。
          #include< iostream.h>
          輸出操作符<<用來把一個值導向cout標準輸出或者cerr標準錯誤上。
          例如:
          cout<<"\n"; 中的“\n表示換行符(new line),輸出換行符的時候,它結束當前的行,并將輸出導向下一行。
          除了顯式的使用"\n"進行換行外,還是可以使用預定義的iostream 操作符endl。進行換行。
          操作符在iostream上,進行的是一個操作,而不只是簡單的提供一個數據。 
          文件的輸入和輸出:
          iostream庫也支持的輸入和輸出。所有能應用在標準當輸入和輸出的上的操作,也都可以應用在已經被打開的輸入和輸出文件上。
          為了打開一個文件供輸入和輸出,除了包含iostream外,還必須包含頭文件,
          #include<fstream>
          為了打開一個輸出文件,我們必須聲明一個ofstream類型的對象。
          ofstream outfile("name_of -files");
          為了測試是否成功的打開一個文件,我們可以用下面的代碼:
          if(!outfile)
          {
          ///如果文件不能打開,值為false

          }
          類似的,如果我們打開一個文件供輸入,那么我們必須聲明一個ifstream的對象。
          ifstream infile("name-of  _files")
          if(!infile)

          例如:
          c++中
          從一個文本中1.txt中讀內容到2.txt中,
          #include<iosrteam>
          #include<ftream>
          #include<string>
          using spacename std;//////注意這里。


          posted @ 2008-06-21 16:31 清流琴音 閱讀(164) | 評論 (0)編輯 收藏
           

          注釋是用來幫助程序員來讀程序結構的與語言。它是一種禮儀,可以用來說明變量的意義或者用來某一段難懂的代碼。注釋不會增加可執行代碼的長度,在生成可執行代碼之前編譯器會將注釋的部分從程序中去除的。
          c++中有兩種注釋符,一種是注釋對(/**/)。與c語言一樣,注釋的部分放在/**/之間。編譯器會將/**/之間的代碼當作注釋部分,注釋的可以放在任何位置。可以含有制表符,空格, 可以跨幾行。
          第二種注釋就是//雙斜線。它可以注釋單行的內容,注釋符右邊的內容都會被當作注釋的內容而被編譯器忽略。

          posted @ 2008-06-21 11:14 清流琴音 閱讀(155) | 評論 (0)編輯 收藏
           
          assert()是c語言標準庫提供的一個通用的標準庫預處理器宏。在代碼中經常用assert()來判斷一個必須的前提條件。例如:要打開一個文件,我們必須先知道合格文嘉你的名字,然后在可以打開為了使用assert()必須包含與之對應的頭文件
          #include < assert.h>
          下面是一個簡單的例子:
          assert(filename!=0);
          判斷是否文件的名字為0。建興斷言,如果文件的 名字為0,那么斷言失敗,輸出錯誤的診斷信息,然后中止程序。
          assrt.h是c標準庫頭文件的c名字。c++程序可以通過使用c的庫頭文件的c名字或者c++的名字來使用它。
          這個頭文件的c++名字是cassert. c庫頭文件的c++名字總是以c開頭,后面跟的是c名字去掉.h的名字。(因為c++中,頭文件的后綴各不相同,所以標準的c++沒有指定頭文件的后綴).
          使用c庫頭文件名字和使用c++的名字,那么#include 預處理器的效果也是不一樣的。
          例如:下面的#include指示符;
          #include<cassert>
          當我們把這個頭文件讀入我們的文本文件中的時候,頭文件中的內容 好似不可見的。因為所有的c++庫名字是在std名字空間中定義的。所以我們的文本文件是不可見的。除非我們使用using指示符顯示地使其可見。
          using  namespace  cassert;
          使用c庫的頭文件就可以直接的在文本文件中使用assert()。而無需使用using指示符了。


          posted @ 2008-06-21 11:12 清流琴音 閱讀(435) | 評論 (0)編輯 收藏
           
          編譯c++的時候,編譯器自動定義了一個預處理器名字_ _cplusplus,(注意前面有兩個下劃線)。
          因此我們可以根據它來判斷程序是否為c++程序,以便有條件的包含代碼。
          例如:
          #ifdef _ _cplusplus
          //不錯,我們要編譯c++
          //extern "c"我們在第七章在講解
          extern"c"
          #endif
          min(int ,int );
          在編譯c的時候,編譯器定義一個_STDC_,當然_ _cpluscplus和_STDC_不會同時被定義的,
          另外兩個比較有用的名字是_LINE_和_FILE_。其中_LINE_是指已經編譯的行數。_FILE_包含正在被編譯的文件的名字。
          另外兩個預定義的名字是:_TIME_和_DATE_它們分別包含被編譯文件的時間和日期。
          時間的格式為:hh:mm:ss
          例如:如果你是在正8點17分編譯這個文件,那么時間表示為8:17:00。如果那天剛好為1998年10月23號,那么日期就為:oct23 1998
          如果當前的或者文件的名字發生了變化,那么預定義名字_LINE_和_FILE_就會變化,其他的預定義名字在編譯期間不會變化的。她們的值也不能被修改




          posted @ 2008-06-21 10:44 清流琴音 閱讀(116) | 評論 (0)編輯 收藏
           

          頭文件通過預處理器標識符(include)而成為我們程序的一部分。預處理器標識符用“#”來標識。這個符號放在程序的最開始 的第一行的位置上。處理這些標識符的程序稱為預處理器(preprocessor),一般綁定在編譯器中。
          include 指示符讀入指定文件的內容,它有兩種格式:
          #include<iostream>
          #include"iostream"
          如果文件名用"<"和 ">"括起來。那么表示這個文件是一個工程文件或者標準的頭文件。查找過程會檢查預定義的目錄。我們可以通過設置搜索路徑環境變量或者命令行選項來修改這些目錄。
          如果文件是用引號括起來的,就表示這個文件是用戶自己提供的,那么查找這個文件的時候,就可以從當前的目錄開始查找,
          被包含的文件可能還會包含#include,一個同文件可能會被同一個原文件多次的包含。條件指示符可以防止這種頭文件被重復包含的情況。
          例如:
          #ifndef   BOOKSTORE_H
          #define BOOKSTORE_H
          /*bookstore.h的內容*/
          #endif
          條件指示符#ifndef用于檢查預編譯器常量BOOKSTORE_H是否已經被定義了(習慣上我們把與編譯器常量用大寫表示)。如果BOOKSTORE_H沒有在前面定義的話,那么#ifndef 的值為真。那么#ifndef 和#endif中間的語句

          將會被執行,否則的話,之間的語句就會被忽略。
          為了保證頭文件只被處理一次。把如下的的頭文件放在#ifndef的后面。
          #define指示符放在#ifndef的后面。這樣頭文件在第一次包含的時候,BOOOKSTORE_H就被定義了,那么以后如果在出現包含頭文件的情況,則 #ifndef的值就為假了。
          只要不存在“兩個必須包含的頭文件使用同一個預編譯器常量”這種情況,那么這種機制就會很好的運行。
          #ifdef指示符用來判斷一個預定義器常量是否已經被定義了,以便有條件的包含程序代碼。

          注意:
          #ifndef條件指示符和ifdef指示符的區別。
          前者用于防止頭文件被重復包含,而后者則是為了判斷一下一個預定義器常量是否被定義了。


          我們在編譯程序的時候,可以使用-D,在——D的后面寫上預處理器常量的名字,這樣就可以在命令行中定義一個與處理器的常量了。
          $CC -DBOOKSTORE_H   main.c
          也可以用#define指示符來定義一個預處理器的常量。


          posted @ 2008-06-17 14:58 清流琴音 閱讀(451) | 評論 (2)編輯 收藏
           

          我們的程序是由算法和數據組成的。算法是(就是將指令組織起來實現特定的功能),
          在c++語言中,動作 被稱為表達式(expression),以分號結尾的表達式稱為語句。在程序中最小的單元是語句(statement).
           函數:把語句按照邏輯分組,就形成了某些單元,。這些單元稱為函數(funtion)。
          函數由四個部分組成:函數返回值的類型,函數名,參數列表,函數體,前三個組合起來稱為函數原型(funtion prototype).
          函數的參數由一個或者多個逗號隔開,由一個小括號括起來。函數體由一對花括號括起來。
          return 語句是c++語句提供的預定義的語句,它提供了一種中止函數執行的方法。當return返回一個值的時候。例如:0 ,就表示這個函數返回了這個值(return value)。在標準的c++中當函數沒有顯示的返回值的時候,默認的函數返回值為0。
          void 用來指定一個沒有返回值的函數。
          #include 是預處理器指示符(preprocessor directive)
          在c++標準庫中的名字。如:cout 不能直接在程序中使用,除非在預處理器標識符:#include<iostream>的后面使用 using  namespce std;
          這條語句被稱為using 指示符(using directve),c++標準庫中的名字在我們的程序的文件是不可見的,它們都是在一個名字空間中聲明的。我們只有顯示的使用它們。這樣的話,這些聲明在名字空間中的名字才有可能在我們的文件中可見。using 告訴編譯器使用在std名字空間中的名字。
          編譯器的一部分的功能是:分析程序代碼的正確性,另一個功能是轉換正確的程序代碼。這種轉換稱為代碼的生成(code generation),一般的情況下這些會生成匯編指令或者目標代碼。這些目標代碼可以被運行這些程序的計算機所理解。
          成功編譯的結果是一個可執行的文件。
          c++定義了一組內置的數據類型,這些數據類型是:整型(int ),浮點型(float),布爾型(ture,和false ),字符類型,
          在這些內置的數據類型之間可以隱式的發生轉換(conversion).
          c++標準還提供了一組擴展的數據類型。字符串類型(string),復數類型(complex number ),列表(list),向量(vector).



          posted @ 2008-06-17 14:19 清流琴音 閱讀(172) | 評論 (0)編輯 收藏
           
          動態連接是一種(juest-in -time)連接。這個就是以意味著,程序在執行的時候要能正確的找到函數庫,連接器通過把庫文件名和路徑名植入到可執行文件中做到這一點,這就意味著函數庫的路徑不可以隨意的改變。
          使用靜態連接的最大危險在于,將來版本的操作系統可能會和現在可執行文件所綁定的系統函數庫不兼容。
          函數庫鏈接的5個秘密:
          1;動態鏈接庫文件的擴展名字是 ".so",而靜態連接庫文件的函數名字是".a".
          posted @ 2008-06-10 15:29 清流琴音 閱讀(127) | 評論 (0)編輯 收藏
           
          比較數組和指針的區別,就是比較它們各自的特點:
          第一:指針中保存的是數據的地址,而數組保存的是直接的數據。
          第二:指針是間接的訪問數據,首先得到指針的內容,然后以這個指針的內容作為地址,通過這個地址來訪問數據, 而數組則是直接訪問數據,a[i]表示以a[i-1]為地址來訪問數據。
          第三:指針通常用于動態的數據結構,數組一般用于存貯固定數目且數據類型相同的數據元素。
          第四:指針相關的函數為mallo(),free(),數組隱式的分配和刪除
          第五:指針通常指向匿名數據,數組本身就是數據名。

          數組和指針都可以在它們定義的時候,用字符串常量來初始化。雖然形式是一樣的,但是底層的機制卻是不一樣的。
          指針在定義的時候,編譯器并不為指針所指向的對象分配空間,而只是為其本身的分配空間。除非在定義的時候用字符串常量進行初始化。但是只能用字符串常量進行初始化,其他的象浮點型,int型的常量是不可以的,編譯的時候會出現無法編譯的錯誤。
          例如:char* p="dfdf f "(為其分配了內存空間)
             char*p=3.14//會出現編譯錯誤
          在ASCI C中,初始化指針的字符串常量被定義為只讀。如果試圖通過指針來修改字符串常量的內容,就會出現未定義的行為。有些編譯器中,把這些字符串常量保存在一個只讀的文本中,防止被修改。
          數組也可以用字符串常量進行初始化,與指針相反的是用字符串常量進行初試話的數組,可以被 修改的,單個字符在以后中是可以改變的,例如:
           char butter[]="ff ff ff ff";
           strncpy(butter,"111",5);
          結果就是 char butter[]="111fff';

          posted @ 2008-06-06 10:45 清流琴音 閱讀(503) | 評論 (0)編輯 收藏
           
          為您介紹簡單方法就是可以從SQL Server Online Book開始學習SQL服務器的所有內容,并配合SQL Server開始安裝、設置和使用了。

            當你進入了編程環境,就可以建立數據庫并使用不同的工具來學習數據庫的各種方法,例如設計一個邏輯數據模型并執行它。因為SQL與數據的操作有關,你可以使用其各種特性,還可以建立存儲程序,觸發器,查看等功能。

            提醒您不要忽略安全機制和性能調試,對于一個數據庫而言,觀察并調試使之順利平穩地工作是至關重要的。除此之外,MCDBA考試還包括與性能調試和特定程序相關的問題。

            下面是在輔導下已經通過MCDBA的學員總結的一些學習經驗:

            1、先熟悉MMC,即Enterprise Manager的操作;

            2、學會用SQL Query Analyzer分析你的SQL語句執行效率;

            3、使用存儲過程/視圖/以及SQL Server特有的服務;

            4、學會使用Profiler來調試你的客戶端程序;

            5、學習數據庫管理技術;

            6、熟讀SQL Server Online Book非常有用!如果不怕辛苦看一遍很值得。

          posted @ 2008-03-19 18:24 清流琴音 閱讀(220) | 評論 (3)編輯 收藏
           
          111
          http://www.verycd.com/topics/160024/

          http://www.verycd.com/topics/64762
          http://www.verycd.com/search/folders/mcse
          http://www.mcse.org.cn/showtopic-4987.aspx 
          http://www.mcse.org.cn/showforum-2.html
          http://www.verycd.com/search/folders/mcse
          http://bbs.tech.ccidnet.com/read.php?tid=283574
          http://www.zuowenw.com/jsjks/microsoft/kaoshifudao/MCDBA/
          http://www.softii.com/downlist/s_313_2.html
          posted @ 2008-03-14 20:12 清流琴音 閱讀(153) | 評論 (3)編輯 收藏
           
          主站蜘蛛池模板: 池州市| 大英县| 印江| 汉阴县| 巴南区| 商水县| 澄江县| 沐川县| 澜沧| 恩施市| 扎兰屯市| 怀远县| 德令哈市| 桦甸市| 乐陵市| 泾阳县| 会泽县| 河南省| 潍坊市| 颍上县| 晋江市| 巴楚县| 蒲城县| 漯河市| 阿尔山市| 丹棱县| 长岭县| 榆中县| 蒙城县| 新闻| 兴山县| 平山县| 郧西县| 武威市| 高密市| 揭东县| 阿坝| 寿阳县| 惠安县| 荥阳市| 南昌市|