• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            Where there is a dream ,there is hope

              C++博客 :: 首頁(yè) :: 聯(lián)系 :: 聚合  :: 管理
              64 Posts :: 0 Stories :: 8 Comments :: 0 Trackbacks

            常用鏈接

            留言簿(1)

            我參與的團(tuán)隊(duì)

            搜索

            •  

            最新評(píng)論

            閱讀排行榜

            評(píng)論排行榜

            #

             

            都是內(nèi)存對(duì)齊,稍有區(qū)別,這里測(cè)試平臺(tái)是VS2008,其它平臺(tái)為測(cè)試

            #pragma pack( n ),
            結(jié)構(gòu)體中的數(shù)據(jù)成員,除了第一個(gè)是始終放在最開始的地方,其它數(shù)據(jù)成員的地址必須是它本身大小或?qū)R參數(shù)兩者中較小的一個(gè)的倍數(shù)
             即:min(n, sizeof(elem))

            結(jié)構(gòu)體整個(gè)的大小就沒有另外的要求

             

            #pragma pack(1)
            struct TestA
            {
                
            char  a;
                
            short b;
                
            char  c;
            }
            ;

            #pragma pack(
            4)
            struct TestB
            {
                
            char  a;
                
            short b;
                
            char  c;
            }
            ;


            結(jié)果:


            在結(jié)構(gòu)體中含有結(jié)構(gòu)體的話,內(nèi)結(jié)構(gòu)體的大小按照此結(jié)構(gòu)體內(nèi)最大元素的大小來計(jì)算,各個(gè)元素的計(jì)算方法如下:
            min(n, e ||max({e}) )

            #pragma pack( 4 )
            struct TestA
            {
                
            char  a;
                
            short b;
                
            char  c;
            }
            ;

            #pragma pack( 
            8 )
            struct TestB
            {
                
            char  a;
                
            char  c;
                TestA m_a;
            }
            ;

            因?yàn)門estA最大的元素是short 2B,所以計(jì)算TestA的大小的時(shí)候,按照2來算



            當(dāng)__declspec( align(#) )#pragma pack( n )同時(shí)修飾結(jié)構(gòu)體的時(shí)候,前者的優(yōu)先級(jí)高,
            注意前者與后者的區(qū)別:

            成員的地址決定于前者及后者,其要么是前者的倍數(shù),要么是后者的倍數(shù),要么是成員的大小的倍數(shù),取最小。

            結(jié)構(gòu)體最后的大小于前者有關(guān),其要么是前者的倍數(shù),要么是結(jié)構(gòu)體中最大偏移量的倍數(shù),取最大。

            要算出最后結(jié)果,必須知道兩者的值或缺省值

            __declspec(align(1)) struct TestA
            {
                
            char  a;
                
            short b;
                
            char  c;
                
            double d;
            }
            ;

            __declspec(align(
            32)) struct TestB
            {
                
            char  a;
                
            short b;
                
            char  c;
                
            double d;
            }
            ;

            輸出:

            posted @ 2011-03-14 12:21 IT菜鳥 閱讀(375) | 評(píng)論 (0)編輯 收藏

                 摘要: 溫故而知新,總結(jié)了多種單例模式的寫法,考慮上多線程沒有非常完美的,各取所需吧 //1.//Easy ,<<Pattern Design>>//Q://When to free the m_singleton space?//when to execute the ...  閱讀全文
            posted @ 2011-03-09 16:18 IT菜鳥 閱讀(325) | 評(píng)論 (0)編輯 收藏

            總用到這個(gè)轉(zhuǎn)化,記下來
            wchar_t* atow(char* src)
            {
                
            int dest_len;
                dest_len 
            = MultiByteToWideChar(CP_ACP,0,src,-1,NULL,0);
                wchar_t 
            *dest = new wchar_t[dest_len];
                
            if(dest == NULL)
                    
            return NULL;
                MultiByteToWideChar(CP_ACP,
            0,src,-1,dest,dest_len);
                
            return dest;
            }
            posted @ 2011-02-28 12:05 IT菜鳥 閱讀(399) | 評(píng)論 (0)編輯 收藏

            static關(guān)鍵字在C和C++中的用法稍有區(qū)別,主要是C++擴(kuò)展了static關(guān)鍵字的作用
            C 用法
            1.修飾函數(shù)成員變量:例

            //test.h
            void test_static_var();

            //test.c
            void test_static_var()
            {
                
            static int var=0;//!不初始化默認(rèn)為0
                var++;
                printf(
            "static int var : %d \n", var);
            }


            //main.c
            int main()
            {
                
            for (int i=0; i<10; i++)
                
            {
                    test_static_var();
                }

                getchar();
                
            return 0;
            }

            2.在文件級(jí)別(即:在函數(shù)體外)修飾 變量或者函數(shù),則表示該變量只在該文件中可見及可用
            //test.h
            void test_static_funtion_one();
            void test_static_fuction_two();

            //test.c
            void test_static_funtion_one()
            {
                printf(
            "This is a normal function. \n");
            }

            static
            void test_static_fuction_two()
            {
                printf(
            "This is a function modified by static. \n");
            }


            //main.c

            int main()
            {
                test_static_funtion_one();
                test_static_fuction_two();
                getchar();
                
            return 0;
            }

            這樣就會(huì)報(bào)錯(cuò):LNK2001: 無(wú)法解析的外部符號(hào) "void __cdecl test_static_fuction_two(void)" (?test_static_fuction_two@@YAXXZ)
            原因就是test_static_fuction_two()被修飾為static ,如果main中不調(diào)用的話,編譯可以通過(VS08),否則便以失敗
            修飾為static后,它只能在test.c中使用。

            C++中包含了前兩種方法,又?jǐn)U展了下面兩種方法:
            3.修飾class 數(shù)據(jù)成員,稱為 靜態(tài)數(shù)據(jù)成員
            4.修飾class 函數(shù)成員,稱之為 靜態(tài)成員函數(shù)
            //test.h
                 class TestA
                 
            {
                 
            public:
                     
                     
            static int s_count;
                     
            static int getCount();
                 
            public:
                     
            int m_value;
                 }
            ;

            //test.c
                int TestA::s_count=0;
                
            int TestA::getCount()
                
            {
                    
            //m_value+=m_value; 靜態(tài)函數(shù)中只能操作靜態(tài)數(shù)據(jù)成員
                    return s_count;
                }
            因?yàn)殪o態(tài)成員函數(shù)沒有傳入隱式的this指針,所以,它不能使用. 、->操作符 ;不能是virtual 的,不能和非靜態(tài)的同名
            posted @ 2011-02-16 12:21 IT菜鳥 閱讀(203) | 評(píng)論 (0)編輯 收藏

            當(dāng)定義一個(gè)命名空間時(shí),可以忽略這個(gè)命名空間的名稱:

                 namespce {
                     char c;
                     int i;
                     double d;
                 }
                 編譯器在內(nèi)部會(huì)為這個(gè)命名空間生成一個(gè)唯一的名字,而且還會(huì)為這個(gè)匿名的命名空間生成一條using指令。所以上面的代碼在效果上等同于:
                 namespace __UNIQUE_NAME_ {
                     char c;
                     int i;
                     double d;
                 }
                 using namespace __UNIQUE_NAME_;
             
                 在匿名命名空間中聲明的名稱也將被編譯器轉(zhuǎn)換,與編譯器為這個(gè)匿名命名空間生成的唯一內(nèi)部名稱(即這里的__UNIQUE_NAME_)綁定在一起。還有一點(diǎn)很重要,就是這些名稱具有internal鏈接屬性,這和聲明為static的全局名稱的鏈接屬性是相同的,即名稱的作用域被限制在當(dāng)前文件中,無(wú)法通過在另外的文件中使用extern聲明來進(jìn)行鏈接。如果不提倡使用全局static聲明一個(gè)名稱擁有internal鏈接屬性,則匿名命名空間可以作為一種更好的達(dá)到相同效果的方法。
            注意:命名空間都是具有external 連接屬性的,只是匿名的命名空間產(chǎn)生的__UNIQUE_NAME__在別的文件中無(wú)法得到,這個(gè)唯一的名字是不可見的.
            C++ 新的標(biāo)準(zhǔn)中提倡使用匿名命名空間,而不推薦使用static,因?yàn)閟tatic用在不同的地方,涵義不同,容易造成混淆.另外,static不能修飾class
            posted @ 2011-02-16 10:12 IT菜鳥 閱讀(687) | 評(píng)論 (2)編輯 收藏

            原文地址:http://www.cnblogs.com/ly4cn/archive/2005/11/28/286185.html

                指針,在C/C++語(yǔ)言中一直是很受寵的;幾乎找不到一個(gè)不使用指針的C/C++應(yīng)用。用于存儲(chǔ)數(shù)據(jù)和程序的地址,這是指針的基本功能。用于指向整型數(shù),用整數(shù)指針(int*);指向浮點(diǎn)數(shù)用浮點(diǎn)數(shù)指針(float*);指向結(jié)構(gòu),用對(duì)應(yīng)的結(jié)構(gòu)指針(struct xxx *);指向任意地址,用無(wú)類型指針(void*)。
                有時(shí)候,我們需要一些通用的指針。在C語(yǔ)言當(dāng)中,(void*) 可以代表一切;但是在C++中,我們還有一些比較特殊的指針,無(wú)法用(void*)來表示。事實(shí)上,在C++中,想找到一個(gè)通用的指針,特別是通用的函數(shù)指針簡(jiǎn)直是一個(gè)“不可能任務(wù)”。
               
                C++是一種靜態(tài)類型的語(yǔ)言,類型安全在C++中舉足輕重。在C語(yǔ)言中,你可以用void*來指向一切;但在C++中,void*并不能指向一切,就算能,也失去了類型安全的意義了。類型安全往往能幫我們找出程序中潛在的一些BUG。
               
                下面我們來探討一下,C++中如何存儲(chǔ)各種類型數(shù)據(jù)的指針。

               
                1.  數(shù)據(jù)指針
                 數(shù)據(jù)指針分為兩種:常規(guī)數(shù)據(jù)指針和成員數(shù)據(jù)指針
                 
                1.1 常規(guī)數(shù)據(jù)指針
                 這個(gè)不用說明了,和C語(yǔ)言一樣,定義、賦值是很簡(jiǎn)單明了的。常見的有:int*, double* 等等。
                 如:
                 int value = 123;
                 
            int * pn = &value;
               
                 
                1.2 成員數(shù)據(jù)指針
                 有如下的結(jié)構(gòu):
                 struct MyStruct
                 {
                   
            int key;
                   
            int value;
                 };
               
                 現(xiàn)在有一個(gè)結(jié)構(gòu)對(duì)象:
                 MyStruct me;
                 MyStruct* pMe = &me;
               
                 我們需要 value 成員的地址,我們可以:
                 int * pValue = &me.value;
                 //
                 int * pValue = &pMe->value;
               
                 當(dāng)然了,這個(gè)指針仍然是屬于第一種范籌----常規(guī)數(shù)據(jù)指針。
                 
                 好了,我們現(xiàn)在需要一種指針,它指向MyStruct中的任一數(shù)據(jù)成員,那么它應(yīng)該是這樣的子:
                 int MyStruct::* pMV = &MyStruct::value;
                 
            //
                 int MyStruct::* pMK = &MyStruct::key;
               
                 這種指針的用途是用于取得結(jié)構(gòu)成員在結(jié)構(gòu)內(nèi)的地址。我們可以通過該指針來訪問成員數(shù)據(jù):
                 int value = pMe->*pMV; // 取得pMe的value成員數(shù)據(jù)。
                 int key = me.*pMK; // 取得me的key成員數(shù)據(jù)。
               
                 那么,在什么場(chǎng)合下會(huì)使用到成員數(shù)據(jù)指針呢?
                 確實(shí),成員指針本來就不是一種很常用的指針。不過,在某些時(shí)候還是很有用處的。我們先來看看下面的一個(gè)函數(shù):
              int sum(MyStruct* objs, int MyStruct::* pm, int count)
              {
                  
            int result = 0;
                  
            for(int i = 0; i < count; ++i)
                      result 
            += objs[i].*pm;
                  
            return result;
              }
                 
                 這個(gè)函數(shù)的功能是什么,你能看明白嗎?它的功能就是,給定count個(gè)MyStruct結(jié)構(gòu)的指針,計(jì)算出給定成員數(shù)據(jù)的總和。有點(diǎn)拗口對(duì)吧?看看下面的程序,你也許就明白了:
                 
                 MyStruct me[10=
                 {
                  {
            1,2},{3,4},{5,6},{7,8},{9,10},{11,12},{13,14},{15,16},{17,18},{19,20}
                 };
                 
                 
            int sum_value = sum(me, &MyStruct::value, 10);
                 
            //計(jì)算10個(gè)MyStruct結(jié)構(gòu)的value成員的總和: sum_value 值 為 110     (2+4+6+8++20)
                 
                 
            int sum_key = sum(me, &MyStruct::key, 10);
                 
            //計(jì)算10個(gè)MyStruct結(jié)構(gòu)的key成員的總和:   sum_key 值 為 100       (1+3+5+7++19)
               
                 
                 也許,你覺得用常規(guī)指針也可以做到,而且更易懂。Ok,沒問題:
                 int sum(MyStruct* objs, int count)
                 {
                  
            int result = 0;
                  
            for(int i = 0; i < count; ++i)
                   result 
            += objs[i].value;
                  
            return result;
                 }

                 你是想這么做嗎?但這么做,你只能計(jì)算value,如果要算key的話,你要多寫一個(gè)函數(shù)。有多少個(gè)成員需要計(jì)算的話,你就要寫多少個(gè)函數(shù),多麻煩啊。 
            posted @ 2011-02-15 11:19 IT菜鳥 閱讀(357) | 評(píng)論 (1)編輯 收藏


            對(duì)于拷貝構(gòu)造函數(shù)引用傳遞,似乎司空見慣,認(rèn)為理所當(dāng)然。但是被問起這個(gè)問題,的確是一片茫然,為什么呢?

            去網(wǎng)上搜索了一下,的確有很多這方面的知識(shí)講解。

            我們先看一下CSDN上的一個(gè)帖子的回答:
            簡(jiǎn)單的回答是為了防止遞歸引用。
            具體一些可以這么講:
             當(dāng)一個(gè)對(duì)象需要以值方式傳遞時(shí),編譯器會(huì)生成代碼調(diào)用它的拷貝構(gòu)造函數(shù)以生成一個(gè)復(fù)本。如果類A的拷貝構(gòu)造函數(shù)是以值方式傳遞一個(gè)類A對(duì)象作為參數(shù)的話,當(dāng)需要調(diào)用類A的拷貝構(gòu)造函數(shù)時(shí),需要以值方式傳進(jìn)一個(gè)A的對(duì)象作為實(shí)參; 而以值方式傳遞需要調(diào)用類A的拷貝構(gòu)造函數(shù);結(jié)果就是調(diào)用類A的拷貝構(gòu)造函數(shù)導(dǎo)致又一次調(diào)用類A的拷貝構(gòu)造函數(shù),這就是一個(gè)無(wú)限遞歸。

            這個(gè)解釋還是蠻具體的。
            利用值傳遞的話,會(huì)導(dǎo)致遞歸引用。

            還有一片文章也談到了這個(gè)問題, 我覺得寫得也非常好!

            為什么拷貝構(gòu)造函數(shù)必須為引用傳遞,不能是值傳遞?
            鏈接地址:http://www.cnblogs.com/chio/archive/2007/09/14/893299.html

            其中講到了3個(gè)問題
            1是拷貝構(gòu)造函數(shù)的作用。
                  作用就是用來復(fù)制對(duì)象的,在使用這個(gè)對(duì)象的實(shí)例來初始化這個(gè)對(duì)象的一個(gè)新的實(shí)例。
            2是參數(shù)傳遞過程到底發(fā)生了什么?
                  將地址傳遞和值傳遞統(tǒng)一起來,歸根結(jié)底還是傳遞的是"值"(地址也是值,只不過通過它可以找到另一個(gè)值)!
            i)值傳遞:
                對(duì)于內(nèi)置數(shù)據(jù)類型的傳遞時(shí),直接賦值拷貝給形參(注意形參是函數(shù)內(nèi)局部變量);
                對(duì)于類類型的傳遞時(shí),需要首先調(diào)用該類的拷貝構(gòu)造函數(shù)來初始化形參(局部對(duì)象);如void foo(class_type obj_local){}, 如果調(diào)用foo(obj);  首先class_type obj_local(obj) ,這樣就定義了局部變量obj_local供函數(shù)內(nèi)部使用
            ii)引用傳遞:
                無(wú)論對(duì)內(nèi)置類型還是類類型,傳遞引用或指針最終都是傳遞的地址值!而地址總是指針類型(屬于簡(jiǎn)單類型), 顯然參數(shù)傳遞時(shí),按簡(jiǎn)單類型的賦值拷貝,而不會(huì)有拷貝構(gòu)造函數(shù)的調(diào)用(對(duì)于類類型).
            3是在類中有指針數(shù)據(jù)成員時(shí),拷貝構(gòu)造函數(shù)的使用?
                    如果不顯式聲明拷貝構(gòu)造函數(shù)的時(shí)候,編譯器也會(huì)生成一個(gè)默認(rèn)的拷貝構(gòu)造函數(shù),而且在一般的情況下運(yùn)行的也很好。但是在遇到類有指針數(shù)據(jù)成員時(shí)就出現(xiàn)問題了:因?yàn)槟J(rèn)的拷貝構(gòu)造函數(shù)是按成員拷貝構(gòu)造,這導(dǎo)致了兩個(gè)不同的指針(如ptr1=ptr2)指向了相同的內(nèi)存。當(dāng)一個(gè)實(shí)例銷毀時(shí),調(diào)用析構(gòu)函數(shù)free(ptr1)釋放了這段內(nèi)存,那么剩下的一個(gè)實(shí)例的指針ptr2就無(wú)效了,在被銷毀的時(shí)候free(ptr2)就會(huì)出現(xiàn)錯(cuò)誤了, 這相當(dāng)于重復(fù)釋放一塊內(nèi)存兩次。這種情況必須顯式聲明并實(shí)現(xiàn)自己的拷貝構(gòu)造函數(shù),來為新的實(shí)例的指針分配新的內(nèi)存。

            問題1和2回答了為什么拷貝構(gòu)造函數(shù)使用值傳遞會(huì)產(chǎn)生無(wú)限遞歸調(diào)用的問題;
            問題3回答了回答了在類中有指針數(shù)據(jù)成員時(shí),拷貝構(gòu)造函數(shù)使用值傳遞等于白顯式定義了拷貝構(gòu)造函數(shù),因?yàn)槟J(rèn)的拷貝構(gòu)造函數(shù)就是這么干的
            posted @ 2011-02-14 17:50 IT菜鳥 閱讀(775) | 評(píng)論 (0)編輯 收藏

            (轉(zhuǎn)自:http://grantren.javaeye.com/blog/43289)

            一 拷貝構(gòu)造函數(shù)是C++最基礎(chǔ)的概念之一,大家自認(rèn)為對(duì)拷貝構(gòu)造函數(shù)了解么?請(qǐng)大家先回答一下三個(gè)問題:

            1. 以下函數(shù)哪個(gè)是拷貝構(gòu)造函數(shù),為什么?

            1. X::X(const X&);   
            2. X::X(X);   
            3. X::X(X&, int a=1);   
            4. X::X(X&, int a=1, b=2);  

             2. 一個(gè)類中可以存在多于一個(gè)的拷貝構(gòu)造函數(shù)嗎?

            3. 寫出以下程序段的輸出結(jié)果, 并說明為什么? 如果你都能回答無(wú)誤的話,那么你已經(jīng)對(duì)拷貝構(gòu)造函數(shù)有了相當(dāng)?shù)牧私狻?/font>

            1. #include    
            2. #include    
            3.   
            4. struct X {   
            5.   template<typename T>   
            6.   X( T& ) { std::cout << "This is ctor." << std::endl; }   
            7.   
            8.   template<typename T>   
            9.     X& operator=( T& ) { std::cout << "This is ctor." << std::endl; }   
            10. };   
            11.   
            12. void main() {   
            13.   X a(5);   
            14.   X b(10.5);   
            15.   X c = a;   
            16.   c = b;   
            17. }  

             

            解答如下:

            1. 對(duì)于一個(gè)類X,如果一個(gè)構(gòu)造函數(shù)的第一個(gè)參數(shù)是下列之一:
            a) X&
            b) const X&
            c) volatile X&
            d) const volatile X&
            且沒有其他參數(shù)或其他參數(shù)都有默認(rèn)值,那么這個(gè)函數(shù)是拷貝構(gòu)造函數(shù). 

            1. X::X(const X&);  //是拷貝構(gòu)造函數(shù)   
            2. X::X(X&, int=1); //是拷貝構(gòu)造函數(shù)  

             2.類中可以存在超過一個(gè)拷貝構(gòu)造函數(shù), 

            1. class X {      
            2. public:      
            3.   X(const X&);      
            4.   X(X&);            // OK   
            5. };  

            注意,如果一個(gè)類中只存在一個(gè)參數(shù)為X&的拷貝構(gòu)造函數(shù),那么就不能使用const X或volatile X的對(duì)象實(shí)行拷貝初始化.

            1. class X {   
            2. public:   
            3.   X();   
            4.   X(X&);   
            5. };   
            6.     
            7. const X cx;   
            8. X x = cx;    // error   

            如果一個(gè)類中沒有定義拷貝構(gòu)造函數(shù),那么編譯器會(huì)自動(dòng)產(chǎn)生一個(gè)默認(rèn)的拷貝構(gòu)造函數(shù).
            這個(gè)默認(rèn)的參數(shù)可能為X::X(const X&)或X::X(X&),由編譯器根據(jù)上下文決定選擇哪一個(gè).

            默認(rèn)拷貝構(gòu)造函數(shù)的行為如下:
             默認(rèn)的拷貝構(gòu)造函數(shù)執(zhí)行的順序與其他用戶定義的構(gòu)造函數(shù)相同,執(zhí)行先父類后子類的構(gòu)造.
             拷貝構(gòu)造函數(shù)對(duì)類中每一個(gè)數(shù)據(jù)成員執(zhí)行成員拷貝(memberwise Copy)的動(dòng)作.
             a)如果數(shù)據(jù)成員為某一個(gè)類的實(shí)例,那么調(diào)用此類的拷貝構(gòu)造函數(shù).
             b)如果數(shù)據(jù)成員是一個(gè)數(shù)組,對(duì)數(shù)組的每一個(gè)執(zhí)行按位拷貝.
             c)如果數(shù)據(jù)成員是一個(gè)數(shù)量,如int,double,那么調(diào)用系統(tǒng)內(nèi)建的賦值運(yùn)算符對(duì)其進(jìn)行賦值.

             

            3.  拷貝構(gòu)造函數(shù)不能由成員函數(shù)模版生成. 

            1. struct X {   
            2.     template<typename T>   
            3.     X( const T& );    // NOT copy ctor, T can't be X   
            4.   
            5.     template<typename T>   
            6.     operator=( const T& );  // NOT copy ass't, T can't be X   
            7. };   
            8.   

            原因很簡(jiǎn)單, 成員函數(shù)模版并不改變語(yǔ)言的規(guī)則,而語(yǔ)言的規(guī)則說,如果程序需要一個(gè)拷貝構(gòu)造函數(shù)而你沒有聲明它,那么編譯器會(huì)為你自動(dòng)生成一個(gè). 所以成員函數(shù)模版并不會(huì)阻止編譯器生成拷貝構(gòu)造函數(shù), 賦值運(yùn)算符重載也遵循同樣的規(guī)則.(參見Effective C++ 3edition, Item45)


            二 針對(duì)上面作者的討論,理解更深了,但是下面我還是會(huì)給出一個(gè)一般的標(biāo)準(zhǔn)的實(shí)現(xiàn)和注意事項(xiàng):
            #include "stdafx.h"
            #include 
            "stdio.h"
            #include 
            <iostream>
            #include 
            <string>


            struct Test1 
            {
                Test1() 
            { }
                Test1(
            int i) { id = i; }
                Test1(
            const Test1& test)
                
            {
                    id 
            = test.id;
                }

                Test1
            & operator = (const Test1& test)
                
            {
                    
            if(this == &test)
                        
            return *this;
                    id 
            = test.id;
                    
            return *this;
                }

                
            int id;
            }
            ;

            class Test2
            {
            public:
                Test2()
            { m_pChar = NULL;}
                Test2(
            char *pChar) { m_pChar = pChar;}
                Test2(
            int num) 
                

                    m_pChar 
            = new char[num];
                    
            for(int i = 0; i< num; ++i)
                        m_pChar[i] 
            = 'a';
                    m_pChar[num
            -1= '\0';
                }

                Test2(
            const Test2& test)
                
            {
                    
            char *pCharT = m_pChar;

                    m_pChar 
            = new char[strlen(test.m_pChar)];
                    strcpy(m_pChar, test.m_pChar);

                    
            if(!pCharT)
                        delete []pCharT;
                }

                Test2
            & operator = (const Test2& test)
                
            {
                    
            if(this == &test)
                        
            return *this;

                    
            char *pCharT = m_pChar;
                    m_pChar 
            = new char[strlen(test.m_pChar)];
                    strcpy(m_pChar, test.m_pChar);

                    
            if(!pCharT)
                        delete []pCharT;

                    
            return *this;
                }

            private:
                
            char *m_pChar;
            }
            ;

            int main(int argc, char* argv[])
            {
                
            const Test1 ts(1); // Test1()
                const Test1* p_ts = &ts;
                
            const Test1 ts2(ts); //Test(const Test1& test)
                const Test1 ts3 = ts; //Test(const Test1& test)
                Test1 ts4; ts4 = ts;  //Test1& operator = (const Test1& test)

                Test2 t(
            5);
                Test2 t2(t);
                Test2 t3 
            = t2;
                Test2 t4; t4 
            = t;
                
            return 0;
            }

            posted @ 2011-02-14 17:38 IT菜鳥 閱讀(314) | 評(píng)論 (0)編輯 收藏

            看到一個(gè)簡(jiǎn)潔的字符串連接函數(shù),頗有啟發(fā)性
            void constr(char* f,char* s)
            {
                
            while(*f!=0)
                
            {
                    f
            ++;
                }

                
            while((*f++=*s++)!=0)
                
            {

                }

                
            }

            int main()
            {

                
            char f[]="Hello";
                
            char s[]="World";
                
                constr(f,s);
                printf(
            "%s",f);
                getchar();
                
            return 0;
            }
            posted @ 2011-02-14 15:24 IT菜鳥 閱讀(612) | 評(píng)論 (2)編輯 收藏

            VC++的預(yù)編譯功能
            TAG:預(yù)編譯和宏定義,VC++,VC++的預(yù)編譯功能
            TEXT:
            這里介紹VC6的預(yù)編譯功能的使用,由于預(yù)編譯詳細(xì)使用比較的復(fù)雜,這里只介紹幾個(gè)最重要的預(yù)編譯指令: /Yu, /Yc,/Yx,/Fp。其它的詳細(xì)資料可以參考: MSDN -> Visual Studio 6.0 Document -> Visual C++ 6.0 Document -> VC++ Programmer Guider - >Compiler and Linker -> Details -> Creating Precompiled Header files
               預(yù)編譯頭的概念:
               所謂的預(yù)編譯頭就是把一個(gè)工程中的那一部分代碼,預(yù)先編譯好放在一個(gè)文件里(通常是以.pch為擴(kuò)展名的),這個(gè)文件就稱為預(yù)編譯頭文件這些預(yù)先編譯好的代碼可以是任何的C/C++代碼,甚至是inline的函數(shù),但是必須是穩(wěn)定的,在工程開發(fā)的過程中不會(huì)被經(jīng)常改變。如果這些代碼被修改,則需要重新編譯生成預(yù)編譯頭文件。注意生成預(yù)編譯頭文件是很耗時(shí)間的。同時(shí)你得注意預(yù)編譯頭文件通常很大,通常有6- 7M大。注意及時(shí)清理那些沒有用的預(yù)編譯頭文件。
               也許你會(huì)問:現(xiàn)在的編譯器都有Time stamp的功能,編譯器在編譯整個(gè)工程的時(shí)候,它只會(huì)編譯那些經(jīng)過修改的文件,而不會(huì)去編譯那些從上次編譯過,到現(xiàn)在沒有被修改過的文件。那么為什么還要預(yù)編譯頭文件呢?答案在這里,我們知道編譯器是以文件為單位編譯的,一個(gè)文件經(jīng)過修改后,會(huì)重新編譯整個(gè)文件,當(dāng)然在這個(gè)文件里包含的所有頭文件中的東西(.eg Macro, Preprocessor )都要重新處理一遍。 VC的預(yù)編譯頭文件保存的正是這部分信息。以避免每次都要重新處理這些頭文件。
               根據(jù)上文介紹,預(yù)編譯頭文件的作用當(dāng)然就是提高便宜速度了,有了它你沒有必要每次都編譯那些不需要經(jīng)常改變的代碼。編譯性能當(dāng)然就提高了。
               要使用預(yù)編譯頭,我們必須指定一個(gè)頭文件,這個(gè)頭文件包含我們不會(huì)經(jīng)常改變的代碼和其他的頭文件,然后我們用這個(gè)頭文件來生成一個(gè)預(yù)編譯頭文件(.pch文件)想必大家都知道 StdAfx.h這個(gè)文件。很多人都認(rèn)為這是VC提供的一個(gè)“系統(tǒng)級(jí)別”的,編譯器帶的一個(gè)頭文件。其實(shí)不是的,這個(gè)文件可以是任何名字的。我們來考察一個(gè)典型的由AppWizard生成的MFC Dialog Based 程序的預(yù)編譯頭文件。(因?yàn)锳ppWizard會(huì)為我們指定好如何使用預(yù)編譯頭文件,默認(rèn)的是StdAfx.h,這是VC起的名字)。我們會(huì)發(fā)現(xiàn)這個(gè)頭文件里包含了以下的頭文件:
            #include <afxwin.h> // MFC core and standard components
            #include <afxext.h> // MFC extensions
            #include <afxdisp.h> // MFC Automation classes
            #include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls
            #include <afxcmn.h>
               這些正是使用MFC的必須包含的頭文件,當(dāng)然我們不太可能在我們的工程中修改這些頭文件的,所以說他們是穩(wěn)定的。
               那么我們?nèi)绾沃付ㄋ鼇砩深A(yù)編譯頭文件。我們知道一個(gè)頭文件是不能編譯的。所以我們還需要一個(gè)cpp文件來生成.pch 文件。這個(gè)文件默認(rèn)的就是StdAfx.cpp。在這個(gè)文件里只有一句代碼就是:#include“Stdafx.h”。原因是理所當(dāng)然的,我們僅僅是要它能夠編譯而已―――也就是說,要的只是它的.cpp的擴(kuò)展名。我們可以用/Yc編譯開關(guān)來指定StdAfx.cpp來生成一個(gè).pch文件,通過/Fp編譯開關(guān)來指定生成的pch文件的名字。打開project - >Setting->C/C++ 對(duì)話框。把Category指向Precompiled Header。在左邊的樹形視圖里選擇整個(gè)工程,Project Options(右下角的那個(gè)白的地方)可以看到 /Fp “debug/PCH.pch”,這就是指定生成的.pch文件的名字,默認(rèn)的通常是 <工程名>.pch。然后,在左邊的樹形視圖里選擇StdAfx.cpp,這時(shí)原來的Project Option變成了 Source File Option(原來是工程,現(xiàn)在是一個(gè)文件,當(dāng)然變了)。在這里我們可以看到 /Yc開關(guān),/Yc的作用就是指定這個(gè)文件來創(chuàng)建一個(gè)Pch文件。/Yc后面的文件名是那個(gè)包含了穩(wěn)定代碼的頭文件,一個(gè)工程里只能有一個(gè)文件的可以有YC開關(guān)。VC就根據(jù)這個(gè)選項(xiàng)把 StdAfx.cpp編譯成一個(gè)Obj文件和一個(gè)PCH文件。
            這樣,我們就設(shè)置好了預(yù)編譯頭文件。也就是說,我們可以使用預(yù)編譯頭功能了。以下是注意事項(xiàng):
               1)如果使用了/Yu,就是說使用了預(yù)編譯,我們?cè)诿總€(gè).cpp文件的最開頭,包含你指定產(chǎn)生pch文件的.h文件(默認(rèn)是stdafx.h)不然就會(huì)有問題。如果你沒有包含這個(gè)文件,就告訴你Unexpected file end.
               2)如果你把pch文件不小心丟了,根據(jù)以上的分析,你只要讓編譯器生成一個(gè)pch文件就可以了。也就是說把 stdafx.cpp(即指定/Yc的那個(gè)cpp文件)重新編譯一遍就可以了。
            posted @ 2011-02-10 10:12 IT菜鳥 閱讀(371) | 評(píng)論 (0)編輯 收藏

            僅列出標(biāo)題
            共7頁(yè): 1 2 3 4 5 6 7 
            亚洲国产精品无码久久一线| 九九热久久免费视频| 亚洲国产成人久久一区久久| 秋霞久久国产精品电影院| 69久久精品无码一区二区| 精品久久无码中文字幕| 久久99热只有频精品8| 久久精品国产亚洲AV电影 | 综合久久国产九一剧情麻豆| 亚洲欧美日韩精品久久亚洲区 | 亚洲国产精品久久久久久| 97久久久精品综合88久久| 久久亚洲国产欧洲精品一| 91亚洲国产成人久久精品网址| 久久精品国产亚洲麻豆| 国产综合免费精品久久久| 国内精品久久久久久久久| 香蕉久久夜色精品国产尤物| 久久亚洲精品国产精品婷婷| 亚洲av日韩精品久久久久久a| 国产午夜免费高清久久影院| 久久国产精品久久国产精品| 久久国产精品二国产精品| 漂亮人妻被中出中文字幕久久| 久久婷婷五月综合97色一本一本 | 久久久久人妻一区精品性色av| 久久99国产精品久久久| 久久91这里精品国产2020| 久久狠狠爱亚洲综合影院 | 亚洲一区中文字幕久久| 2020久久精品亚洲热综合一本| 热re99久久精品国99热| 精品久久久久久久中文字幕 | 久久久黄片| av无码久久久久久不卡网站| 精品免费久久久久国产一区| 国内高清久久久久久| 久久99亚洲综合精品首页| 久久天天躁狠狠躁夜夜96流白浆| 久久国产福利免费| 久久99精品国产麻豆宅宅|