• <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>

            山寨:不是最好的,是最適合我們的!歡迎體驗山寨 中文版MSDN

            Blog @ Blog

            當華美的葉片落盡,生命的脈絡才歷歷可見。 -- 聶魯達

            常用鏈接

            統計

            積分與排名

            BBS

            Blog

            Web

            最新評論

            [轉]C/C++中的結構體

            什么是結構體? 

              簡單的來說,結構體就是一個可以包含不同數據類型的一個結構,它是一種可以自己定義的數據類型,它的特點和數組主要有兩點不同,首先結構體可以在一個結構中聲明不同的數據類型,第二相同結構的結構體變量是可以相互賦值的,而數組是做不到的,因為數組是單一數據類型的數據集合,它本身不是數據類型(而結構體是),數組名稱是常量指針,所以不可以做為左值進行運算,所以數組之間就不能通過數組名稱相互復制了,即使數據類型和數組大小完全相同。 

              定義結構體使用struct修飾符,例如: 

            程序代碼 程序代碼
            struct test 

            float a; 
            int b; 
            }
              上面的代碼就定義了一個名為test的結構體,它的數據類型就是test,它包含兩個成員a和b,成員a的數據類型為浮點型,成員b的數據類型為整型。 

              由于結構體本身就是自定義的數據類型,定義結構體變量的方法和定義普通變量的方法一樣。

            程序代碼 程序代碼
            test pn1; 

              這樣就定義了一test結構體數據類型的結構體變量pn1,結構體成員的訪問通過點操作符進行,pn1.a=10 就對結構體變量pn1的成員a進行了賦值操作。 

              注意:結構體生命的時候本身不占用任何內存空間,只有當你用你定義的結構體類型定義結構體變量的時候計算機才會分配內存。 

              結構體,同樣是可以定義指針的,那么結構體指針就叫做結構指針。 

              結構指針通過->符號來訪問成員,下面我們就以上所說的看一個完整的例子:

            程序代碼 程序代碼
            #include <iostream>    
            #include 
            <string>    
            using namespace std;  
              
            struct test//定義一個名為test的結構體  
            {  
                
            int a;//定義結構體成員a  
                int b;//定義結構體成員b  
            }
            ;  
              
            void main()      
            {  
                test pn1;
            //定義結構體變量pn1  
                test pn2;//定義結構體變量pn2  
              
                pn2.a
            =10;//通過成員操作符.給結構體變量pn2中的成員a賦值  
                pn2.b=3;//通過成員操作符.給結構體變量pn2中的成員b賦值  
              
                pn1
            =pn2;//把pn2中所有的成員值復制給具有相同結構的結構體變量pn1  
                cout<<pn1.a<<"|"<<pn1.b<<endl;  
                cout
            <<pn2.a<<"|"<<pn2.b<<endl;  
              
                test 
            *point;//定義結構指針  
              
                point
            =&pn2;//指針指向結構體變量pn2的內存地址  
                cout<<pn2.a<<"|"<<pn2.b<<endl;  
                point
            ->a=99;//通過結構指針修改結構體變量pn2成員a的值  
                cout<<pn2.a<<"|"<<pn2.b<<endl;  
                cout
            <<point->a<<"|"<<point->b<<endl;  
                cin.
            get();  
            }

             
              總之,結構體可以描述數組不能夠清晰描述的結構,它具有數組所不具備的一些功能特性。

              下面我們來看一下,結構體變量是如何作為函數參數進行傳遞的。

            程序代碼 程序代碼
            #include <iostream>    
            #include 
            <string>    
            using namespace std;  
              
            struct test  
            {  
                
            char name[10];  
                
            float socre;  
            }
            ;  
              
            void print_score(test pn)//以結構變量進行傳遞  
            {  
                cout
            <<pn.name<<"|"<<pn.socre<<endl;  
            }
              
              
            void print_score(test *pn)//一結構指針作為形參  
            {  
                cout
            <<pn->name<<"|"<<pn->socre<<endl;  
            }
              
              
            void main()      
            {  
                test a[
            2]={{"marry",88.5},{"jarck",98.5}};  
                
            int num = sizeof(a)/sizeof(test);  
                
            for(int i=0;i<num;i++)  
                
            {  
                    print_score(a[i]);  
                }
              
                
            //for(int i=0;i<num;i++)  //error C2374: 'i' : redefinition; multiple initialization
                for(int j=0;j<num;j++)
                
            {  
                    
            //print_score(&a[i]); 
                    print_score(&a[j]);
                    
                }
              
                cin.
            get();  
            }

              void print_score(test *pn)的效率是要高過void print_score(test pn)的,因為直接內存操作避免了棧空間開辟結構變量空間需求,節省內存。

              下面我們再說一下,傳遞結構引用的例子。 

              利用引用傳遞的好處很多,它的效率和指針相差無幾,但引用的操作方式和值傳遞幾乎一樣,種種優勢都說明善用引用可以做到程序的易讀和易操作,它的優勢尤其在結構很大的時候,避免傳遞結構變量很大的值,節省內存,提高效率。

            程序代碼 程序代碼
            #include <iostream>    
            #include 
            <string>    
            using namespace std;  
              
            struct test  
            {  
                
            char name[10];  
                
            float socre;  
            }
            ;  
              
            void print_score(test &pn)//以結構變量進行傳遞  
            {  
                cout
            <<pn.name<<"|"<<pn.socre<<endl;  
            }
              
              
            void main()      
            {  
                test a[
            2]={{"marry",88.5},{"jarck",98.5}};  
                
            int num = sizeof(a)/sizeof(test);  
                
            for(int i=0;i<num;i++)  
                
            {  
                    print_score(a[i]);  
                }
              
                cin.
            get();  
            }
             


              上面我們說明了易用引用對結構體進行操作的優勢,下面我們重點對比兩個例程,進一部分析關于效率的問題。

            程序代碼 程序代碼
            //-------------------------------------例程1---------------------------------  
              
            #include 
            <iostream>    
            #include 
            <string>    
            using namespace std;  
              
            struct test  
            {  
                
            char name[10];  
                
            float socre;  
            }
            ;  
              
            void print_score(test &pn)  
            {  
                cout
            <<pn.name<<"|"<<pn.socre<<endl;  
            }
              
              
            test get_score()  
            {  
                test pn;  
                cin
            >>pn.name>>pn.socre;  
                
            return pn;  
            }
              
            void main()  
            {  
                test a[
            2];  
                
            int num = sizeof(a)/sizeof(test);  
                
            for(int i=0;i<num;i++)  
                
            {  
                    a[i]
            =get_score();  
                }
              
                cin.
            get();  
                
            for(int i=0;i<num;i++)  
                
            {  
                    print_score(a[i]);  
                }
              
                cin.
            get();  
            }
              
              
            //-------------------------------------例程2---------------------------------  
              
            #include 
            <iostream>    
            #include 
            <string>    
            using namespace std;  
              
            struct test  
            {  
                
            char name[10];  
                
            float socre;  
            }
            ;  
              
            void print_score(test &pn)  
            {  
                cout
            <<pn.name<<"|"<<pn.socre<<endl;  
            }
              
              
            void get_score(test &pn)  
            {  
                cin
            >>pn.name>>pn.socre;  
            }
              
            void main()  
            {  
                test a[
            2];  
                
            int num = sizeof(a)/sizeof(test);  
                
            for(int i=0;i<num;i++)  
                
            {  
                    get_score(a[i]);  
                }
              
                cin.
            get();  
                
            for(int i=0;i<num;i++)  
                
            {  
                    print_score(a[i]);  
                }
              
                cin.
            get();  
            }



              例程2的效率要遠高過例程1的原因主要有以下兩處: 


              第一: 

              例程1中的 

            程序代碼 程序代碼
            test get_score() 

            test pn; 
            cin
            >>pn.name>>pn.socre; 
            return pn; 
            }

             
              調用的時候在內部要在??臻g開辟一個名為pn的結構體變量,程序pn的時候又再次在棧內存空間內自動生成了一個臨時結構體變量temp,在前面的教程中我們已經說過,它是一個copy,而例程2中的: 
            程序代碼 程序代碼
            void get_score(test &pn) 

            cin
            >>pn.name>>pn.socre; 
            }
             

              卻沒有這一過程,不開辟任何新的內存空間,也沒有任何臨時變量的生成。 

              第二: 

              例程1在mian()中,必須對返回的結構體變量進行一次結構體變量與結構體變量直接的相互賦值操作。 
            程序代碼 程序代碼
            for(int i=0;i<num;i++

            a[i]
            =get_score(); 
            }
             

              而例程2中由于是通過內存地址直接操作,所以完全沒有這一過程,提高了效率。
            程序代碼 程序代碼
            for(int i=0;i<num;i++

            get_score(a[i]); 
            }
             

              函數也是可以返回結構體應用的,例子如下:

            程序代碼 程序代碼
            #include <iostream>    
            #include 
            <string>    
            using namespace std;  
              
            struct test  
            {  
                
            char name[10];  
                
            float socre;  
            }
            ;  
              
            test a;  
              
              
            test 
            &get_score(test &pn)  
            {  
                cin
            >>pn.name>>pn.socre;  
                
            return pn;  
            }
              
              
            void print_score(test &pn)    
            {    
                cout
            <<pn.name<<"|"<<pn.socre<<endl;    
            }
                
              
            void main()  
            {  
                test 
            &sp=get_score(a);  
                cin.
            get();  
                cout
            <<sp.name<<"|"<<sp.socre;  
                cin.
            get();   
            }
             

              調用get_score(a);結束并返回的時候,函數內部沒有臨時變量的產生,返回直接吧全局結構變量a的內存地址賦予結構引用sp 

              最后提一下指針的引用 

              定義指針的引用方法如下:

            程序代碼 程序代碼
            void main()  
            {  
            int a=0;  
            int b=10;  
            int *p1=&a;  
            int *p2=&b;  
            int *&pn=p1;  
            cout 
            <<pn<<"|"<<*pn<<endl;  
            pn
            =p2;  
            cout 
            <<pn<<"|"<<*pn<<endl;  
            cin.
            get();  
            }
              pn就是一個指向指針的引用,它也可以看做是指針別名,總之使用引用要特別注意它的特性,它的操作是和普通指針一樣的,在函數中對全局指針的引用操作要十分小心,避免破壞全局指針!

            posted on 2007-08-13 23:11 isabc 閱讀(340) 評論(0)  編輯 收藏 引用 所屬分類: C++基礎

            廣告信息(免費廣告聯系)

            中文版MSDN:
            歡迎體驗

            久久综合久久鬼色| 久久国产精品久久| 精品久久久无码人妻中文字幕| 青青青青久久精品国产h久久精品五福影院1421 | 国产99久久久国产精品小说| 狠狠色狠狠色综合久久| 久久精品a亚洲国产v高清不卡| 97精品伊人久久久大香线蕉| 一本久久a久久精品综合香蕉| 精品久久久久久国产潘金莲| 国产精品综合久久第一页| 久久久久亚洲AV无码观看| 日本免费久久久久久久网站| 亚洲国产另类久久久精品| 久久99精品久久久久久水蜜桃| 麻豆av久久av盛宴av| 国产精品99久久不卡| 久久99精品久久只有精品| 免费精品国产日韩热久久| 国产精品久久久久无码av| 国内精品久久国产| 国产亚洲美女精品久久久 | 久久66热人妻偷产精品9| 久久影院久久香蕉国产线看观看| 91久久婷婷国产综合精品青草| 久久久久久久亚洲精品| 99久久成人18免费网站| 婷婷综合久久狠狠色99h| 午夜精品久久久久久久| 久久精品免费全国观看国产| 色悠久久久久久久综合网| 久久国产精品一区二区| 99精品国产在热久久无毒不卡| 亚洲精品乱码久久久久久自慰| 香蕉久久永久视频| 一级做a爰片久久毛片看看 | 午夜不卡久久精品无码免费| 一本色道久久99一综合| 亚洲∧v久久久无码精品| 久久久久久久久久久| 中文无码久久精品|