C语言 结构体的浅拷贝和深拷贝

最新推荐文章于 2023-12-21 17:33:17 发布
最新推荐文章于 2023-12-21 17:33:17 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： C/C++ 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43001551/article/details/104856489
版权

1. 浅拷贝

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

struct STU
{
	char name[32];
	int age;
	char *address;
};


void struct_init(struct STU* stu)
{
	strcpy(stu->name, "zhangsan", strlen("zhangsan") + 1);
	stu->age = 12;
	stu->address = "beijing";
}

void struct_copy(struct STU *to, struct STU *from )
{
	*to = *from;
}

int main(void)
{ 
	struct STU stu1, stu2;
	memset(&stu1, 0x00, sizeof(struct STU));
	memset(&stu2, 0x00, sizeof(struct STU));
	struct_init(&stu1);

	printf("before copy\n");
	printf("stu1.name:%p\n", stu1.name);
	printf("&stu1.name:%p\n", &stu1.name);
	printf("stu2.name:%p\n", stu2.name);
	printf("&stu2.name:%p\n", &stu2.name);
	printf("stu1.address:%p\n", stu1.address);
	printf("&stu1.address:%p\n", &stu1.address);
	printf("stu2.address:%p\n", stu2.address);
	printf("&stu2.address:%p\n", &stu2.address);

	struct_copy(&stu2, &stu1);

	printf("\nafter copy\n");
	printf("stu1.name:%p\n", stu1.name);
	printf("&stu1.name:%p\n", &stu1.name);
	printf("stu2.name:%p\n", stu2.name);
	printf("&stu2.name:%p\n", &stu2.name);
	printf("stu1.address:%p\n", stu1.address);
	printf("&stu1.address:%p\n", &stu1.address);
	printf("stu2.address:%p\n", stu2.address);
	printf("&stu2.address:%p\n", &stu2.address);

	return 0;
}

运行结果：
在这里插入图片描述
结果分析：
如图，未加& 打印的是指针内部存放的值，即指针所指向空间的地址，加了& 打印的是指针的地址。

结构体stu1 和 stu2 被创建的时候，成员name 就有他自己的空间（32字节），也就是说他有自己的地址（&name），所以他们的地址不相同。当struct_copy 开始拷贝name 时，他将from->name 所指向的空间拷贝至to->name，类似于strcpy，所以stu1 和 stu2 他们的内容相同。另外由于name 为字符数组，且数组的第一个成员的地址 和 数组名的地址相同，所以name 和 &name 的地址相同。

再来看adress，当结构体被创建的时候，为每个结构体的指针address分配了空间（32位编译器为4字节），memset将指针所存储的地址初始化为0（如 第一个stu2.address的地址），struct_init 创建了一个常量区的变量“beijing”，并使stu1.address 指向这个变量，所以stu1.address有值，而stu2.address为0。struct_copy 将stu1.address指向的地址（005F7854）拷贝至stu2.address，所以他们打印的值相同。

由于结构体成员address 存放的是常量区的数据，所以就算stu1的空间被释放，stu2的address所指向的空间依旧存在。但是常量区的数据不可被修改，所以我们更多的使用malloc为指针成员分配内存，接下来我们看看malloc对结构体浅拷贝的影响。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>

struct STU
{
	char name[32];
	int age;
	char *address;
};


void struct_init(struct STU* stu)
{
	strcpy(stu->name, "zhangsan", strlen("zhangsan") + 1);
	stu->age = 12;
	stu->address = (char *)malloc(strlen("beijing") + 1);
	strcpy(stu->address, "beijing");
}

void struct_copy(struct STU *to, struct STU *from )
{
	*to = *from;
}

