La conversion Char tableau de Long en C

Cette question semble stupide, mais s'il vous plaît me guider
J'ai une fonction pour convertir les données d'une longueur de char tableau

void ConvertLongToChar(char *pSrc, char *pDest)
{
    pDest[0] = pSrc[0];
    pDest[1] = pSrc[1];
    pDest[2] = pSrc[2];
    pDest[3] = pSrc[3];
}

Et j'appelle la fonction ci-dessus comme ceci

long lTemp = (long) (fRxPower * 1000);
ConvertLongToChar ((char *)&lTemp, pBuffer);

Qui fonctionne très bien.
J'ai besoin d'une fonction similaire pour inverser la procédure. Convertir char tableau de long.
Je ne peux pas utiliser atol ou des fonctions similaires.

OriginalL'auteur AjayR | 2011-07-14

c memory

7

Laissant la charge de la correspondance de l'endianness avec votre autre fonction que pour vous, voici un moyen:
```
unsigned long int l = pdest[0] | (pdest[1] << 8) | (pdest[2] << 16) | (pdest[3] << 24);
```
Juste pour être sûr, ici, est le correspondant dans une autre direction:
```
unsigned char pdest[4];
unsigned long int l;
pdest[0] = l         & 0xFF;
pdest[1] = (l >>  8) & 0xFF;
pdest[2] = (l >> 16) & 0xFF;
pdest[3] = (l >> 24) & 0xFF;
```
Allant de char[4] à long et à l'arrière est entièrement réversible; allez de temps pour char[4] et à l'arrière est réversible pour une valeur allant jusqu'à 2^32-1.

Noter que tout cela n'est bien définies pour les types non signés.

(Mon exemple est peu endian si vous lisez pdest de gauche à droite.)

Addendum: je suis aussi en supposant que CHAR_BIT == 8. En général, remplacer les multiples de 8 par multiples de CHAR_BIT dans le code.

OriginalL'auteur Kerrek SB
9

Que vous pouvez faire:
```
union {
 unsigned char c[4];
 long l;
} conv;

conv.l = 0xABC;
```
et l'accès c[0] c[1] c[2] c[3]. C'est bon comme il ne perd pas de mémoire et est très rapide car il n'y a pas de changement ou toute cession d'ailleurs la première et il fonctionne dans les deux sens.

La meilleure façon de le faire.
Il est aussi, selon la norme C++, un comportement indéfini. 🙂
C'est un C question.
juste assez. Il est aussi, selon la norme, un comportement indéfini. 🙂
^ Ce que les compilateurs n'est pas réellement instructif à propos de ce que dit la Norme, si vous arrivé à être à corriger de toute façon. @jalf.com Non, C fait type beaucoup les jeux de mots par l'intermédiaire d'un union bien spécifié dans le C99 à partir de: stackoverflow.com/questions/11639947/... C++ pas hériter cela, cependant.

OriginalL'auteur Vinicius Kamakura
6

Un moyen simple serait d'utiliser memcpy:
```
char * buffer = ...;
long l;
memcpy(&l, buff, sizeof(long));
```
Qui ne se prend pas endianness en compte, cependant, alors méfiez-vous si vous devez partager des données entre plusieurs ordinateurs.

OriginalL'auteur Etienne de Martel
3

Si vous voulez dire à traiter sizeof (long) octets de la mémoire comme un seul long, alors vous devriez le faire ci-dessous:
```
char char_arr[sizeof(long)];
long l;

memcpy (&l, char_arr, sizeof (long));
```
Cette chose peut être fait par collage de chacun des octets de long à l'aide de décalage de bits sna-coller, comme ci-dessous.
```
l = 0;
l |= (char_arr[0]);
l |= (char_arr[1] << 8);
l |= (char_arr[2] << 16);
l |= (char_arr[3] << 24);
```
Si vous voulez convertir "1234\0" chaîne dans 1234L alors vous devriez
```
l = strtol (char_arr, NULL, 10); /* to interpret the base as decimal */
```
Fernandes : merci pour le modifier.

OriginalL'auteur phoxis

Fait ce travail:

#include<stdio.h>

long ConvertCharToLong(char *pSrc) {
    int i=1;
    long result = (int)pSrc[0] - '0';
    while(i<strlen(pSrc)){
         result = result * 10 + ((int)pSrc[i] - '0');
         ++i;
    }
    return result;
}


int main() {
    char* str = "34878";
    printf("The answer is %d",ConvertCharToLong(str));
    return 0;
}

Il l'habitude de travailler comme nous le char de la matrice de ne pas stocker directe à long valeur magasin en octets, merci pour votre réponse
oh désolé, mon mauvais. Cochez la case modifier. Son travail de 100% de fines.
vous avez raison avec votre exemple. Dans Mon cas, il n'est pas long données, mais octets qu'il s'agit de stocker, de sorte que cette solution fonctionne pas pour moi

OriginalL'auteur

-1

C'est sale, mais il fonctionne:
```
unsigned char myCharArray[8];
//Put some data in myCharArray here...
long long integer = *((long long*) myCharArray);
```
et ce qui est mal, de l'aliasing erreur et possible un comportement indéterminé de mauvais alignement

OriginalL'auteur Vin'Z
-1
```
char charArray[8]; //ideally, zero initialise
unsigned long long int combined = *(unsigned long long int *) &charArray[0];
```
Méfiez-vous des chaînes de valeur null comme vous vous en fin de copie de tous les octets au-delà de le terminateur null dans combined; ainsi dans l'affectation ci-dessus, charArray doit être tout à zéro d'initialisation pour un "nettoyage" de la conversion.

et ce qui est mal, de l'aliasing erreur et possible un comportement indéterminé de mauvais alignement

OriginalL'auteur Engineer

Vous devez vous connecter pour publier un commentaire.