Warning: file_get_contents(/data/phpspider/zhask/data//catemap/4/c/72.json): failed to open stream: No such file or directory in /data/phpspider/zhask/libs/function.php on line 167

Warning: Invalid argument supplied for foreach() in /data/phpspider/zhask/libs/tag.function.php on line 1116

Notice: Undefined index: in /data/phpspider/zhask/libs/function.php on line 180

Warning: array_chunk() expects parameter 1 to be array, null given in /data/phpspider/zhask/libs/function.php on line 181
通过设置取消引用的指针将对象从堆栈复制到堆是一种好的做法吗? 请考虑此示例程序: #include <stdio.h> #include <stdlib.h> typedef struct { int a; int b; } X; int main(void) { X* p = malloc(sizeof(X)); // Heap allocation X z = {.a = 2, .b = 3}; // Stack allocation *p = z; // Copying from the stack onto the heap printf("\n%d\n", p->b); return 0; } #包括 #包括 类型定义结构{ INTA; int b; }X; 内部主(空){ X*p=malloc(sizeof(X));//堆分配 xz={.a=2,.b=3};//堆栈分配 *p=z;//从堆栈复制到堆 printf(“\n%d\n”,p->b); 返回0; }_C_Stack_Heap Memory - Fatal编程技术网 b); 返回0; },c,stack,heap-memory,C,Stack,Heap Memory" /> b); 返回0; },c,stack,heap-memory,C,Stack,Heap Memory" />

通过设置取消引用的指针将对象从堆栈复制到堆是一种好的做法吗? 请考虑此示例程序: #include <stdio.h> #include <stdlib.h> typedef struct { int a; int b; } X; int main(void) { X* p = malloc(sizeof(X)); // Heap allocation X z = {.a = 2, .b = 3}; // Stack allocation *p = z; // Copying from the stack onto the heap printf("\n%d\n", p->b); return 0; } #包括 #包括 类型定义结构{ INTA; int b; }X; 内部主(空){ X*p=malloc(sizeof(X));//堆分配 xz={.a=2,.b=3};//堆栈分配 *p=z;//从堆栈复制到堆 printf(“\n%d\n”,p->b); 返回0; }

通过设置取消引用的指针将对象从堆栈复制到堆是一种好的做法吗? 请考虑此示例程序: #include <stdio.h> #include <stdlib.h> typedef struct { int a; int b; } X; int main(void) { X* p = malloc(sizeof(X)); // Heap allocation X z = {.a = 2, .b = 3}; // Stack allocation *p = z; // Copying from the stack onto the heap printf("\n%d\n", p->b); return 0; } #包括 #包括 类型定义结构{ INTA; int b; }X; 内部主(空){ X*p=malloc(sizeof(X));//堆分配 xz={.a=2,.b=3};//堆栈分配 *p=z;//从堆栈复制到堆 printf(“\n%d\n”,p->b); 返回0; },c,stack,heap-memory,C,Stack,Heap Memory,此程序正确打印3。我假设这意味着*p=z成功地将z的数据从堆栈复制到堆上 如果可以很容易地将东西从堆栈复制到堆中,那么为什么大多数人在尝试这样做时使用memcpy 在什么情况下memcpy合适,而在什么情况下上述解决方案合适?当您将一个数组的内容复制到另一个数组时(这些内容不构成字符串),您将使用memcpy,或者当您试图将一种类型的对象的内容映射到另一种类型的对象的字节时 例如,如果要将结构类型映射到一个无符号字符数组,您可以执行以下操作: X foo = {1, 2}; unsigned c

此程序正确打印
3
。我假设这意味着
*p=z
成功地将
z
的数据从堆栈复制到堆上

如果可以很容易地将东西从堆栈复制到堆中,那么为什么大多数人在尝试这样做时使用
memcpy


在什么情况下
memcpy
合适,而在什么情况下上述解决方案合适?

当您将一个数组的内容复制到另一个数组时(这些内容不构成字符串),您将使用
memcpy
,或者当您试图将一种类型的对象的内容映射到另一种类型的对象的字节时

例如,如果要将
结构
类型映射到一个
无符号字符数组
,您可以执行以下操作:

X foo = {1, 2};
unsigned char *bytes = malloc( sizeof foo );
unsigned char sbytes[sizeof foo];

memcpy( bytes, &foo, sizeof foo );
memcpy( sbytes, &foo, sizeof foo );
类似地,如果您试图将一个数组的内容复制到另一个数组,而这些内容并不构成字符串,那么您也应该使用memcpy:

int src[N];
int *dst = malloc( sizeof src );
int sdst[N];
...
memcpy( dst, src, sizeof src );
memcpy( sdst, src, sizeof src );
如果它们确实构成了一个字符串,则使用strcpy:

char blah[10];
strcpy( blah, "foo" );
否则,请使用赋值运算符,就像您在这里所做的那样

“通过设置取消引用的指针将对象从堆栈复制到堆是否是一种良好的做法?”

对<代码>*p=z很好。优于
memcpy()
:类型检查

在什么情况下
memcpy
合适,而在什么情况下上述解决方案合适

  • memcpy
    :复制数组时

  • memcpy
    :源/目标未对齐时(代码需要打包/解包数据)

  • 否则:使用简单的赋值


这是一个有效的代码。可以将结构的一个对象指定给sane结构的另一个对象。例如,当没有结构的对象或需要进行“深度”复制时,使用memcpy。赋值和
memcpy
之间的选择只是个别样式,没有明显的原因。但是如果它是数组而不是单个对象,您需要使用
memcpy
,因为您无法分配数组。@vladfrommovo
memcpy()
不会进行深度复制。它只复制顶级对象的字节。@VladFromMosco赋值和memcpy将以相同的方式复制指针
memcpy()
不会递归。这两个选项在计算上是相同的吗?我可以说,在嵌入式环境中,直接分配确实很少见(至少可以这么说)。@RobertoCaboni:我手头没有嵌入式系统。我刚刚设计了一个简单的测试,它使用
memcpy
和直接赋值来复制一个带有两个
int
成员的
struct
类型,并且
gcc
为这两个成员生成了相同的代码-它用直接赋值替换了
memcpy
调用(这很有意义,因为在本例中,两个操作数的类型相同).Hi John,谢谢你的帮助回答。两个问题:1.我很确定我知道这一点,但公平地说,
memcpy
strcpy
之间的唯一区别在于后者不需要指定的大小来复制,而是在遇到第一个空字节时终止。正确吗?2。“…将一种类型的对象的内容映射到另一种类型的对象的字节。。。"-有意思,你能举一个例子吗?我不清楚。谢谢你!@AvivCohn:1.对-
strcpy
用于在字符类型的数组之间复制字符串-这是
memcpy
的一个特例。2.看我的第一个例子,我将
foo
的字节映射到
无符号字符的数组上另一个示例是,您可以将
float
的字节复制到
long
-
strcpy(&long\u对象,&float\u对象,long\u对象的大小);
-这将在
long
对象中保留
float
对象的位模式(直接赋值会将值从
浮点
转换为
表示-即
3.0
=>
3
)只是出于好奇,关于将浮点的位模式复制为长示例,您能给出一个需要这样做的真实场景的示例吗?