int main(void)
{ 
	struct STU stu1, stu2;
	memset(&stu1, 0x00, sizeof(struct STU));
	memset(&stu2, 0x00, sizeof(struct STU));
	struct_init(&stu1);

	printf("before copy\n");
	printf("stu1.name:%p\n", stu1.name);
	printf("&stu1.name:%p\n", &stu1.name);
	printf("stu2.name:%p\n", stu2.name);
	printf("&stu2.name:%p\n", &stu2.name);
	printf("stu1.address:%p\n", stu1.address);
	printf("&stu1.address:%p\n", &stu1.address);
	printf("stu2.address:%p\n", stu2.address);
	printf("&stu2.address:%p\n", &stu2.address);

	struct_copy(&stu2, &stu1);

	printf("\nafter copy\n");
	printf("stu1.name:%p\n", stu1.name);
	printf("&stu1.name:%p\n", &stu1.name);
	printf("stu2.name:%p\n", stu2.name);
	printf("&stu2.name:%p\n", &stu2.name);
	printf("stu1.address:%p\n", stu1.address);
	printf("&stu1.address:%p\n", &stu1.address);
	printf("stu2.address:%p\n", stu2.address);
	printf("&stu2.address:%p\n", &stu2.address);

	return 0;
}

与之前不同的是，这次我们没有为address指向常量区的空间，而是在堆区申请了一块空间，再用“beijing”进行填充。

运行结果：
在这里插入图片描述
从结果上来看，和第一个例子在相等关系上似乎没有什么区别。但是，这个程序存在一个巨大的bug，那就是我们malloc的内存没有手动释放，内存泄漏的危害不必多说。我们再来修改一下代码，添加free语句。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>

struct STU
{
	char name[32];
	int age;
	char *address;
};


void struct_init(struct STU* stu)
{
	strcpy(stu->name, "zhangsan", strlen("zhangsan") + 1);
	stu->age = 12;
	stu->address = (char *)malloc(strlen("beijing") + 1);
	strcpy(stu->address, "beijing");
}

void struct_copy(struct STU *to, struct STU *from )
{
	*to = *from;
}

int main(void)
{ 
	struct STU stu1, stu2;
	memset(&stu1, 0x00, sizeof(struct STU));
	memset(&stu2, 0x00, sizeof(struct STU));
	struct_init(&stu1);

	printf("before copy\n");
	printf("stu1.name:%p\n", stu1.name);
	printf("&stu1.name:%p\n", &stu1.name);
	printf("stu2.name:%p\n", stu2.name);
	printf("&stu2.name:%p\n", &stu2.name);
	printf("stu1.address:%p\n", stu1.address);
	printf("&stu1.address:%p\n", &stu1.address);
	printf("stu2.address:%p\n", stu2.address);
	printf("&stu2.address:%p\n", &stu2.address);

	struct_copy(&stu2, &stu1);

	printf("\nafter copy\n");
	printf("stu1.name:%p\n", stu1.name);
	printf("&stu1.name:%p\n", &stu1.name);
	printf("stu2.name:%p\n", stu2.name);
	printf("&stu2.name:%p\n", &stu2.name);
	printf("stu1.address:%p\n", stu1.address);
	printf("&stu1.address:%p\n", &stu1.address);
	printf("stu2.address:%p\n", stu2.address);
	printf("&stu2.address:%p\n", &stu2.address);

	if (stu1.address)
	{
		printf("\nbefore free\n");
		printf("stu1.address:%p\n", stu1.address);
		printf("&stu1.address:%p\n", &stu1.address);

		free(stu1.address);
		//stu1.address = NULL;

		printf("\nafter free\n");
		printf("stu1.address:%p\n", stu1.address);
		printf("&stu1.address:%p\n", &stu1.address);
	}

	if (stu2.address)
	{
		printf("\nbefore free\n");
		printf("stu2.address:%p\n", stu2.address);
		printf("&stu2.address:%p\n", &stu2.address);

		free(stu2.address);
		//stu2.address = NULL;

		printf("\nafter free\n");
		printf("stu2.address:%p\n", stu2.address);
		printf("&stu2.address:%p\n", &stu2.address);
	}

	return 0;
}

在这里插入图片描述
通过添加断点，我们发现在程序运行到 free(stu2.address); 时，就崩溃了。而且我们可以从打印信息中看出，stu1.address 的值在free前后虽然没有变化，但是这块地址所对应的空间确实被系统回收了，而当free(stu2.address)时，由于和stu1.address 指向的地址相同，所以stu2 free的就是属于系统的空间，所以程序会崩溃。

2. 深拷贝

那么，如果结构体中有这种变量的话，那应该怎么拷贝呢。我们再来看一段代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>

