1.传递结构成员

  1. #include<stdio.h> 
  2. #define FUNDLEN 50 
  3.  
  4. struct funds{ 
  5.        char bank[FUNDLEN]; 
  6.        double bankfund; 
  7.        char save[FUNDLEN]; 
  8.        double savefund; 
  9. }; 
  10. double sum(double x,double y);//sum不关心也不知道实际参数是结构的成员,如果希望改变原始值,可以传递成员地址  
  11.  
  12. int main(void){ 
  13.     struct funds stan={ 
  14.            "Garlic Bank"
  15.            3024.72, 
  16.            "Lucy's Saving"
  17.            9237.11 
  18.     }; 
  19.     printf("%.2f\n",sum(stan.bankfund,stan.savefund)); 
  20.     getchar(); 
  21.     return 0; 
  22. double sum(double x,double y){ 
  23.        return x+y; 
  24. }  

2.使用结构地址

 

  1. #include<stdio.h> 
  2. #define FUNDLEN 50 
  3.  
  4. struct funds{ 
  5.        char bank[FUNDLEN]; 
  6.        double bankfund; 
  7.        char save[FUNDLEN]; 
  8.        double savefund; 
  9. }; 
  10. double sum(const struct funds *);//没有改变指向的内容,使用const保护结构内容  
  11.  
  12. int main(void) { 
  13.     struct funds stan = { 
  14.            "Carlic"
  15.            3024.72, 
  16.            "Luck's Saving!"
  17.            9237.11 
  18.     }; 
  19.     printf("%.2f\n",sum(&stan)); 
  20.      
  21.     getchar(); 
  22.     return 0; 
  23. double sum(const struct funds * money){ 
  24.        return money->bankfund + money->savefund; 

3.把结构作为参数传递

 

  1. #include<stdio.h> 
  2. #define FUNDLEN 50 
  3.  
  4. struct funds{ 
  5.        char bank[FUNDLEN]; 
  6.        double bankfund; 
  7.        char save[FUNDLEN]; 
  8.        double savefund; 
  9. }; 
  10. double sum(struct funds);//产生了一个副本,使用原结构的副本完成操作!  
  11.  
  12. int main(void) { 
  13.     struct funds stan = { 
  14.            "Carlic"
  15.            3024.72, 
  16.            "Luck's Saving!"
  17.            9237.11 
  18.     }; 
  19.     printf("%.2f\n",sum(stan)); 
  20.      
  21.     getchar(); 
  22.     return 0; 
  23. double sum(struct funds money){ 
  24.        return money.bankfund + money.savefund;//运算符更改了变成了点运算符  

4.结构的其他特性

允许把一个结构赋值给另一个结构,初始化也可以

 

  1. struct funds stan = { 
  2.            "Carlic"
  3.            3024.72, 
  4.            "Luck's Saving!"
  5.            9237.11 
  6.     }; 
  7.     struct funds bob = stan;//允许把结构赋给另一个结构进行初始化和赋值!  

允许把结构作为返回值返回

a.使用指向结构的指针

  1. #include<stdio.h> 
  2. #include<string.h> 
  3. #define LEN 20 
  4.  
  5. void getInfo(struct namect *pst); 
  6. void makeInfo(struct namect *pst); 
  7. void showInfo(const struct namect *pst);//使用const,因为它不改变数值  
  8.  
  9. struct namect{ 
  10.        char firstName[LEN]; 
  11.        char lastName[LEN]; 
  12.        int count; 
  13. }; 
  14.  
  15. int main(void){ 
  16.     struct namect person;//所有操作都在这一个结构上进行  
  17.     getInfo(&person); 
  18.     makeInfo(&person); 
  19.     showInfo(&person); 
  20.      
  21.     getchar(); 
  22.     return 0; 
  23. }  
  24. void getInfo(struct namect *pst){ 
  25.      printf("Enter your first name:\n"); 
  26.      scanf("%s",pst->firstName);//此处也可以使用gets  
  27.      printf("Enter your last name:\n"); 
  28.      scanf("%s",pst->lastName); 
  29.      while(getchar() != '\n'
  30.           continue
  31. void makeInfo(struct namect *pst){ 
  32.      pst->count = (strlen(pst->firstName)+strlen(pst->lastName)); 
  33. void showInfo(const struct namect *pst){ 
  34.      printf("%s %s ,your name contains %d letters.\n",pst->firstName,pst->lastName,pst->count); 

b.使用结构

 

  1. #include<stdio.h>  
  2. #include<string.h>  
  3. #define LEN 20  
  4.   
  5. struct namect getInfo(void);  
  6. struct namect makeInfo(struct namect);  
  7. void showInfo(struct namect);   
  8.   
  9. struct namect{  
  10.        char firstName[LEN];  
  11.        char lastName[LEN];  
  12.        int count;  
  13. };  
  14.   
  15. int main(void){  
  16.     struct namect person;//三个函数每一个都创建了自己的person副本,共使用了四个不同结构  
  17.      
  18.     person = getInfo();  
  19.     person = makeInfo(person);  
  20.     showInfo(person);  
  21.       
  22.     getchar();  
  23.     return 0;  
  24. }   
  25. struct namect getInfo(void){//返回机制帮助我们很好的弥补了多副本情况  
  26.     struct namect temp; 
  27.     printf("Enter your firstName:\n"); 
  28.     gets(temp.firstName); 
  29.     printf("Enter your lastName:\n"); 
  30.     gets(temp.lastName); 
  31.     return temp; 
  32. }  
  33. struct namect makeInfo(struct namect info){  
  34.      info.count = strlen(info.firstName) + strlen(info.lastName); 
  35.      return info; 
  36. }  
  37. void showInfo(struct namect info){  
  38.      printf("%s %s ,your name contains %d letters.\n",info.firstName,info.lastName,info.count);  
  39. }  

5.结构还是指向结构的指针?

指针的优点:早期编译器也可以实现;只需传递单一地址

指针的缺点:缺少数据保护,使用const来解决

结构的优点:处理原始数据的副本,更安全

结构的缺点:不支持早期编译器,浪费空间时间

6.在结构中使用字符数组还是字符指针

结论是请使用字符数组而不是字符指针,原因如下

 

  1. #define LEN 20 
  2. struct names{//该结构分配了40字节  
  3.        char firstName[LEN]; 
  4.        char lastName[LEN]; 
  5. }; 
  6. struct pnames{//该结构只分配了8字节用来存放两个地址  
  7.        char *first; 
  8.        char *last; 
  9. }; 
  10. struct names veep = {"Talia","Summers"};//字符串就存储在结构内部  
  11. struct pnames treas = {"Brad","Fallingjaw"};//应该管理那些已经分配好空间的字符串,被分配在字符串存储区,正确的!  
  12.  
  13. struct pnames attorney; 
  14. scanf("%s",attorney.first);//危险!字符串被放在了last指针指向的位置,可以是任何位置,会出错的!  

7.结构、指针和malloc 

上例中使用字符数组虽然安全,但是浪费空间,需要预先指定字符串的大小。我们可以结合使用malloc来应用字符串指针。

 

  1. #include<stdio.h> 
  2. #include<string.h> 
  3. #include<stdlib.h> 
  4.  
  5. struct namect{ 
  6.        char *fname; 
  7.        char *lname; 
  8.        int count; 
  9. }; 
  10. void getInfo(struct namect *); 
  11. void makeInfo(struct namect *); 
  12. void showInfo(const struct namect *); 
  13. void cleanup(struct namect *); 
  14.  
  15. int main(void){ 
  16.     struct namect person; 
  17.     getInfo(&person); 
  18.     makeInfo(&person); 
  19.     showInfo(&person); 
  20.     cleanup(&person); 
  21.      
  22.     getchar(); 
  23.     return 0; 
  24. void getInfo(struct namect *pst){//两个字符串的都不是保存在结构中,而是保存在了malloc管理的内存块中  
  25.     char temp[81];//临时数组  
  26.     printf("Enter your first name:\n"); 
  27.     gets(temp); 
  28.     pst->fname = (char *)malloc(strlen(temp) + 1);//strlen求出来的已经是字节数了!!别忘了结束符! 
  29.     strcpy(pst->fname,temp);//字符串复制到新分配的空间中去  
  30.     printf("Enter your last name:\n"); 
  31.     gets(temp); 
  32.     pst->lname = (char *)malloc(strlen(temp) + 1); 
  33.     strcpy(pst->lname,temp);  
  34. void makeInfo(struct namect *pst){ 
  35.      pst->count = strlen(pst->fname) + strlen(pst->lname); 
  36. void showInfo(const struct namect *pst){ 
  37.      printf("%s %s,your name contains %d letters.\n"
  38.      pst->fname,pst->lname,pst->count); 
  39. void cleanup(struct namect *pst){//一定要记得free,否则容易产生内存泄露  
  40.      free(pst->fname); 
  41.      free(pst->lname); 

8.使用结构数组的函数

 

  1. #include<stdio.h> 
  2. #define FUNDLEN 40 
  3. #define N 2 
  4.  
  5. struct funds{ 
  6.        char bank[FUNDLEN]; 
  7.        double bankfund; 
  8.        char save[FUNDLEN]; 
  9.        double savefund; 
  10. }; 
  11. double sum(const struct funds money[],int n);//传递数组进去,并传递数组的大小 
  12. int main(void){ 
  13.     struct funds jones[N] = { 
  14.            { 
  15.                  "Garlic"
  16.                  3024.72, 
  17.                  "Lucky's saving"
  18.                  9237.11 
  19.            }, 
  20.            { 
  21.                  "Honest"
  22.                  3534.28, 
  23.                  "Party"
  24.                  3203.89 
  25.            } 
  26.     }; 
  27.     printf("%.2f\n",sum(jones,N));//sum(&jones[0],N)因为二者都指向同一个地址  
  28.     getchar(); 
  29.     return 0; 
  30. double sum(const struct funds money[],int n){ 
  31.        double total = 0.00; 
  32.        int i; 
  33.         
  34.        for(i=0;i<n;i++){ 
  35.            total += money[i].bankfund + money[i].savefund; 
  36.        } 
  37.        return total; 
  38. }