Au Niveau Du Bit De Concaténation

J'ai le texte suivant:

char *pointer = decimal_to_binary(192) //yields 11000000
char *pointer2 = decimal_to_binary(168) //yields 10101000

Je suis en train de concat en:

1100000010101000

J'ai été référencement: Concaténer des nombres binaires de différentes longueurs et je suis actuellement en utilisant:

unsigned long pointer3 = (*pointer << 16) | *pointer2;

qui donne à la sortie:

1100010000000000110001

Ce que je fais mal?

considérant 32 grande machine, avez-vous essayé (*pointer << 32) | *pointer2
Êtes-vous sûr qu'il y a le dernier 0 sur le résultat que vous voulez? Si tout ce que vous voulez, c'est la concaténation de deux pointeurs, il semble que le dernier 0 est dans l'excès...
Fixe. merci Claudio.
Votre code n'a même pas compiler
Je pense que la question est un peu déroutant... avez-vous envie de concaténer une chaîne de caractères qui représente le nombre binaire ou les bits d'eux-mêmes (un entier)? Le titre de "bit-à-bit de concaténation" m'a fait penser que tu voulais l'opération sur un certain nombre et vous avez juste eu quelques erreurs de syntaxe, mais après @JonathanLeffler réponse je soupçonne que vous voulez juste concaténer des chaînes de caractères représentant les nombres binaires... Quel est le vrai but?

InformationsquelleAutor John Smith | 2013-04-18

bitwise-operators c

Vous ne vous montrez pas comment vous imprimer quoi que ce soit, ce qui le rend difficile à interpréter à votre question. Cependant, cette affirmation est irrémédiablement cassé en ce qu'il ne fait rien pour concaténer les chaînes de caractères pointée par pointer et pointer2:

unsigned long pointer3 = (*pointer << 16) | *pointer2;

C'est le premier personnage que pointer points (un 1) et les quarts de la valeur à gauche 16 bits, puis ajoute (rup) dans le premier personnage que pointer2 points (un autre 1), et attribue à l'entier donc le format de la mal nommée pointer3. Ainsi, on obtient la valeur:

pointer3 = 0x00310031;

La question prend une certaine interprétation, mais en faisant quelques plausible (mais pas nécessairement exacte) des hypothèses, ce code pourrait faire ce que vous êtes après:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static char *decimal_to_binary(unsigned char byte)
{
    char *result = malloc(9);
    if (result != 0)
    {
        char *digit = result;
        for (int i = 0; i < 8; i++)
            *digit++ = ((byte >> (7 - i)) & 0x01) + '0';
        *digit = '#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static char *decimal_to_binary(unsigned char byte)
{
char *result = malloc(9);
if (result != 0)
{
char *digit = result;
for (int i = 0; i < 8; i++)
*digit++ = ((byte >> (7 - i)) & 0x01) + '0';
*digit = '\0';
}
return result;
}
int main(void)
{
char *pointer1 = decimal_to_binary(192);
char *pointer2 = decimal_to_binary(168);
char  concatenated[17];
unsigned long pointer3 = (*pointer1 << 16) | *pointer2;
strcpy(&concatenated[0], pointer1);
strcpy(&concatenated[8], pointer2);
printf("P1 = <<%s>>; P2 = <<%s>>; P3 = 0x%08lX; C = <<%s>>\n",
pointer1, pointer2, pointer3, concatenated);
free(pointer1);
free(pointer2);
return(0);
}
';
    }
    return result;
}

int main(void)
{
    char *pointer1 = decimal_to_binary(192);
    char *pointer2 = decimal_to_binary(168);
    char  concatenated[17];
    unsigned long pointer3 = (*pointer1 << 16) | *pointer2;

    strcpy(&concatenated[0], pointer1);
    strcpy(&concatenated[8], pointer2);

    printf("P1 = <<%s>>; P2 = <<%s>>; P3 = 0x%08lX; C = <<%s>>\n",
           pointer1, pointer2, pointer3, concatenated);

    free(pointer1);
    free(pointer2);
    return(0);
}

De sortie:

P1 = <<11000000>>; P2 = <<10101000>>; P3 = 0x00310031; C = <<1100000010101000>>

Noter que le code à l'aide de decimal_to_binary() ne pas prendre soin d'éviter de (mis)à l'aide de pointeurs null. La conception de decimal_to_binary() est également à moins de stellaires; ceux free() appels sont facilement oubliés. Une meilleure conception de l'être:

void decimal_to_binary(unsigned char byte, char buffer[9]);

où le code appelant fournit le tampon dans lequel la sortie binaire est écrit. Il ya aussi d'autres façons d'écrire la boucle dans decimal_to_binary(); certains pourraient même être plus efficace que celui qui a été choisi ici.

ici vous avez utilisé la fonction strcpy.. pourquoi êtes-vous en faisant d'eux des cordes...alors il n'y a pas de sens de faire tout ce que je pense....juste les convertir en string et se joindre à eux... je pense que nous devons utiliser de l'opérateur au niveau du bit pour le faire
Eh bien, votre code a char *pointer = decimal_to_binary(192);, alors je suppose que decimal_to_binary() est de retour une char *, ce qui signifie a string. Si vous aviez unsigned char number1 = decimal_to_binary(192); (qui pourrait éliminer l'appel de la fonction et être écrit unsigned char number1 = 192;), et de même pour unsigned number2 = 168;, alors vous pouvez les combiner avec unsigned short number3 = (number1 << 8) | number2;. Si vous voulez de bonnes réponses, un bon SSCCE (Bref, Autonome, Exemple Correcte) qui montre ce que vous essayez de faire.
Ce n'est pas ma qué. je suis juste d'y répondre. et si vous ne souhaitez imprimer que le binaire alors pourquoi utiliser l'opération au niveau du bit c'est ce que je demande... je pense qu'il faut concaténer ces deux numéros, puis imprime sa valeur binaire
oh, désolé, n'a pas regardé assez attentivement avis vous êtes un co-répondeur. La question est confuse. J'ai pris une manière de considérer la question, fondée sur le char * les types utilisés. Vous prenez un point de vue alternatif, basé sur la mention des opérations bit à bit. Votre choix peut très bien être meilleur que le mien — la question ne devrait certainement être mieux écrit pour le rendre plus clair ce qui est vraiment voulu.
Son Ok.... et ya qué. doit être écrit mieux..

InformationsquelleAutor Jonathan Leffler

1

Ok, d'abord, vous ne devriez pas initialiser un pointeur et un entier; le compilateur va probablement vous avertir comme ceci:
```
warning: initialization makes pointer from integer without a cast [enabled by default]
   char* pointer1 = 0xc0;
```
Si vous n'êtes pas familier avec la notation hexadécimale, veuillez vous référer à cette; vous verrez la conversion de binaire en hexadécimal est beaucoup plus simple que de nombre décimal en hexadécimal, par exemple.

Si vous voulez représenter ces 8 bits on peut attribuer directement à unsigned char variables, comme je l'ai fait ici-bas (collez ce code dans un fichier "test.c", par exemple):
```
#include <stdio.h>

void main() {
  unsigned char num1 = 0xc0; /* Same as binary 11000000 in hex */
  unsigned char num2 = 0xa8; /* Same as binary 10101000 in hex */

  unsigned long result = (num1 << 8) | num2;
  printf("0x%x\n", result);
}
```
Vous pouvez le compiler avec gcc -o test test.c, qui sort cette lors de l'exécution à: 0xc0a8 (c'est le même que 1100000010101000).

Si vous attribuez le nombre de pointeurs comme vous l'avez fait, vous obtiendrez probablement un "segmentation fault" ou "violation d'accès" lorsque vous essayez de déréférencer avec *pointer et *pointer2, parce que cela signifie que vous souhaitez que la valeur stockée à l'adresse de pointeur, ce qui, probablement, ne réside pas dans votre programme de l'espace d'adresse.

Depuis result est un long (32 bits), il peut certainement retenir votre 16 bits, mais num1 et num2 être unsigned char, de sorte que lorsque vous shift gauche et OU leur il ne veut pas rendre la chose de négatif en un nombre binaire signé la plus à gauche du jeu de bit à 1 signifie qu'il est un nombre négatif, donc si vous utilisez un simple char au lieu de cela il va signer étendre le résultat sur 32 bits, donc il reste négative: 0xffffffa8

InformationsquelleAutor Claudio
0

D'abord seulement affecter un certain nombre de pointeur comme
unsigned long pointer3 = *pointer;
après cette maj gauche cette pointer3 16 fois.
pinter3=pointer3<<16;
pointer3=pointer3|*pointer2;

cela fonctionne je pense que
- Malheureusement, cela n'aide pas du tout, le résultat net est la même que dans la question.
InformationsquelleAutor umang2203

Il n'y a pas besoin de passer par 16 comme vous le faites dans

unsigned long pointer3 = (*pointer << 16) | *pointer2;

pointeur ne doit être déplacé par 8.

Code suivant va réaliser ce que vous essayez de faire.

#include <stdio.h>
#include <string.h>

void print_binary(int num) {
    short rem[16] = {0};
    for (short i = 1; i <= 16; i++) {
        rem[16-i] = num%2;
        num = num >> 1;
    }
    for (short int i = 0; i < 16; i++) {
        printf("%d", rem[i]);
    }
    printf("\n");
}

int main (int argc, char* argv[]) {

    unsigned char num1 = 192;
    unsigned char num2 = 168;
    int num3 = 0;
    num3 = (num1 << 8) | num2;
    printf("first number: %d\n", num1);
    print_binary(num1);

    printf("second number: %d\n", num2);
    print_binary(num2);

    printf("The number is %d\n", num3);
    print_binary(num3);

    return 0;
}

InformationsquelleAutor vineet kapoor

-1

Celui-ci semble facile à comprendre)

 #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    using namespace std;



    int main()
    {
    int a = 32; //100000
    int b = 5; //101
    int step=0;
    int siz=0;
    while(1){
    if(pow(2,step) < b){
    step++;
    continue;
    }
    else{
    siz = step;
    break;
    }

    }
    a = a<<siz;
    a = a | b;
    cout<<a;
    }

Cette réponse est bâclée, incertaine et difficile à comprendre.

InformationsquelleAutor Mr. Hello_world

Vous devez vous connecter pour publier un commentaire.