struct STU
{
	char name[32];
	int age;
	char *address;
};


void struct_init(struct STU* stu)
{
	strcpy(stu->name, "zhangsan", strlen("zhangsan") + 1);
	stu->age = 12;
	stu->address = (char *)malloc(strlen("beijing") + 1);
	strcpy(stu->address, "beijing");
}

void struct_copy(struct STU *to, struct STU *from )
{
	//*to = *from;
	memcpy(to, from, sizeof(struct STU));
	to->address = (char *)malloc(strlen(from->address) + 1);
	strcpy(to->address, from->address);
}

int main(void)
{ 
	struct STU stu1, stu2;
	memset(&stu1, 0x00, sizeof(struct STU));
	memset(&stu2, 0x00, sizeof(struct STU));
	struct_init(&stu1);

	printf("before copy\n");
	printf("stu1.name:%p\n", stu1.name);
	printf("&stu1.name:%p\n", &stu1.name);
	printf("stu2.name:%p\n", stu2.name);
	printf("&stu2.name:%p\n", &stu2.name);
	printf("stu1.address:%p\n", stu1.address);
	printf("&stu1.address:%p\n", &stu1.address);
	printf("stu2.address:%p\n", stu2.address);
	printf("&stu2.address:%p\n", &stu2.address);

	struct_copy(&stu2, &stu1);

	printf("\nafter copy\n");
	printf("stu1.name:%p\n", stu1.name);
	printf("&stu1.name:%p\n", &stu1.name);
	printf("stu2.name:%p\n", stu2.name);
	printf("&stu2.name:%p\n", &stu2.name);
	printf("stu1.address:%p\n", stu1.address);
	printf("&stu1.address:%p\n", &stu1.address);
	printf("stu2.address:%p\n", stu2.address);
	printf("&stu2.address:%p\n", &stu2.address);

	if (stu1.address)
	{
		printf("\nbefore free\n");
		printf("stu1.address:%p\n", stu1.address);
		printf("&stu1.address:%p\n", &stu1.address);

		free(stu1.address);
		//stu1.address = NULL;

		printf("\nafter free\n");
		printf("stu1.address:%p\n", stu1.address);
		printf("&stu1.address:%p\n", &stu1.address);
	}

	if (stu2.address)
	{
		printf("\nbefore free\n");
		printf("stu2.address:%p\n", stu2.address);
		printf("&stu2.address:%p\n", &stu2.address);

		free(stu2.address);
		//stu2.address = NULL;

		printf("\nafter free\n");
		printf("stu2.address:%p\n", stu2.address);
		printf("&stu2.address:%p\n", &stu2.address);
	}

	return 0;
}

我们修改了struct_copy函数，这次先将from的内容全部拷贝至to，再针对to->address 变量单独分配空间，并用from->address 将其初始化，这样看起来from跟to的内容一模一样了，也就完成了结构体的拷贝。

运行结果：
在这里插入图片描述
根据打印信息我们看出，这此stu2.address 的地址跟之前两次不同，不再和stu1.address 相同，说明两个指针指向的不再是同一块空间，针对不同的空间，我们将他们单独释放，程序也就不会出错了。

