메모리를 std :: copy로 복사하십시오.

Question

모든 CopyMemory 함수를 std :: copy 함수로 변환하려고합니다.

copymemory 및 memcpy에서는 작동하지만 std :: copy에서는 작동하지 않습니다. 누구든지 내가 뭘 잘못하고 어떻게 해결할 지 말해 줄 수 있니?

std::string Foo = "fdsgsdgs"; 

std::string::iterator it = Foo.begin(); 

unsigned char* pt = &(*it); 

어떻게 다음 반복자 포인터를 변환합니다 :

template<typename T> 
void S(unsigned char* &Destination, const T &Source) 
{ 
    //CopyMemory(Destination, &Source, sizeof(T)); 
    std::copy(&Source, &Source + sizeof(T), Destination);  //Fails.. 
    Destination += sizeof(T); 
} 

template<typename T> 
void D(T* &Destination, unsigned char* Source, size_t Size) 
{ 
    //CopyMemory(Destination, Source, Size); 
    std::copy(Source, Source + Size, Destination); 
    Source += sizeof(T); 
} 

template<typename T> 
void D(T &Destination, unsigned char* Source, size_t Size) 
{ 
    //CopyMemory(&Destination, Source, Size); 
    std::copy(Source, Source + Size, &Destination); 
    Source += sizeof(T); 
} 

나는 또한 내가 할 수있는 포인터로 반복자를 변환하려면 다음을 냈어요? : S

내가 (그렇지 않은 경우 작동하는 경우 7 인쇄 ... 랜덤 숫자)을 방어 적이기/표준 대 copymem :: 다음과 같이 복사가됩니다를 테스트하는 데 사용하는 코드 :

#include <windows.h> 
#include <iostream> 
#include <vector> 
#include <typeinfo> 

using namespace std; 

typedef struct 
{ 
    int SX, SY; 
    uint32_t Stride; 
    unsigned long ID; 
    int TriangleCount; 
} Model; 

template<typename T> 
void S(unsigned char* &Destination, const T &Source) 
{ 
    CopyMemory(Destination, &Source, sizeof(T)); 
    Destination += sizeof(T); 
} 

template<typename T> 
void S(unsigned char* &Destination, const std::vector<T> &VectorContainer) 
{ 
    size_t Size = VectorContainer.size(); 
    for (size_t I = 0; I < Size; ++I) 
     S(Destination, VectorContainer[I]); 
} 

void S(unsigned char* &Destination, const Model &M) 
{ 
    S(Destination, M.SX); 
    S(Destination, M.SY); 
    S(Destination, M.Stride); 
    S(Destination, M.ID); 
    S(Destination, M.TriangleCount); 
} 

template<typename T> 
void D(T* &Destination, unsigned char* Source, size_t Size) 
{ 
    CopyMemory(Destination, Source, Size); 
    Source += sizeof(T); 
} 

template<typename T> 
void D(T &Destination, unsigned char* Source, size_t Size) 
{ 
    CopyMemory(&Destination, Source, Size); 
    Source += sizeof(T); 
} 

template<typename T> 
void D(std::vector<T> &Destination, unsigned char* Source, size_t Size) 
{ 
    Destination.resize(Size); 
    for(size_t I = 0; I < Size; ++I) 
    { 
     D(Destination[I], Source, sizeof(T)); 
     Source += sizeof(T); 
    } 
} 

void D(Model* &Destination, unsigned char* Source) 
{ 
    D(Destination->SX, Source, sizeof(Destination->SX)); 
    D(Destination->SY, Source, sizeof(Destination->SY)); 
    D(Destination->Stride, Source, sizeof(Destination->Stride)); 
    D(Destination->ID, Source, sizeof(Destination->ID)); 
    D(Destination->TriangleCount, Source, sizeof(Destination->TriangleCount)); 
} 

long double* LD = new long double[25000]; 
std::vector<Model> ListOfModels, ListOfData; 

void ExecuteCommands() 
{ 
    switch(static_cast<int>(LD[1])) 
    { 
     case 1: 
     { 
      LD[2] = 2; 
      unsigned char* Data = reinterpret_cast<unsigned char*>(&LD[3]); 
      Model M; M.SX = 1; M.SY = 3; M.Stride = 24; M.ID = 7; M.TriangleCount = 9; 
      Model K; K.SX = 3; K.SY = 21; K.Stride = 34; K.ID = 9; K.TriangleCount = 28; 

      ListOfModels.push_back(M); 
      ListOfModels.push_back(K); 
      S(Data, ListOfModels); 
     } 
     break; 
    } 
} 

void* GetData() 
{ 
    unsigned char* Data = reinterpret_cast<unsigned char*>(&LD[3]); 
    D(ListOfData, Data, LD[2]); 
    cout<<ListOfData[0].ID;  //Should print 7 if it works. 
    return &ListOfData[0]; 
} 


int main() 
{ 
    LD[1] = 1; 
    ExecuteCommands(); 
    GetData(); 
} 

Answer 1

이 코드에는 여러 가지 문제가 있으므로 어디서부터 시작해야할지 모르는 것이 거의 없습니다. 그리고 오류는 많은 경우에있어서 당신이해야 할 일에 대한 큰 오해를 배제하기 때문에 기본적입니다. 당신이 작성한 코드 종류는 숙련 된 C++ 프로그래머에게는 위험합니다. 코드에서 작성한 오류로 인해 경험이 많이 떨어진다는 것을 알 수 있습니다.

당신이하려는 일을 중단하십시오.

하지만 코드를 작성해 보겠습니다.

std::copy(&Source, &Source + sizeof(T), Destination);  //Fails.. 

먼저 C++에서 포인터에 대해 설명하겠습니다.

당신이 어떤 종류의 T에 대한 포인터가있는 경우의 일, T *t을 가정 해 봅시다이 t + 1 것이다 하지 이동 한 바이트 위에 포인터. 여기는 기본적인 포인터 연산입니다. t + 1은 sizeof(T)에 의해 그것을 옮길 것입니다; 포인터가 C의 초기부터 어떻게 작동했는지, C++은 말할 것도 없습니다.

Source은 T&이므로 &Source은 T*입니다. 따라서 sizeof(T)을 추가하면 포인터가 sizeof(T) * sizeof(T)만큼 증가합니다. 그것은 당신이 원하는 것이 아닙니다.

둘째, std::copy은 memcpy이 아닙니다. std::copy은 하나의 값 콜렉션 (입력 반복자 쌍에 의해 정의 됨)을 출력 반복자에 의해 정의 된 다른 값 콜렉션으로 복사하기위한 것입니다. std::copy은 입력 반복자의 value_type이 출력 반복자의 value_type으로 암시 적으로 변환 가능해야합니다.

해당 입력 반복기 인 T*의 value_type은 T입니다. T* 님의 포인터가 T입니다. 출력 반복자 인 char*의 value_type은 char입니다. std::copy은 효과적으로 수행하려고 할 것입니다 :

char *val; 
T *t; 
*val = *t; 

에도이 두 포인터가 초기화되지 않은 사실을 무시

이는 이해되지 않는다. T에 operator char 변환 연산자가없는 경우 T을 입력하고 char으로 이동하면됩니다.따라서 컴파일 오류가 발생합니다. 너도 그래야 해.

T이 실제로 있고 적절한 크기의 char* 배열로 복사하려는 경우 (또는 그 반대) std::copy은 필요한 도구가 아닙니다. 원하는 도구는 std::memcpy입니다. std::copy은 개체 인을 복사하기위한 것으로 바이트를 복사하지 않습니다.