C primer plus学习笔记 —— 8、结构体

结构体

结构类似于一个超级数组，数组中每个元素类型都是相同的。而这个超级数组中的每个元素类型可以不同。

结构体声明

声明并未创建对象，也就是未给数据分配空间。只是描述了对象的结构布局。

struct book {            /* structure template: tag is book     */
    char title[MAXTITL];
    char author[MAXAUTL];
    float value;
};    
//创建变量
struct book lib;
1
2
3
4
5
6
7

上面是分开的形式，我们也可以使用简化方式创建变量

//上面创建的完整形式，也就是结构声明和定义组合完成
struct book {       
    char title[MAXTITL];
    char author[MAXAUTL];
    float value;
} lib;
1
2
3
4
5
6

初始化结构体

struct book lib = {
        "Garlic-Melon Bank",
        "Lucky's Savings and Loan",
        8543.94
    };
    //这种方式可以调换每个成员的顺序
struct book lib2 = {
		.value = 8543.94,
        .author = "Garlic-Melon Bank",
        .title = "Lucky's Savings and Loan"
    };
1
2
3
4
5
6
7
8
9
10
11

结构体赋值

数组不允许把一个数组赋值给另一个数组

int a[3] = { 1,4,5};
int b[3];
b = a; //这是不允许的
1
2
3

但是结构体可以

struct namect {
    char fname[NLEN];
    char lname[NLEN];
    int letters;
};

struct namect a = {"asndg", "ang", 4};
struct namect b = a; //这是允许的，是把a的每个成员的值都给b，并且其中的数组的值也可以完全拷贝过去。

1
2
3
4
5
6
7
8
9

深拷贝和浅拷贝

但是如果一个结构体包含指针变量，并在使用结构的过程中进行了动态内存的分配，同时进行了相同类型的结构体的变量之间进行了相互赋值，此时会引发浅拷贝和深拷贝问题。

浅拷贝

typedef struct Student
{
    char *name;
    int age;
}Student;
 
int main(int argc, char *argv[])
{
    Student std1;
    Student std2;
 
    //给结构体1赋值并打印
    std1.name = (char *)malloc(10);
    std1.age = 20;
    strcpy(std1.name, "lele");
 
    printf("std1--->name: %s, age: %d\n", std1.name, std1.age);
 
    //把std1直接赋值给std2，并打印std2的值
    std2 = std1;
    printf("std2--->name: %s, age: %d\n", std2.name, std2.age);
 
    //释放std1成员name所指向的内存空间
    printf("std1--->name addr: %p \n", std1.name);
    free(std1.name);        //可以成功释放空间
 
    //释放std2成员name所指向的内存空间
    printf("std2--->name addr: %p \n", std2.name);
    free(std2.name);        //由于指向的空间已经释放，所以不能重复释放
 
    return 0;
}
// std1--->name: lele, age: 20
// std2--->name: lele, age: 20
// std1--->name addr: 0x7f82b6f05b10 
// std2--->name addr: 0x7f82b6f05b10 
// a.out(46264,0x1108e2600) malloc: *** error for object 0x7f82b6f05b10: pointer being freed was not allocated
// a.out(46264,0x1108e2600) malloc: *** set a breakpoint in malloc_error_break to debug
// Abort trap: 6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

这里出现问题是因为std1给std2赋值的时候，因为结构体中存在指针，赋值只把结构体中指针指向的地址给拷贝过去了，所以当我们释放结构体std2时，因为std1里的char*已经释放了，但是我们又释放了这个地址，所以重复释放报错。

深拷贝

注意到上面出现的问题，我们很好想到解决方法，就是注意赋值时struct中成员变量的指针，我们重新分配一块内存，并把内容拷贝过来，所以这就是深拷贝。

typedef struct Student
{
    char *name;
    int age;
}Student;
 
