C语言之结构体

发表于 | 分类于 | |

结构体的定义和初始化

结构体是简单数据类型的综合

1
2
3
4
5
6
7
struct man
{
	char name[100];
	int age;
};
struct man m = { "tom", 12 };
struct man m = { .name = "tom", .age = 12 };

访问结构体成员

要访问结构体成员，要使用.操作符。

1
m.age;

结构体的内存对齐模式

结构在内存的大小是和结构成员最长的那个元素相关的
编译器在编译一个结构的时候采用内存对齐模式

1
2
3
4
5
struct man{
    char a;
    int b;
};
//sizeof(struct man) = 8

指定结构体元素的位字段

定义一个结构体的时候可以指定具体元素的位长

1
2
3
struct test{
	char a : 2;//指定元素为2位长，不是2个字节长
};

结构数组

1
2
struct man m[10] = { { "tom", 12 }, { "marry", 10 }, { "jack", 9 } };
m[1].name;

嵌套结构

一个结构的成员还可以是另一个结构类型

1
2
3
4
5
6
7
8
9
10
11
12
13
struct names{
	char first[100];
	char last[100];
};

struct man{
	struct names name;
	int age;
};

struct man m = { { "wang", "wu" }, 20 };

m.name.fist;//嵌套的使用

结构体的赋值

struct name a = b;
结构的赋值其实就是两个结构内存的拷贝

1
memcpy(&a, &b, sizeof(b));

如果结构体成员有指针元素，那么就不能直接赋值，原因是会指向同一块内存，使用free的话会造成没有实际指向

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct man
{
    int age;
    char *name;
};

int main()
{
    struct man m1;
    m1.age = 10;
    m1.name = malloc(10);
    strcpy(m1.name, "jack");
    struct man m2;
    m2.age = 12;
    m2.name = malloc(strlen(m1.name) + 1);
    strcpy(m2.name, m1.name);    
}

指向结构体的指针

1
2
3
4
struct man m;
struct man *p = &m;
(*p).age = 10;//为操作简单，加入了->操作符
p->age = 10;

结构中的数组成员和指针成员

一个结构中可以有数组成员，也可以有指针成员
如果是指针成员结构体成员在初始化和赋值的时候就需要提前为指针成员分配内存

1
2
3
4
5
struct man
{
	char name[100];
	int age;
};

1
2
3
4
5
struct man
{
	char *name;
	int age;
};

在堆中创建的结构体

如果结构体有指针类型成员，同时结构体在堆中创建，那么释放堆中的结构体之前需要提前释放结构体中的指针成员指向的内存

1
2
3
4
5
6
7
8
struct man
{
	char *name;
	int age;
};
	struct man *s = malloc(sizeof(struct man) * 2);
	s[0].name = malloc(10 * sizeof(char));
	s[1].name = malloc(10 * sizeof(char));

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
struct student
{
	int ID;
	char *name;
	int age;
};

int main()
{
    struct student *sp = malloc(sizeof(struct student) * 10);
	memset(sp, 0, sizeof(struct student) * 10);
	for (int i = 0; i < 10; i++)
	{
		sp[i].ID = i;
		sp[i].age = i;
		char buf[1024] = { 0 };
		scanf("%s", buf);
		int len = strlen(buf);//得到用户输入字符串的长度
		sp[i].name = malloc(len + 1);
		sprintf(sp[i].name, "%s", buf);
	}

	for (int i = 0; i < 10; i++)
	{
		printf("ID =%d, age = %d, name = %s\n", sp[i].ID, sp[i].age, sp[i].name);
	}

	for (int i = 0; i < 10; i++)
	{
		free(sp[i].name);
	}

	free(sp);
}

结构体作为函数参数

结构体作为函数参数，基本数据类型不会被改变，指针会被改变

1
2
3
4
5
6
7
func(struct student st)
{
    st.age = 10;//原数值不会改变
    strcpy(st.name, "zhang");//原数值会被改变
}

func(st)

结构指针作为函数参数，所有数据可改变

1
2
3
4
5
6
7
func(struct student *st)
{
    st->age = 10;//原数值不会改变
    strcpy(st->name, "zhang");//原数值会被改变
}

func(&st)

其根本原因是指向问题
如果一个结构体变量做为函数的参数，效率极低。同时老的C编译器都不支持传递结构变量，只支持传递结构指针

结构体指针做函数返回值

可以返回结构体，但一般不那么做，原因是结构体返回太大

1
2
3
4
5
6
struct str *getstr()
{
	struct str *s = malloc(sizeof(struct str));
	strcpy(s->buf, "hello world");
	return s;
}

Donate comment here