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

             
              調用的時候在內部要在棧空間開辟一個名為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 閱讀(339) 評論(0)  編輯 收藏 引用 所屬分類: C++基礎

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

            中文版MSDN:
            歡迎體驗

            久久精品男人影院| 九九精品久久久久久噜噜| 四虎影视久久久免费观看| 久久精品成人免费看| 久久亚洲精品成人av无码网站| 精品国产青草久久久久福利| 蜜桃麻豆www久久国产精品| 99久久人人爽亚洲精品美女| 久久美女网站免费| 国产亚洲精午夜久久久久久 | 日产精品久久久一区二区| 一本久道久久综合狠狠躁AV| 国产69精品久久久久观看软件 | 久久w5ww成w人免费| 成人久久久观看免费毛片| 国内精品久久久久影院免费| 999久久久国产精品| 亚洲第一永久AV网站久久精品男人的天堂AV | 麻豆AV一区二区三区久久| 久久久久国产精品熟女影院| 97久久精品人妻人人搡人人玩| 久久香蕉国产线看观看乱码| 久久久久无码专区亚洲av| 久久99热这里只有精品66| 久久久国产精品亚洲一区| 91精品国产高清久久久久久国产嫩草| 国产激情久久久久影院| 久久亚洲精品国产精品婷婷| 久久国产精品一国产精品金尊| 大蕉久久伊人中文字幕| 久久人人爽人人爽人人片AV麻烦| 国产人久久人人人人爽| 久久综合狠狠综合久久97色| 久久午夜无码鲁丝片| 久久91这里精品国产2020| 亚洲中文字幕无码久久2017| 91麻豆精品国产91久久久久久| 久久国产劲爆AV内射—百度| 久久精品国产精品亜洲毛片| 国产精品视频久久久| 国内精品久久久久影院薰衣草 |