c++ unsigned char copie de la mémoire

J'ai besoin de passer un unsigned char tableau à partir d'une méthode à l'autre, et j'ai essayé d'utiliser ce code:

{
     unsigned char *lpBuffer = new unsigned char[182];
 ReceiveSystemState(lpBuffer);

}

BOOL ReceiveSystemState(unsigned char *lpBuffer)
  {
      unsigned char strRecvBuffer[182] = { 0 };
      //strRecvBuffer construction

      memcpy(lpBuffer, strRecvBuffer, sizeof(strRecvBuffer));

      return TRUE;
 }

Aucun de ces 3 méthodes (utilisé dans ReceiveSystemState) fonctionné comme je l'espérais. Après l'utilisation de chacun d'eux tout ce qu'il est copié est le premier char de strRecvBuffer et rien de plus. Le strRecvBuffer a vide caractères d'un élément, mais j'ai besoin de ceux qu'ils sont, parce que cette chaîne est un message à partir d'un périphérique matériel, et ce message sera anallysed à l'aide d'un protocole. Ce qui me manque ici? Dois-je initialiser lpBuffer mal?

EDIT: j'ai utilisé un simple memcpy méthode pour faire le travail. Toujours le même résultat: tout ce qui est copié est le premier char de strRecvBuffer.

EDIT2: code du Travail:

{
     unsigned char *lpBuffer = new unsigned char[182];
     ReceiveSystemState(lpBuffer);
     for (int i = 0; i < 144; i++)
     {
         memcpy(&c_dateKG[i], lpBuffer + i * sizeof(unsigned char), sizeof(unsigned char) );
     }

}    
  BOOL ReceiveSystemState(unsigned char *lpBuffer)
  {
     unsigned char strRecvBuffer[182] = { 0 };
     //strRecvBuffer construction

     memcpy(lpBuffer, strRecvBuffer, sizeof(strRecvBuffer));

     return TRUE;
  }

ne pense pas que cela fera une différence depuis unsigned char a 1 octet taille. donc, fondamentalement, 182 * sizeof(unsigned char) est la même que 182.
Je n'ai pas cette. Où dois-que viennent les données? Vous définissez strRecvBuffer pour contenir un 0 et les ordures par la suite. Autres que que, memcpy copie tous de la matrice, que votre boucle.
= { 0 } est la syntaxe pour définir tous les éléments à 0
memcpy( lpBuffer, strRecvBuffer, 182 ) devrait faire le travail. Il y a quelque chose d'autre que vous n'êtes pas à nous montrer. Aussi: pourquoi avez-vous jeté à void parfois, et pas d'autres? Pourquoi avez-vous attribuer NULL à une variable qui est immédiatement aller hors de portée, et pourquoi avez-vous vérifier la valeur null avant de delete[] (où un pointeur null est légal), et pas plus tôt? Pour cette question, pourquoi avez-vous vérifier la valeur null à tous, depuis new[] est garanti de ne jamais retourner un pointeur null? Et peut-être le plus important: pourquoi êtes-vous à l'aide de new[], au lieu de std::vector< unsigned char >?
les données proviennent d'un port série à l'aide d'une autre méthode, et la déclaration est pour initializind tous les éléments avec 0.
ce que je ne vous montrent pas, est une méthode qui lit les données à partir d'un port série, et renvoie strRecvBuffer. Qui ne devrait pas interférer avec le reste du code.
Peut-être, mais il n'y a aucune raison dans le code que vous montrez memcpy de ne pas travailler.
Debug définir un point d'arrêt à memcopy et vérifier le contenu de lpbuffer premier.
fait cela, et a comparé les 2 tableaux.
concernant "une méthode qui lit les données à partir d'un port série, et renvoie strRecvBuffer." dans le code ci-dessus strRecvBuffer est une variable locale, nous sommes donc supposer que vous êtes de passage à l'invisible méthode? Le code ci-dessus n'est pas le code à partir de votre source à l'origine de votre problème. Je n'ai aucun doute que vous avez un problème, mais dans le processus de rognage ce que vous jugés sans importance le code avant de le poster ici, vous avez raccordé le problème ainsi. Tous les doutes que je vous suggère de créer un seul fichier avec simplement le code ci-dessus et exécutez-la. fournit à la fois de la dyn-alloc et statique 182 octets. des œuvres.
cette méthode n'était pas le problème en effet. J'ai édité ma question avec le code de travail.

