Est-il correct d'utiliser memcpy() pour copier une structure qui contient un pointeur?

Il y a plusieurs erreurs dans le code présenté, je vais parler en premier, suivi par mon stock-diatribe de pointeurs vs tableaux.

struct charMap
{ 
  unsigned int * name;   
  unsigned int id;       
};
typedef struct charMap CharMapT;

Il déclare un type de structure qui comprend un pointeur vers unsigned int comme le premier membre de (nom) et un int comme le second membre (id). Sur un système 32 bits par défaut en octets de l'emballage ce sera 8 octets large (pointeur de 32 bits = 4 octets, 32-bit signé int=4 octets). Si c'est une machine 64 bits, les pointeurs sera de 8 octets de large, l'int toujours susceptibles de 32 bits, ce qui fait de la taille de la structure 12 octets.

Discutable Code

void ABC::Function ()
{
  CharMapT list[] = 
  {
    {"NAME1", 1},
    {"NAME2", 2}, 
    {"NAME3", 3}
  };

  structList = new CharMapT[sizeof(list)];
  memcpy(structList, &list, sizeof(list));
}

Il alloue un tableau dynamique de CharMapT des structures. Combien? Plus que vous ne le pensez. Le sizeof(list) sera de retour le byte-comte de la list[] tableau. Depuis un CharMapT structure est de 8 octets de large (voir ci-dessus), il faut en 3 * 8, ou 24 CharMapT éléments (36 points, si à l'aide de pointeurs 64-bit).

Nous avons ensuite memcpy() 24 octets (ou 36 octets) à partir de list (le & dans &list est inutile) à la mémoire nouvellement allouée. cela permettra de copier plus de 3 CharMapT structures, laissant les autres 21, nous avons alloué intacte (au-delà de leur valeur initiale par défaut de construction).

Note: vous êtes l'initialisation d'un const char * à un champ déclaré que unsigned int *, donc, si cette même compilé le type de données fondamental serait différent. En supposant que vous avez fixé votre structure et de modifier le type de pointeur pour const char *, les adresses de la statique des constantes de chaîne (les adresses de la rubrique "NOM" constantes) quelque part dans votre const segment de données sera affectée à la variable pointeur des éléments dans structList[0].nom, structList[2].nom, et structList[3].nom respectivement.

Ce ne sera PAS copier les données de relever à. il ne copie que le pointeur valeurs. Si vous voulez des copies de données, alors vous devez raw de les affecter (malloc, de nouveau, peu importe).

Mieux encore, utiliser une std::vector<CharMapT>, utilisez std::string pour CharMapT::name, et l'utilisation std::copy() à reproduire la source (ou même directement de cession).

J'espère que explique ce que vous cherchez.

---

Pointeur vs Tableau Diatribe

Jamais confondre un pointeur d'un tableau. Un pointeur est une variable que détient une adresse. Tout comme un int variable tenir un entier de valeur, ou un char variable contient un type de caractère, la valeur à un pointeur est une adresse

Un tableau est différent. Il est également une variable (évidemment), mais il ne peut pas être une l-value, et près de tous les endroits où elle est généralement utilisée une conversion se produit. Sur le plan conceptuel que les résultats de la conversion dans un temporaire pointeur qui pointe vers le type de données de la matrice, et contient l'adresse du premier élément. Il ya des moments où cette notion ne pas se produisent (comme l'application de l'adresse de l'opérateur).

void foo(const char * p)
{
}

char ar[] = "Hello, World!";
foo(ar); //passes 'ar', converted to `char*`, into foo. 
         //the parameter p in foo will *hold* this address

ou ceci:

char ar[] = "Goodbye, World!";
const char *p = ar;  //ok. p now holds the address of first element in ar
++p;                 //ok. address in `p` changed to address (ar+1)

mais pas cette:

char ar[] = "Goodbye, World!";
++ar; // error. nothing to increment.

OriginalL'auteur WhozCraig

Tous vous avez vraiment besoin de savoir ici, c'est que memcpy vous donnera un bit à bit copie de l'original. Donc, ce que vous aurez est de deux pointeurs avec la même valeur (c'est à dire, une adresse) qui se réfèrent aux mêmes données.

Sur une note de côté, vous avez déclaré name comme un pointeur vers int, ce qui est évidemment faux. Il devrait être un const char*. Aussi, comme c'est le C++ et pas en C, vous êtes mieux servi par quelque chose comme std::copy qui ne cassera pas votre code subtilement si charMap un jour devient un type complexe. Sur la même note, préférez std::string au lieu de const char* dans la plupart des situations.

OriginalL'auteur Ed S.

Je voudrais ajouter à @EdS.'s réponse:

Votre code est juste beaucoup plus c++ de style c code c++ si vous le faites comme ceci:

#include<string>
#include<vector>

struct CharMap
{ 
  CharMap(const std::string& name, unsigned char id); //only needed if you don't use -std=c++11
  std::string name;   
  unsigned char id;       
};
CharMap::CharMap(const std::string& name, unsigned char id):
  name(name),
  id(id)
{}

class ABC
{
public:
  ABC(); //or ABC() = default; if you use -std=c++11
  void Function();
private:
  std::vector<CharMap> structList;
}

ABC::ABC(){} //not needed with -std=c++11

void ABC::Function ()
{
  //This works with -std=c++11:
  //structList = 
  //{
  // {"NAME1", 1},
  // {"NAME2", 2}, 
  // {"NAME3", 3}
  //}; 

  //without c++11:
  structList = std::vector<CharMap>(3);
  structList[0] = CharMap("NAME1",1); //don't worry about copies, we have RVO (check wikipedia or SO)
  structList[1] = CharMap("NAME2",2);
  structList[2] = CharMap("NAME2",3);
}

Pourquoi ne pas utiliser std::vector pour faire un tableau? Vous pouvez le faire comme ceci:

#include<vector>

std::vector<CharMapT> structList(list.size()); 

Il est plus sûr, aussi, éviter d'utiliser des pointeurs diminue le risque de fuites de mémoire ou de bugs dus à une mauvaise utilisation de la sizeof opérateur.

Je suppose que vous ne voulez pas vraiment un structList, qui a autant d'éléments que l' la taille de la mémoire de votre liste. (Si la liste est le double de ce qui pourrait être plusieurs fois plus que le nombre d'éléments dans votre liste.)

Aussi, memcpy n'est pas vraiment nécessaire, si la liste est également un vecteur (qui est une fonction c vraiment). Vous venez de faire une simple affecter le fonctionnement:

structList = list; //given that list is a vector.

Cela va copier les éléments comme memcpy.

OriginalL'auteur Barnabas Szabolcs