标签: memcpy

我有一段C代码,我正在尝试优化,其中包括设置数组a到b.我目前正在使用memcpy来实现这一点,并且它可以工作,但它不够快.即

double a[4] = {1.0, 2.0, 3.0, 4.0};
double b[4];
memcpy(b, a, sizeof(a));

这是一个基本的例子,我的程序类似,但使用多达9000双打.我知道使用指针可以节省很多时间,但我不知道该怎么做.非常感谢您的帮助.

编辑:我不需要保留一个可以丢弃的数组.我只需要从a转移到b.

我反思memcpy.

我知道memcpy用于将变量复制到变量.

但是使用它并不是更好:( 例如)

int a = 5;
int b;

b = a;

而不是memcpy？

或使用std::move替代memmove？

1. Memcpy并且Memmove没有过时/缓慢的功能(也许这些功能来自C)？
2. 如果是,在C++ 11标准中替换这些函数的最佳方法是什么？

我想制作一个变量的副本,比如char **argv使用像memcpy 这样的东西但是怎么样？我可以知道尺寸以及如何参数化它,因为memcpy不会将二星作为参数.我必须写一个循环吗？

我必须在执行之前建立管道.因此,我希望像argv循环的每次迭代一样"生成"变量.

    token = strtok(cmd, "|");
    i = 0;
    while (token != NULL)
    {   
        printf("token %s\n", token);       
        makeArgs(token, &argc, &argv);
        for (int b = 0; b < argc; b++) {
           printf("makeargs %d: %s\n", b, argv[b]);   
        }   

        // Will copy argc characters from array1 to array2
       /* memcpy(makearg,argc, argc*18*sizeof(int));*/    
        shellcommand[i].argv = argv;
        i++;
        token = strtok(NULL, "|");
    }           
   /* do stuff */
   fork_pipes(argc, shellcommand);

我的目标是建立如下的管道.