int main(int argc, char *argv[])
{
    Student std1;
    Student std2;
 
    std1.name = (char *)malloc(10);
    std1.age = 20;
 
    strcpy(std1.name, "lele");
 
    printf("std1--->name: %s, age: %d\n", std1.name, std1.age);
 
    //把std1直接赋值给std2，并打印std2的值
    std2 = std1;
    //为name成员重新分配一段空间，并把内容拷贝过来
    std2.name = (char *)malloc(10);        
    strcpy(std2.name, std1.name);
    printf("std2--->name: %s, age: %d\n", std2.name, std2.age);
 
    //释放std1成员name所指向的内存空间
    free(std1.name);        //可以成功释放空间
 
    //释放std2成员name所指向的内存空间
    free(std2.name);        //由于指向的不是同一段空间，可以成功释放
 
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

C Primer Plus学习笔记

docx 5星 超过95%的资源 1.10MB

下载

结构体作为返回值

struct namect {
    char fname[NLEN];
    char lname[NLEN];
    int letters;
};

struct namect getinfo(void);

int main(void)
{
    struct namect person;
    
    person = getinfo();
}

struct namect getinfo(void)
{
    struct namect temp;
    printf("Please enter your first name.\n");
    s_gets(temp.fname, NLEN);
    printf("Please enter your last name.\n");
    s_gets(temp.lname, NLEN);
    
    return temp;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

我们可以在函数内部创建一个结构体，然后作为返回值返回，并赋值给另一个结构体。

结构体数组

struct book {                     /* set up book template     */
    char title[MAXTITL];
    char author[MAXAUTL];
    float value;
};
int main(void)
{
    struct book library[MAXBKS]; /* array of book structures */
    int count = 0;
    int index;
	library[count].title[0];//
}
1
2
3
4
5
6
7
8
9
10
11
12

嵌套struct

struct names {                     // first structure
    char first[LEN];
    char last[LEN];
};

struct guy {                       // second structure
    struct names handle;           // nested structure
    char favfood[LEN];
    char job[LEN];
    float income;
};

int main(void)
{
    struct guy fellow = {   // initialize a variable
        { "Ewen", "Villard" }, 
        "grilled salmon",
        "personality coach",
        68112.00
    };
    printf("Dear %s, \n\n", fellow.handle.first);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

结构和指针

注意结构体还 不是数组，所以他的变量名和数组不一样，并不表示首元素地址。而是单独一个类型，所以使用结构体指针要注意。

struct guy {
    char favfood[LEN];
    char job[LEN];
    float income;
};

int main(void)
{
    struct guy *him = {
            "grilled salmon",
            "personality coach",
            68112.00
    };
    him->income = 53.4;


    struct guy him2 = {
            "grilled salmon",
            "personality coach",
            68112.00
    };
    him2.income = 433.5;
    struct guy *him3 = &him2;
    him3->income = 43.5;
   
   	// 使用malloc给某个结构体分配内存
	struct guy *stu
	    = (struct guy *)malloc(sizeof(struct guy));

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

注意结构体一般比较大，所以对于大的结构体一般不采用在栈上分配内存，空间可能不够，而在堆上分配内存。

传递结构地址进入函数

c primer plus练习答案PDF版

application/pdf 5星 超过95%的资源 327KB

下载

传递结构

struct funds {
    char   bank[FUNDLEN];
    double bankfund;
    char   save[FUNDLEN];
    double savefund;
};

double sum(struct funds moolah)
{
    return(moolah.bankfund + moolah.savefund);
}
double sum2(const struct funds * money)
{
    return(money->bankfund + money->savefund);
}

int main(void)
{
    struct funds stan = {
        "Garlic-Melon Bank",
        4032.27,
        "Lucky's Savings and Loan",
        8543.94
    };
    sum(stan); //传递结构
    sum2(&stan) //传递结构的地址
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

因为sum函数接收一个结构体指针，但是用const修饰表示不能修改指针指向值的内容。
传递结构和传递结构地址进入函数顾名思义，就是传递结构的时候实际上传递的是结构的副本，程序使用和修改的都是副本。
而传递结构地址则使用的是原来的结构。

结构和结构指针选择

传递结构：优点，操作的是副本对原数据进行保护，缺点是传递结构浪费时间和存储空间。所以小型结构可以使用直接传结构。
传递地址：优点：操作快，且不需要占用额外空间。缺点：会误操作而修改原结构变量。所以对于大型结构使用地址传递，当然如果想防止误操作可以加const修饰。

结构体中的指针

我们将结构体中的字符数组改成字符指针

struct funds1 {
    char   bank[20];
    char   save[20];
    }
struct funds2 {
    char   *bank;
    char   *save;
    }
1
2
3
4
5
6
7
8

对于funds1，结构体在创建对象的时候要分配40字节，
而对于funds2只需要16字节，因为每个指针占8字节。funds2不用为字符串分配空间，因为他存储的是地址，而字符串实际占用的空间是存储在别处的。所以这点在使用的时候就要注意。
看如下程序，就是malloc内存来存储字符串，然后用字符指针来指向这块内存。

struct namect {
    char * fname;  // using pointers
    char * lname;
    int letters;
};

void getinfo(struct namect *);        // allocates memory

int main(void)
{
    struct namect person;
    
    getinfo(&person);
}

void getinfo (struct namect * pst)
{
    char temp[SLEN];
    printf("Please enter your first name.\n");
    s_gets(temp, SLEN);
    // allocate memory to hold name
    pst->fname = (char *) malloc(strlen(temp) + 1);
    // copy name to allocated memory
    strcpy(pst->fname, temp);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

把结构写入文件

/* booksave.c -- saves structure contents in a file */
#include 
#include 
#include 
#define MAXTITL  40
#define MAXAUTL  40
#define MAXBKS   10             /* maximum number of books */
#define BOOKNAME "book.txt"
char * s_gets(char * st, int n);
struct book {                   /* set up book template    */
    char title[MAXTITL];
    char author[MAXAUTL];
    float value;
};

int main(void)
{
    struct book library[MAXBKS]; /* array of structures     */
    int count = 0; //记录输入的结构体数量
    int index, filecount; //filecount记录第几个结构体
    FILE * pbooks;
    int size = sizeof (struct book);
    
    //新建一个文件
    if ((pbooks = fopen(BOOKNAME, "a+b")) == NULL)
    {
        fputs("Can't open book.dat file\n",stderr);
        exit(1);
    }
    
    rewind(pbooks);            /* go to start of file     */
    //读文件内容
    while (count < MAXBKS &&  fread(&library[count], size,
                                    1, pbooks) == 1)
    {
        if (count == 0)
            puts("Current contents of book:");
        printf("%s by %s: $%.2f\n",library[count].title,
               library[count].author, library[count].value);
        count++;
    }
    filecount = count;
    if (count == MAXBKS)
    {
        fputs("The book.dat file is full.", stderr);
        exit(2);
    }
    
    puts("Please add new book titles.");
    puts("Press double [enter] to stop.");
    while (count < MAXBKS && s_gets(library[count].title, MAXTITL) != NULL
           && library[count].title[0] != '\0')
    {
        puts("Now enter the author.");
        s_gets(library[count].author, MAXAUTL);
        puts("Now enter the value.");
        scanf("%f", &library[count++].value);
        while (getchar() != '\n')
            continue;                /* clear input line  */
        if (count < MAXBKS)
            puts("Enter the next title.");
    }
    
    if (count > 0)
    {
        puts("Here is the list of your books:");
        for (index = 0; index < count; index++)
            printf("%s by %s: $%.2f\n",library[index].title,
                   library[index].author, library[index].value);
        //将结构体写入文件：定位到结构变量开始的位置，并把结构中所有字节都写入到文件
        //数据被分为count-file块，每块大小是一个结构体，写入到文件中 
        fwrite(&library[filecount], size, count - filecount,
               pbooks);
    }
    else
    	puts("No books? Too bad.\n");
    
    puts("Bye.\n");
    fclose(pbooks);
    
    return 0;
}

char * s_gets(char * st, int n)
{
    char * ret_val;
    char * find;
    
    ret_val = fgets(st, n, stdin);
    if (ret_val)
    {
        find = strchr(st, '\n');   // look for newline
        if (find)                  // if the address is not NULL,
            *find = '\0';          // place a null character there
        else
            while (getchar() != '\n')
                continue;          // dispose of rest of line
    }
    return ret_val;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101