Discussion :

[zuzuu]

Bonjour,

J'ai un petit soucis d'utilisation du C++, aussi comme c'est un cas un peu particulier, je voulais vous demandez votre avis :

J'ai un tableau dans je ne connais pas le type (ça peut être MaClasse[4], comme float[6]... etc).

Mais à aucun moment je ne sais quel est le type. Tout ce dont je dispose c'est :
* sizeObj : la taille de l'objet (sizeof(MaClasse) ou sizeof(float) par exemple).
* source : un void * pointant sur l'obj (mon tableau).
* destination : un void * pointant sur l'obj (du type égal à ce qui est contenu dans le tableau (par exemple maClasse ou un float).

J'aimerais faire un memcpy(destination, source, sizeObj) pour plusieurs élément du tableau à divers destination, mais il semble que le fait de ne pas connaitre le type de l'obj ne passe pas à la compilation...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
  for (unsigned l_ii = 0; l_ii < l_countInstance; l_ii++)
    {
      // Source pointer on the current value to copy
      void * l_val = new void*;
      // set the obj in l_val
      Get(l_val);       
      int * l_beginMem = (int *)l_val + (l_countInstance * l_sizeObj);
      

      // Destination pointer on child where copy value
      void * l_valChild = new void *;
      // Get the obj of destination
      m_children.at(l_ii)->Get(l_valChild);

      // Copy value 
      memcpy (l_valChild, l_beginMem, l_sizeObj);

    }

J'ai le sentiment de ne pas posséder la bonne adresse au niveau de la ligne en bleu...

En connaissant à l'avance le type, je peux caster void * l_val en Montype *, si cela peut vous aidez à comprendre.
Comment manipuler seulement les adresses des endroits sources et destinations sans se préocuper du type des données, puisque je connais les tailles à copier?

[bacelar]

Comment manipuler seulement les adresses des endroits sources et destinations sans se préocuper du type des données, puisque je connais les tailles à copier?

Heu, et comment vous gérez le padding entre les éléments du tableau si cous connaissez pas le type de l'élément ?

La copie binaire d'objet, c'est plus que suspect.

[zuzuu]

Ben en fait, du coup, je fais comme si j'avais des int ou des char. Dès que j'ai l'adresse en mémoire pour l'instant, je copie coup par coup. C'est pour cela je me demandais si il y avait quelque chose de plus élégant.


en fait, c'est parce que je dois faire un programme générique capable d'envoyer des données binaires sur un réseau.

[bacelar]

Il y a tout un tas de Framework qui gère la sérialisation pour ça, boost par exemple.
Et des données opaques, c'est bien gentil, mais s'il y a des pointeurs dans les objets, bonjour les dégâts.

[JolyLoic]

J'aimerais faire un memcpy(destination, source, sizeObj) pour plusieurs élément du tableau à divers destination, mais il semble que le fait de ne pas connaitre le type de l'obj ne passe pas à la compilation...

Tu n'as pas le droit de faire memcpy sur des objets, sauf conditions spéciales. En C++98, les conditions sont que l'objet soit un POD (en gros, une struct à la C, dont tous les membres sont aussi des POD, aucun constructeur, pas de fonction virtuelle...). En C++0x, les conditions ont été légèrement relâchées (on peut avoir des contructeurs, mais les constructeurs de copie et de déplacement doivent être triviaux), mais il n'empêche que la grande majorité des types n'est pas compatible avec memcpy.

Comme tu es dans la section .NET, je suppose que tu parles de C++/CLI, et non de C++, et bien là non plus les types ne sont pas copiables directement en mémoire, et pire encore, on ne peut même pas lire directement leur représentation mémoire, sans les avoir a préalable épinglé (pin) pour empêcher le GC de les bouger d'un point à l'autre...

[zuzuu]

Non, non , c'est bien du C++ que je fais. Je me suis trompée de rubrique ?
En fait, c'est justement sur des structures que nous faisons cela uniquement. Justement, il semble que ce soit le seul moyen de pouvoir enregistrer bit à bit (ou octet par octet) les données et les récupérer ensuite pour reconstituer la structure d'origine.

[JolyLoic]

En effet, ici, c'est pour la variante du C++ liée à .NET, c'est à dire le C++/CLI. Pour le C++, c'est http://www.developpez.net/forums/f19/c-cpp/cpp/

[3DArchi]

Justement, il semble que ce soit le seul moyen de pouvoir enregistrer bit à bit (ou octet par octet) les données et les récupérer ensuite pour reconstituer la structure d'origine.

Outre ce qu'à déjà précisé Loïc sur les contraintes de la structure pour garantir un memcpy 'brut' en C++, je voudrais juste rappeler qu'une bête sérialisation octet par octet pour transporter des données doit tenir compte (en C++ comme en C) des problèmes d'alignements, de boutisme, de taille des types et j'en oublie certainement.
Je crois que si tu peux tu devrais suivre le conseil de bacelar et opter pour une bibliothèque qui propose de la sérialisation en C++.

Sinon, sur le code que tu as posté :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
void * l_val = new void*;
      // set the obj in l_val
      Get(l_val);

ici tu alloue un pointeur sur void. Donc (en supposant que tu as des adresses sur 32 bits), tu alloues 4 octets seulement.
Que fait Get ? S'il se contente de positionner l'adresse de l_val, alors l'allocation est inutile. S'il copie des données vers l'adresse pointée par l_val, alors tu auras souvent des débordements.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int * l_beginMem = (int *)l_val + (l_countInstance * l_sizeObj);

En appliquant l'arithmétique des pointeurs, cette ligne ne déplace pas l_val de l_countInstance * l_sizeObj octets mais de (l_countInstance * l_sizeObj)*sizeof(int) octets puisque tu cast l_val en int*.

Et bien sur il en va de même pour la variable suivante.

Donc ta ligne bleu pose bien problème mais c'est probablement toute ta sérialisation qui risque de partir dans les choux.