标签: memcpy

是否有一个"简单"的方式来实现类似CopyTo()对MemberwiseCopy(而不是Clone()或者MemberwiseClone在C#)？我不想创建一个新对象,因为我希望每个拥有旧对象的人都能够看到新对象的属性,这可能是完全不同的.虽然大多数这些派生自一个可以保留一些抽象函数的父类,但我不想写几百行代码只是为了逐个复制每个成员.可能需要复制所有这些(糟糕的设计,但它不是我的,也不是被重写).看起来微软会为此创建一个界面,还是我错过了什么？

在C中,如果我提供一个有符号整数,特别是一个负整数作为memcpy函数的第三个参数,会发生什么？

例:

 memcpy(destBuf, source, -100*sizeof(source))

-100*sizeof(source)memcpy会将结果解释为unsigned吗？

谢谢!

我想使用memcpy将struct数组的元素复制到另一个.我相信这很可能导致我的程序由于某种原因而失败.另外我怎样才能释放内存？

struct FaultCodes
{
  string troubleFound;
  string causeCode;
  string actionCode;
  string paymentCode;
  string suppCode;
  u_int16_t multiplier;
};

struct JobFaultInfo
{
  static const size_t NUM_CODES = 5;
  FaultCodes codes[NUM_CODES];
};

FaultCodes codes[JobFaultInfo::NUM_CODES];
// I have populated codes with the data.

JobFaultInfo info;
memcpy(info.codes, codes, sizeof(FaultCodes)*JobFaultInfo::NUM_CODES);

我在gcc下编译了以下代码:

int parseMsg(const char *msg_to_parse, unsigned long *exp_input, unsigned long *sysTicks )
{
   int l_msg_size = strlen(msg_to_parse);
   if(l_msg_size <10)
          return -1;
    char l_exp_input_arr[10];
    char l_sys_ticks_arr[10];
    memcpy(l_sys_ticks_arr,msg_to_parse+12,10);

    memcpy(l_exp_input_arr,msg_to_parse,10);
   //l_msg_size = strlen(msg_to_parse);
    *sysTicks = strtoul(l_sys_ticks_arr,NULL,10);

   *exp_input = strtoul(l_exp_input_arr,NULL,10);



   return 0;
}

我正试图以下列方式测试它:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int parseMsg(const char *msg_to_parse, unsigned long *exp_input, unsigned long *sysTicks );

int main(void) {
char msg[] = "1234567890  59876543213";
unsigned long along1, along2;
along1 =0;
along2=0;
parseMsg(msg,&along1, &along2 );
printf("result of parsing: \n \t …

我如何从给定的偏移量开始复制内存.例如

int main()
{
   int a1[100], a2[100], i;
   errno_t err;

   // Populate a2 with squares of integers
   for (i = 0; i < 100; i++)
   {
      a2[i] = i*i;
   }

   // Tell memcpy_s to copy 10 ints (40 bytes), giving
   // the size of the a1 array (also 40 bytes).
   err = memcpy_s(a1, sizeof(a1), a2, 10 * sizeof (int) );    
   if (err)
   {
      printf("Error executing memcpy_s.\n");
   }
   else
   {
     for (i = 0; i < 10; i++)
       printf("%d ", a1[i]); …

我想学习如何将3维数组从主机内存复制到设备内存.假设我有一个包含数据的3d数组.例如int host_data [256] [256] [256]; 我想以这样的方式将数据复制到dev_data(设备数组),以便host_data [x] [y] [z] = dev_data [x] [y] [z]; 我该怎么做？以及如何访问设备中的dev_data数组？一个简单的例子非常有用.

为什么以下不编译:

struct Carrier
{
  void* data;
  int StrategyRequestType;

  Carrier(int StrategyRequestType )
  {
    StrategyRequestType = StrategyRequestType;
  }

  template <typename T>
  bool loadStrategyRequestType(T)
  {
    data = malloc(sizeof(T));
    memcpy ( data, &T, sizeof(T) );   // Syntax error here - "expected primary expression before ',' token"
    return true;
  }
};

什么方法可以使它工作？

我试图"打包"一个大的mmap()d文件,如下所示:

//numBytes is based on user input
data = static_cast<char*>(mmap((caddr_t)0, numBytes, PROT_READ, MAP_SHARED, myFile, 0));

int
Sender::Packetize(char* data, int numBytes)
{
    int seqNum = 1;
    int offset = 0;
    size_t totalPacked = 0;
    unsigned int length = sizeof(struct sockaddr_in);

    bool dataRemaining = true;
    while(dataRemaining)
    {
            //MTU = 1460
        size_t payloadSize;
        (numBytes > MTU) ? payloadSize = MTU : payloadSize = numBytes;
        char* payload = (char*)malloc(payloadSize);

        memcpy(payload, data, payloadSize);
        Packet pac = {seqNum, 0, payloadSize, payload}; //Basic struct

        totalPacked …

我在这里有一个疑问,我正在尝试将一个变量memcpy()复制string[9]到一个unsigned long long int变量,这里是代码:

unsigned char string[9] = "message";
string[8] = '\0';
unsigned long long int aux;

memcpy(&aux, string, 8);
printf("%llx\n", aux); // prints inverted data

/* 
 * expected: 6d65737361676565
 *  printed: 656567617373656d
 */

如何在不反转数据的情况下制作此副本？

我正在尝试并行复制矩阵。下面是我正在使用的代码。目前，它可以与char一起正常工作，但是当我使用短裤时它会出现段错误。我认为错误在于复制向量之外的内存。我试图调试我的假设，但没有成功。

CMakeLists.txt

cmake_minimum_required(VERSION 3.0)
project(memcpy CXX)
find_package (Threads)
add_executable(memcpy main.cpp)
set_property(TARGET memcpy PROPERTY CXX_STANDARD 17)
target_link_libraries (memcpy ${CMAKE_THREAD_LIBS_INIT})

main.cpp

#include <cassert>
#include <condition_variable>
#include <cstring>
#include <iostream>
#include <mutex>
#include <string>
#include <thread>
#include <vector>


class Barrier {
  public:
    explicit Barrier(std::size_t const count) : m_threshold(count), m_remaining(count), m_generation(0) {}

    void wait() {
        auto local = std::unique_lock<std::mutex>{m_mutex};
        auto current_generation = m_generation;

        m_remaining--;
        if (!m_remaining) {
            m_generation++;
            m_remaining = m_threshold;
            m_condition.notify_all();
        } else {
            m_condition.wait(local, [this, current_generation] { return current_generation != m_generation; }); …