InformationsquelleAutor MRM | 2012-10-05

arrays c++unsigned-char

7

Votre code est absolument ordures. Quelques remarques:

Utilisation sizeof:

Utilisation sizeof(static_massive_name); ou count_of_arr_elements * sizeof(arr_type);

Par exemple:
```
unsigned char src[255];    
unsigned char dst[255];

//fill src with random data
for (int i = 0; i < 255; ++i) {
    src[i] = static_cast<unsigned char> (rand() % 255);
}

memcpy(src, dst, sizeof(dst));


//now dst will have copied values from src (random numbers)
```
Mise à JOUR:

L'intégralité du code source pour les tests:
```
#include <iostream>
#include <string.h>
#include <time.h>
#include <stdlib.h>

using namespace std;

void print(unsigned char* arr, size_t size) {
    for (size_t i = 0; i < size; ++i) { 
        //see type casting (to int)!!!
        cout << "arr[" << i << "] = " << (int)arr[i]<< endl;
    }
}

int main() {
    srand(time(0));

    //unsigned char type hold values from 0 to 255
    unsigned char src[15];
    unsigned char dst[15];

    for (int i = 0; i < 15; ++i) {
        src[i] = rand() % 255;
    }

    memcpy(src, dst, sizeof(dst));

    print(src, 15);
    print(dst, 15);

    return 0;
}
```
Résultat:
```
arr[0] = 34
arr[1] = 80
arr[2] = 183
arr[3] = 112
arr[4] = 18
arr[5] = 120
arr[6] = 183
arr[7] = 0
arr[8] = 0
arr[9] = 0
arr[10] = 0
arr[11] = 57
arr[12] = 137
arr[13] = 4
arr[14] = 8
arr[0] = 34
arr[1] = 80
arr[2] = 183
arr[3] = 112
arr[4] = 18
arr[5] = 120
arr[6] = 183
arr[7] = 0
arr[8] = 0
arr[9] = 0
arr[10] = 0
arr[11] = 57
arr[12] = 137
arr[13] = 4
arr[14] = 8
```
- J'ai essayé aussi, le résultat est le même: seul le premier caractère est copié.
- votre échantillon fonctionne bien, à l'application de la méthode de mon code ne fonctionne pas.
- 1. Si mon code fonctionne très bien, que le système de memcpy fonctionne très bien 2. Lorsque vous imprimez unsigned char - assurez-vous de cast en int (si votre code utilise le c++) ou printf (pour du code C): unsigned char var = 12; printf("var = %d\n", (int), var);
- je suis sûr que memcpy fonctionne très bien, il y a encore quelque chose là-bas, dans mon code que je n'utilisez pas de droit. Et il ne fait pas vraiment de sens, car je la syntaxe ressemble bien maintenant.
- après un peu plus de regards lors de mon code, j'ai réalisé que: dans BOOL ReceiveSystemState(unsigned char *lpBuffer), lpBuffer est passé comme un pointeur vers un tableau de caractères, de sorte que le débogueur montré que "seul le premier char" était en effet le premier char de l'ensemble de la zone mémoire lpBuffer souligné. (mon explication ne peut pas être trop précis). Donc il n'y a pas d'autre problème que ... eh bien, moi! J'ai juste besoin d'utiliser memcpy(&c_dateKG[i], lpBuffer + i * sizeof(unsigned char), sizeof(unsigned char) ); copier les valeurs de la matrice de retour à partir de la mémoire. J'ai mis à jour mon post avec le corect utiliser de code. Merci!
- L'exemple de Code est faux! "src" et "heure d'été" en memcpy fonctions doivent être échangé, correct: memcpy(dst, src, sizeof(src)); consultez le manuel. L'exemple de code ci semble fonctionner parce que le non initialisé "heure d'été", contient aussi aléatoire charaters. Pour mieux test, utiliser i au lieu de rand() % 255 dans le src de l'initialisation de la boucle.
- erreur dans mon commentaire précédent, c'est correct: memcpy(dst, src, sizeof(heure d'été));
InformationsquelleAutor Maxim

Vous devez vous connecter pour publier un commentaire.