/*  who | awk '{print $1}' | sort …

我正在尝试从我读取的文件中获取 int 值。诀窍是我不知道这个值有多少字节，所以我首先读取长度八位字节，然后尝试读取长度八位字节告诉我的尽可能多的数据字节。当我尝试将数据八位字节放入 int 变量并最终打印它时，问题就出现了 - 如果第一个数据八位字节为 0，则仅复制后面的一个，因此我尝试读取的 int 是错误的，如 0x00A2与 0xA200 不同。如果我使用 ntohs 或 ntohl，那么 0xA200 会被错误地解码为 0x00A2，因此它不能解决空洞问题。我正在像这样使用 memcpy：

memcpy(&dst, (const *)src, bytes2read)   

其中 dst 是 int，src 是 unsigned char *，bytes2read 是 size_t。

那么我做错了什么？谢谢！

我正在使用之前用 clang++ 编译的一段 C++ 代码（针对 x86）。在转换为 gcc 时，我在以下行中看到错误：

    memset(tracking, 0, sizeof(dbg_log_tracking_t));

我知道我不能 memset 一个“非平凡”（编译器的话）类，或者带有 vtable 的东西，但这是一个struct，它是一个内存块，仅此而已，但在编译时，g++ 告诉我，我无法清除非平凡类型的对象。

我得到一个指针作为缓冲区，我将从 phy 中将数据读入该缓冲区，然后使用该结构进行解包。在读取完成之前需要将该结构清零。

在C语言中，我可以高兴地搬起石头砸自己的脚。如果我愿意的话，我可以将 main() 设置为 null，但令人沮丧的是我在这里不能这样做。

我能想到的唯一解决方案是保留这个已经归零的结构的静态实例，然后将其memcpy过来，但这看起来就像是带有额外步骤和浪费内存的memset。

如果没有编写一个明确的函数来访问该特定结构的每个字段（只要我想要这样做，就必须这样做），如何将整个结构归零？

当我尝试在wchar_t字符串上使用memcpy时遇到错误。具体地说，尽管我发送给memcpy的长度与我要复制的字符串的长度正确，但仅复制了字符串中的前半个字符。这给我留下了目标字符串中不好的数据，因为字符串的后半部分充满了从字符串的新创建中遗留下来的垃圾字符。

下面的屏幕截图显示了我正在处理的确切问题：

我唯一能想到的是，这可能与我将非Unicode应用程序的语言环境设置为日语有关，但我要做的第一件事是将语言环境改回英语，问题仍然存在。我觉得我确实缺少一个非常明显的解决方案。有任何想法吗？

memcpy(buf, buf + (pos - offset), len);

然而,

0<=pos<=strlen(buf), 0<=offset<=strlen(buf)

memcpy()在这种情况下使用是否安全？如果没有,会出现什么问题？请提出最佳做法.

我正在尝试使用 C 中的 memcpy() 创建一个通用交换函数。当我尝试交换数组时，我得到了一个垃圾值。

这是下面的代码：

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

typedef struct Student
{
    char a[10];
    int b;
    double c;
}   Student;

void swap(void* one, void* two,size_t size)

{
    char temp[size] ;
    memcpy(temp,two,size); // temp = *two;
    memcpy(two,one,size);//*two = *one;
    memcpy(one,temp,size);//*one = temp;
}

int main()
{
    int i1 = 10, i2 = 20;
    float f1 = 1.6, f2 = 8.9;
    int a1[3] = {1, 2, 3}, a2[3] = {10, 20, 30};
    Student s1 = {"Mark", 42, 5.2}, s2 = {"Bilal", 9, …

我知道memcpy对于重叠区域通常是不安全的,我确实理解其中的原因.但我的问题是:做这样的事情通常是否安全？

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

int main(void) {
    int a = 5;
    memcpy(&a, &a, sizeof a);
    printf("%d", a);
    return 0;
}

如果没有,我可以认为哪种硬件/软件配置是安全的？

edit1:所以我将改进我的问题:这个函数的通常*实现会认为它安全吗？(当然不在C标准之外)

edit2:我知道这个问题很容易解决,但是这个奇怪的用例引起了一个问题,这个问题没有直接被其他答案所覆盖.

*通常我指的是大多数使用和部署系统的实现(例如linux,windows ......)

我制作了一个最小的工作示例,我有一大段代码.

问题是,sizeof打印第一次调用16,这是正确的大小,而第二次调用只打印8.奇怪的是,它总是打印8,独立于结构的大小,是否只有一个值或10个值.

struct test_struct
{
    int32_t val1;
    int32_t val2;
    int32_t val3;
    int32_t val4;
};

unsigned char * StructToChar(test_struct structy)
{
    unsigned char returnval[sizeof(structy)];
    memcpy(returnval, &structy, sizeof(structy));
    return returnval;
}

int main()
{
    test_struct sendstruct = {};
    unsigned char *test_array = StructToChar(sendstruct);

    unsigned char returnval[sizeof(sendstruct)];
    memcpy(returnval, &sendstruct, sizeof(sendstruct));

    printf("%d\n", sizeof(returnval));
    printf("%d\n", sizeof(test_array));
    return 0;
}

我正在寻找如何编写像memcpy这样的函数.将整数或字符从一个数组复制到另一个数组的方法.我的意思是,它使用memcpy,而不使用它.但就我而言,它不起作用.

void Memcpy( void *from, void *to, int dimension, int length ) {

   if(dimension == sizeof(char)){
      char *copyFrom = (char *)from;
      char *copyTo = (char *)to;

      for(int i = length; i < length; i++)
         copyTo[i] = copyFrom[i];
   }


   if(dimension == sizeof(int)){
      int *copyFrom = (int *)from;
      int *copyTo = (int *)to;

      for(int i = length; i < length; i++)
         copyTo[i] = copyFrom[i];
   }
}

{谢谢你的帮助=)}

简介:这个问题是我收集的C和C++(以及C/C++常见子集)问题的一部分,这些问题涉及允许具有严格相同的字节表示的指针对象具有不同的"值",即行为不同对于某些操作(包括在一个对象上定义了行为,在另一个对象上定义了未定义的行为).

在另一个引起很多混淆的问题之后,这里有关于指针语义的问题,希望能够解决问题:

这个程序在所有情况下都有效吗？唯一有趣的部分是在"pa1 == pb"分支中.

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

int main() {
    int a[1] = { 0 }, *pa1 = &a[0] + 1, b = 1, *pb = &b;
    if (memcmp (&pa1, &pb, sizeof pa1) == 0) {
        int *p;
        printf ("pa1 == pb\n"); // interesting part
        memcpy (&p, &pa1, sizeof p); // make a copy of the representation
        memcpy (&pa1, &p, sizeof p); // pa1 is a copy of the bytes of …