Inteiro de 8 bits

1. Inteiro de 8 bits

Leonardo dos santos prado
leonardosprado

(usa Ubuntu)

Enviado em 18/03/2016 - 02:19h

Estou declarando um inteiro de 8 bits, mas ele só imprime o primeiro algarismo do numero, e 8 bits deveria ir de 0 a 255. Porque está só um algarismo do numero inteiro ?
o codigo ta assim:

#include "stdint.h"
#include <iostream>
#include <locale.h>
using namespace std;
int main(){
int8_t i;
cout<<"\nDigite número: ";
cin>>i;
cout<<endl;
cout<<"\n Número digitado : " <<i<<endl;

return 0;
}



  


2. Re: Inteiro de 8 bits

Pedro
pehecoro

(usa Arch Linux)

Enviado em 18/03/2016 - 09:53h

Bom dia,

Bem, acredito que vá de -128 a 127 por padrão(signed), se for sem sinal (unsigned) ira de 0 a 255.
Então no caso seria uint8_t.


3. Re: Inteiro de 8 bits

M.
XProtoman

(usa Fedora)

Enviado em 18/03/2016 - 14:32h

pehecoro escreveu:

Bom dia,

Bem, acredito que vá de -128 a 127 por padrão(signed), se for sem sinal (unsigned) ira de 0 a 255.
Então no caso seria uint8_t.

Completando a dica do pehecoro, na hora de imprimir faça uma conversão para int que deve dar certo:
cout<<"\n Número digitado : " << (int)i <<endl; 


Boa sorte, que o código esteja com você!


4. Re: Inteiro de 8 bits

Paulo
paulo1205

(usa Ubuntu)

Enviado em 19/03/2016 - 19:31h

Eis uma das Infelicidades herdadas do C.

Nos nossos PCs, uint8_t é um typedef (ou equivalente) com mais ou menos o seguinte aspecto:

typedef unsigned char uint8_t; 


Em outras palavras, dá exatamente na mesma declarar uma variável qualquer como uint8_t ou como unsigned char. E as operações de entrada e saída formatada em streams tratam dados dos tipos char, signed char e unsigned char do mesmo modo, ou seja, como representando caracteres, e não inteiros de oito bits.

Uma das soluções já foi apresentada: uma conversão estática de tipo para inteiro de maior precisão na hora da impressão. Contudo, essa solução só resolve o problema na hora de imprimir, não de ler. E cabe mais uma ressalva: muita gente -- inclusive eu -- desaconselha o uso de conversão de tipos ao estilo de C; é melhor você fazer conversão ao estilo construtor de conversão de tipo (e.g. “int(some_uint8_var)”) ou conversão estática explícita (e.g. “static_cast<int>(some_uint8_var)”).

Outra abordagem é usar uma classe envelopadora de baixo custo (possivelmente custo zero, com um bom compilador) que tire dos seus bytes a característica original de representar caracteres.

class my_uint8_t {
// I/O operators
friend istream &operator >>(istream &, my_uint8_t &);
friend ostream &operator <<(ostream &, const my_uint8_t &);

private:
uint8_t value;

public:
// Template for type-conversion constructors
template <typename T=unsigned> my_uint8_t(const T &v=T()):
value(static_cast<uint8_t>(v))
{ }

// Type conversion to other types
// Note that implicit conversion is allowed only to unsigned int;
// direct conversion to other types (i.e. not going through conversion
// to unsigned int first) must be explicit. A good side-effect is that
// we don't need to write lots of binary operator functions (e.g. for
// arithmetic and logical operations).
operator unsigned() const { return value; }
template <typename T> explicit operator T() const { return T(value); }

// Unary operators
my_uint8_t operator +() { return *this; }
int operator -() { return -int(value); }
bool operator !() { return !value; }
my_uint8_t operator ~() { return ~value; }
my_uint8_t &operator ++() { ++value; return *this; }
my_uint8_t operator ++(int) { auto temp=value; ++value; return temp; }
my_uint8_t &operator --() { --value; return *this; }
my_uint8_t operator --(int) { auto temp=value; --value; return temp; }

// Assignment operators
template <typename T> my_uint8_t &operator *=(const T &other){
value*=other;
return *this;
}

template <typename T> my_uint8_t &operator /=(const T &other){
value/=other;
return *this;
}

template <typename T> my_uint8_t &operator %=(const T &other){
value%=other;
return *this;
}

template <typename T> my_uint8_t &operator +=(const T &other){
value+=other;
return *this;
}

template <typename T> my_uint8_t &operator -=(const T &other){
value-=other;
return *this;
}

template <typename T> my_uint8_t &operator &=(const T &other){
value&=other;
return *this;
}

template <typename T> my_uint8_t &operator |=(const T &other){
value|=other;
return *this;
}

template <typename T> my_uint8_t &operator ^=(const T &other){
value^=other;
return *this;
}

template <typename T> my_uint8_t &operator <<=(const T &other){
value<<=other;
return *this;
}

template <typename T> my_uint8_t &operator >>=(const T &other){
value>>=other;
return *this;
}
};

istream &operator >>(istream &is, my_uint8_t &var){
unsigned u;
is >> u;
var.value=u;
return is;
}

ostream &operator <<(ostream &os, const my_uint8_t &var){
return os << unsigned(var.value);
}



5. Re: Inteiro de 8 bits

Leonardo dos santos prado
leonardosprado

(usa Ubuntu)

Enviado em 21/03/2016 - 16:40h

Então paulo1205, percebi que estava implementado na biblioteca <cstdint> desta forma mesmo que você falou, int8_t mesmo que char, me ajudou bastante aqui, obrigado pela força ai, bela resposta com a classe, gostei bastante, vou dar uma olhada mais a fundo nela com certeza. Valeu.






Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts