Ponteiros

[rafaelrrf]

Viventes,

 

Se eu tenho um vetor char de 10 posições: char v[10]. E um inteiro x com valor 10: int x = 10. Como eu poderia passar para o vetor "v" o valor inteiro em "x" usando ponteiros?

[Midori]

Apesar de ser possível atribuir um valor inteiro a char, essa pergunta não faz muito sentido.

Primeiro, para trabalhar com ponteiro você deve criar uma variável ponteiro com o operador '*'. E essa variável é que vai apontar para o endereço de outra.

Agora se você quiser converter int para vetor de char, há funções específicas para isso.

[rafaelrrf]

Não quero usar nenhum tipo de conversão como sprintf etc.

 

O que eu queria fazer era atribuir o valor inteiro que tem 4 bytes no meu sistema, para o vetor char, ocupando apenas 4 bytes no mesmo, seria possível?

[Ansi C]

Não quero usar nenhum tipo de conversão como sprintf etc.

 

O que eu queria fazer era atribuir o valor inteiro que tem 4 bytes no meu sistema, para o vetor char, ocupando apenas 4 bytes no mesmo, seria possível?

Hey'!' @rafaelrrf

Sim, use 'casting'

 

Ilustração:

   int x = 10;   char int32_b[4];   *(int*)int32_b = x;   printf( "show int32_b: = %d\n", *(int*)int32_b );

[Midori]

Agora vi que você alterou o código no printf.

Antes estava sendo tratado como 1byte

[Ansi C]

@olliver.soul

 

Sim-sim , havia esquecido de aplicar o cast.

 

 

 

 

 

[rafaelrrf]

Mas em quais posições do array eu estou inserindo o numero 10 que é o valor de x? Como eu faria para inserir em outra posição? Pelo visto você esta convertendo o array para um inteiro com o cast, mas eu não quero me desfazer dele, preciso imprimir ele como uma string. Pois também tenho que inserir nesse array, caracteres, além dos valores inteiros. Seria possível?

[Ansi C]

@rafaelrrf

q?

O vetor continua sendo o que ele é, sua natureza apenas é modificada no instante do cast e nada mais.

Confesso que não entendi mais nada.

 

 

 

[rafaelrrf]

E porque não consigo imprimir o vetor char com %s?

 

Por exemplo:

printf( "show int32_b: = %s\n", int32_b );

 

Isso quer dizer que algo foi modificado...

[Ansi C]

@rafaelrrf

Se eu te entendi você quer imprimir 3 dígitos; Of couser!

Cada variável char cabe apenas um digito, isso mesmo 1 digito por char, pode ser letra ou numero.

Apenas um por char;

 

Assim sendo sua intenção é fazer

int x = 10;

ser convertido em strings (3 char) e armazenado no seu vetor de 4 char?

e por fim impresso pela função printf, contudo esta conversão sem auxilio da função sprintf?

[rafaelrrf]

Eu quero imprimir meu buffer. Sim, cada char ocupa 1 Byte. Vejamos um novo exemplo, tenho um vetor de char de 50 bytes : char buffer[50]. E uma variavel inteira: int x = 10. O que eu quero é passar apenas o valor de "x" para o "buffer", ou seja, como x tem 4 bytes, acredito que ocupara então 4 bytes no buffer. Sendo assim ocupará 4 posições no buffer, certo? Mas eu quero fazer essa passagem sem usar funções de conversão, como sprintf. O que eu quero é algo como passar o conteudo do endereço de cada byte do inteiro para o buffer usando ponteiros, mas n estou conseguindo fazer isso. Conseguiu entender?

[Ansi C]

Tudo bem para mim não faz o menor sentido.

Vamos observar o que pensa os outros membros.

[isrnick]

Não sei se isso é possível com ponteiros, mas acredito que você poderia obter isto usando deslocamentos de bits (se entendi corretamente o que você quer):

unsigned char v[10];unsigned long x = 10;v[0] = (x >> 24) & 0xFF;v[1] = (x >> 16) & 0xFF;v[2] = (x >> 8) & 0xFF;v[3] = x & 0xFF;

[Ansi C]

Logo imaginei que se tratava de algo que não tenho conhecimento, |AINDA|.

[rafaelrrf]

Legal @isrnick, parece que este é o caminho.

 

Afinal, pode me explicar o que está acontecendo no código?

 

Agradeço.

[isrnick]

Vamos escolher um número melhor pra explicar, como 66314.

 

66314 em binário com 32bits:

00000000000000010000001100001010

Dividindo em 4 bytes:

00000000 00000001 00000011 00001010

Se nós deslocarmos este número para a direita nestas quantidades de bits teremos:

>> 24 bits - 00000000 00000000 00000000 00000000>> 16 bits - 00000000 00000000 00000000 00000001>> 8 bits  - 00000000 00000000 00000001 00000011>> 0 bits  - 00000000 00000001 00000011 00001010

Mas observe nos 2 últimos casos que a parte que nos interessa são apenas os 8 bits mais a direita, entretanto existem números diferentes de 0 nas posições mais a esquerda destes bits, e precisamos eliminá-las antes de atribuir o valor ao char (que tem apenas 1 byte = 8 bits).

 

Para isso usamos o valor hexadecimal 0xff (=255) que em binário é igual a:

...000011111111 (8 bits mais a direita 1, e o restante 0)

E realizamos a operação booleana AND (que em C é simbolizado por &) entre o número deslocado e 0xff. Resultando que apenas os valores dos 8 bits mais a direita do número deslocado permanecem, e o restante a esquerda se torna 0, podendo então ser armazenado na variável char.

Resultado final:

>> 24 bits & 0xff - 00000000 00000000 00000000 00000000 = 00000000>> 16 bits & 0xff - 00000000 00000000 00000000 00000001 = 00000001>> 8 bits & 0xff  - 00000000 00000000 00000000 00000011 = 00000011>> 0 bits & 0xff  - 00000000 00000000 00000000 00001010 = 00001010

[Midori]

É interessante observar nesse tipo de operação de fazer 1 deslocamento para a direita é o mesmo que dividir por 2 e fazer 1 para a esquerda é o mesmo que multiplicar por dois.

Por exemplo;

y = x >> 1;

É o mesmo que

y = x / 2;

Agora quando se faz mais de 1 deslocamento, é preciso considerar a quantidade de deslocamentos na base 2 para ter o mesmo resultado com os operadores de multiplicação ou divisão, por exemplo.

y = x << 8;

É igual

y = x * 256; // já que 256 = 2^8

[Ansi C]

Hey'!' Feras!!!

 

Ajuda-me aqui a entender também o que fez essa tal de; Operação com Bits,

que ao meu entendimento nos resultados obtidos foram os mesmo.

Corrigi ai por favor se estive errando !!!!!!!!!!!

 

Ilustração:

int main( void ){   unsigned char v[10] = { 0 };   unsigned long x = 10;   v[0] = (x >> 24) & 0xFF;   v[1] = (x >> 16) & 0xFF;   v[2] = (x >> 8) & 0xFF;   v[3] = x & 0xFF;//"Prova dos nove" com ponteiros '!'   if ( *((unsigned long*)(v + 3)) == x ) printf( "SIM\n\n" );   else printf( "NAO\n\n" );return 0;   }

 

<A precisa mais não, entendi...>

Foi a maneira de copiar os 4 bytes de Um no Outro sequencialmente. 

[rafaelrrf]

Legal @isrnick, ajudou muito.

 

Resolvido.