影子浅
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言结构体成员赋值的深拷贝和浅拷贝
yx5666的博客
09-30 934
使用C语言来说，深拷贝浅拷贝的概念我们不需要深究，在进行结构体拷贝的时候，结构体成员是非指针的话，那么直接赋值是没有任何问题的，建议使用这种方式，避免浅拷贝这类不易发现的错误产生。从中我们看到，改变Member2的值，Member1的值也改变了，这说明一片空间被两个不同的子对象共享了，改变一个对象的值另外一个也会随之改变。中的浅拷贝是指在拷贝过程中，对于指针型成员变量只拷贝指针本身，而不拷贝指针所指向的目标，它按字节复制的。我们分几种情况举例子来看一下。
C语言中结构体的深拷贝和浅拷贝
a_hang_szz的博客
03-15 4397
C语言中结构体的深拷贝和浅拷贝 一、结构体的浅拷贝 1.结构体的浅拷贝是把一个结构体的内容拷贝到另外一个结构体，仔细看代码就可以 #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #include &lt;windows.h&gt; typedef struct teacher { char *name; int age; }teacher...
浅谈C语言中结构体的浅拷贝和深拷贝
qq_39997903的博客
10-31 3860
1、C语言中结构体深浅拷贝问题的来源 如果一个结构体包含指针变量，并在使用结构的过程中进行了动态内存的分配，同时进行了相同类型的结构体的变量之间进行了相互赋值，此时会引发浅拷贝和深拷贝问题。 2、浅拷贝问题 #include <stdio.h> #include <stdlib.h> int main() { } ...
C语言：浅拷贝与深拷贝
edward_zcl的博客
01-04 3578
这里先简单讲一讲c中的浅拷贝与深拷贝，关于更深层使用的拷贝构造函数，深拷贝构造函数，浅拷贝构造函数等，以及其他语言的深拷贝这里就不赘述了。结构体跟类其实很类似，不管是使用或者作用域上。 浅拷贝：表层的引用，实际指向同一块内存 深拷贝：存放在不同的内存空间当中 typedef struct{ char name[20]; int age; }student; student st...
C语言深拷贝和浅拷贝问题
最新发布
weixin_40194697的博客
12-21 1017
所以这在释放内存时会出问题，会导致原来拷贝结构体指针指向的动态内存没有指针指向它，也基本就无法释放了，后面如果涉及动态内存申请和释放，程序会报错。这里结构体里面的指针是指向了动态分配内存。其实就算是指向任何一个变量或者数组，拷贝结构体时都是浅拷贝，即，拷贝结构体的指针本身（值）被拷贝，也就是其指向被拷贝结构体指针指向的值，而不指向原来指向的值，原来指向的值就和这个指针脱离了。有些地方用结构体赋值代替memcpy结构体，结果是一样的，但是，个人认为，赋值不叫拷贝，应该就叫赋值，否则浅拷贝情况太多了。
【C 语言】结构体 ( 结构体深拷贝 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
12-02 8929
一、结构体浅拷贝与深拷贝、 二、结构体深拷贝、 三、结构体深拷贝代码示例、
【C 语言】结构体 ( 结构体浅拷贝 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
12-02 1558
一、结构体浅拷贝与深拷贝、 二、结构体浅拷贝、 三、结构体浅拷贝代码示例、
结构体的浅拷贝与深拷贝
YLG_lin的博客
10-10 2219
浅拷贝：将结构体变量空间内容 赋值一份 到另一个相同类型的结构体变量空间中。所谓的深拷贝，就是为结构体的指针成员 分配独立空间 然后再内容拷贝。如果结构体中有指针成员 浅拷贝 会带来多次释放堆区空间的问题。相同类型的结构体变量可以整体赋值，默认赋值方式为：浅拷贝。如果结构体中没有指针成员 浅拷贝 不会带来问题。如果结构体中有指针成员 尽量使用深拷贝。结构体中指针成员指向堆区。
c语言——结构体赋值(深拷贝和浅拷贝)
e891377的专栏
05-18 6632
c语言——结构体赋值 结构体赋值1 struct Person { char name[64]; int age; }; void test01() { struct Person person1 = { "aaa", 20 }; struct Person person2 = { "bbb", 30 }; //赋值操作 person1 = person2; printf("Name:%s Age:%d\n",person1.name,person1.age); printf("N
C/C++ 浅拷贝和深拷贝的实例详解
01-01
C/C++ 浅拷贝和深拷贝的实例详解 深拷贝是指拷贝对象的具体内容，而内存地址是自主分配的，拷贝结束之后，两个对象虽然存的值是相同的，但是内存地址不一样，两个对象也互不影响，互不干涉。 浅拷贝就是对内存地址...
矩阵运算库自实现(c语言)
10-07
2. C语言结构体：在C语言中，我们可以使用结构体（struct）来定义自定义的数据类型，如矩阵结构。结构体允许我们将相关数据组合在一起，方便我们处理和存储矩阵。 二、自定义矩阵结构 ```c typedef struct { int ...
c代码-测试结构体赋值
07-14
C语言中没有内置的结构体复制操作，所以通常需要手动进行深拷贝，也就是逐个成员复制： ```c // 结构体复制 struct Student student3 = student1; // 浅拷贝，仅地址复制 memcpy(&student3, &student1, sizeof...
关于C语言----六：结构体
07-19
直接赋值或使用`memcpy`函数可以实现结构体的拷贝，但要注意浅拷贝和深拷贝的区别，避免数据错误。 总结，C语言中的结构体是数据组织和管理的重要工具，它提供了灵活的数据结构，可以构建各种复杂的程序设计模型。...
C语言 联合（union）
qq_43001551的博客
03-14 5787
1. 联合简介 联合（union）是一种数据类型，他能在同一块空间中存储不同数据类型，但不是同时存储。如果我们想设计一种结构，其能存储一些既无规律，也无顺序的数据，那么就可以用到联合。 创建联合和创建结构体相同，需要声明一个模板，再用这个模板创建变量，下面给出例子： union STU { int num; char sex; double score; char name[32]; };...
C语言 被调函数修改指针形参
qq_43001551的博客
03-20 3667
我们都知道，如果想在函数中修改实参的值，那么，你传递给函数的应该是这个值的地址。如果你想修改的是个指针，那么是传递指针的地址（二级指针），还是传递该指针呢？ 1. C语言中的函数调用 讲之前，先弄清楚一些概念：主调函数，被调函数，实参，形参。 void fun(int p) // p 是形参，是在fun()内使用的形式参数 { p = 12； } void fun2(int *parra...
C语言 static和extern的区别和使用
qq_43001551的博客
03-08 634
再读C Primer Plus，发现里面很多东西是第一次看的时候没有特别注意的，现将他们记录下来，所谓“温故知新”，就是这个道理。 1. 对象和标识符 C语言提供了多种不同的模型在内存中存储数据，而这些模型就叫做存储类别。如（int， char， int *， struct …），个人更愿意把这种存储类别形象的比喻为做蛋糕的“模具”，只要使用这个“模具”，就能在内存中“扣”出一块内存，而这个内...
C语言 standard C I/O函数
qq_43001551的博客
03-22 525
针对标准C的部分I/O函数做个记录，以下函数头文件均为：stdio.h 字符I/O int fgetc( FILE *stream ); int getc( FILE *stream ); int getchar( void ); fgetc和getc的参数是需要操作的流，前提是这个流之前已经被打开，而getchar始终从标准输入流（stdin）读取。每个函数从流中读取下一字符，并把它作为函...
内核链表 list.h
qq_43001551的博客
10-19 203
记录一下整理的关于内核链表相关函数内容 一、双指针双向循环链表（list） 1. 基本原理 struct list_head { struct list_head* pPre; struct list_head* pNext; }; typedef struct _STU { char cSex; char szAddress[128]; int iNumber; int iFlag; struct list_head mylist; }STU;
c语言 结构体 深拷贝
09-15
结构体的深拷贝是指拷贝结构体对象时，不仅拷贝结构体成员的值，还要重新分配内存并拷贝指针成员指向的数据。实现结构体的深拷贝可以按照以下步骤进行操作： 1. 首先，进行结构体的浅拷贝，使用memcpy函数将源结构体的内容拷贝到目标结构体中，保证基本类型成员的值相同。 2. 然后，对于指针类型的成员，需要重新为目标结构体的指针成员分配内存空间。可以使用malloc函数为目标结构体的指针成员分配足够的内存空间。 3. 最后，将源结构体的指针成员指向的数据拷贝到目标结构体的指针成员指向的内存空间中。可以使用strcpy函数将源结构体的指针成员的数据拷贝到目标结构体的指针成员中。 下面是一个示例代码，用于演示结构体的深拷贝： ```c typedef struct { int id; char* name; } Student; void copy_student(Student* to, Student* from) { memcpy(to, from, sizeof(Student)); to->name = (char*)malloc(strlen(from->name) + 1); strcpy(to->name, from->name); } ``` 以上代码中，copy_student函数实现了结构体的深拷贝操作。首先使用memcpy函数进行结构体的浅拷贝，然后重新为name指针成员分配内存空间，并使用strcpy函数将源结构体的name数据拷贝到目标结构体的name中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值