tamanho do int

[gRoOvE 0]

diz nas apostilas que o tipo int eh igual sempre ao barramento do processador, aqui tenho um processador 64bits porém com OS 32bits.

se fosse 16bits seria 2elevado16 = 65536, que seria posições diferentes sem sinal

como uso OS de 32, entao seria 2elevado32 = 4294967296 posições diferentes sem sina

é isso mesmo ??

 

queria saber pq o compilador ou processador, nao sei...aceitam somente 10 digitos no tipo int ?? depois que passa disso, fica td negativo, td errado os numeros

acredito que seja o compilador, pois o visual C++ resolve bem ate 10 digitos e o Portugol (compilador pra portugues estruturado) aguenta só 7 "/

[Evandrobm 0]

cara se não me engano tu pode usar a função sizeof, não sei de qual biblioteca, mas deve ser uma daquelas básicas que eu disse no outro tópico

 

...
int tamanho;
tamanho=sizeof(int);
printf("%d",tamanho);
...

Acho que assim vai dar, talvez tenha algum errinho, mas acho que é isso, não sou acostumado a usar esse função XD

[_Isis_ 202]

Tá tudo no limits.h

Acho até que dá pra alterar os valores.

 

/* We don't have #include_next.
  Define ANSI <limits.h> for standard 32-bit words.  */

/* These assume 8-bit `char's, 16-bit `short int's,
  and 32-bit `int's and `long int's.  */

/* Number of bits in a `char'.  */
#  define CHAR_BIT	  8

/* Minimum and maximum values a `signed char' can hold.  */
#  define SCHAR_MIN	 (-128)
#  define SCHAR_MAX	 127

/* Maximum value an `unsigned char' can hold.  (Minimum is 0.)  */
#  define UCHAR_MAX	 255

/* Minimum and maximum values a `char' can hold.  */
#  ifdef __CHAR_UNSIGNED__
#   define CHAR_MIN	 0
#   define CHAR_MAX	 UCHAR_MAX
#  else
#   define CHAR_MIN	 SCHAR_MIN
#   define CHAR_MAX	 SCHAR_MAX
#  endif

/* Minimum and maximum values a `signed short int' can hold.  */
#  define SHRT_MIN	  (-32768)
#  define SHRT_MAX	  32767

/* Maximum value an `unsigned short int' can hold.  (Minimum is 0.)  */
#  define USHRT_MAX	 65535

[gRoOvE 0]

Isis, poderia me explicar o que é essa biblioteca? Seria uma biblioteca, onde são guardados todos os valores constantes de int, char, float, etc?

Estou tentando entender esse exercício <- http://forum.imasters.com.br/index.php?showtopic=258483

 

#include <stdio.h>
#include <limits.h>
#define FLAG INT_MIN
#define SIZE 5
int main(void) {
  int matriz[SIZE][SIZE];
  int i,j;

  /* Leitura */
  for(i=0;i<SIZE;i++)
	for(j=0;j<SIZE;j++) {
		printf("\nDigite o valor de matriz[%d][%d]:",i,j);
		LOOP_ERRO:
		  scanf("%d",&matriz[i][j]);
		  if (matriz[i][j] == FLAG) {
			 puts("\nERRO: digite outro numero");
			 goto LOOP_ERRO;
		  }
	}

[_Isis_ 202]

http://en.wikipedia.org/wiki/Limits.h

[gRoOvE 0]

nesse caso:

#define FLAG INT_MIN

a constante FLAG recebe –2,147,483,648 então?

Pra te falar a verdade, não intendi o uso dessa FLAG ai "/

[_Isis_ 202]

Cara,eh so pra você marcar o que ja foi contado na matriz.

[gRoOvE 0]

ta, mais que valor vai ser esse INT_MIN? Por que antes de ele entrar uma primeira vez naquele if, o FLAG ta recebendo o valor desse INT_MIN

[_Isis_ 202]

Eu estou definindo uma macro.Dá quase na mesma você fazer const int FLAG = INT_MIN como global, a não ser pela alocação de espaço. O valor de INT_MIN tá em limits.h. Não complique.

[gRoOvE 0]

isso não é uma constante? Seria macro se tivesse argumento, certo? O valor de INT_MIN é ≤–32,767?

 

if (matriz[i][j] == FLAG) {

nao consegui entender oq esse if faz, sinceramente "/

[_Isis_ 202]

Não. Constante é uma variável declarada com o modificador const. Qualquer coisa definida com #define é macro (apenas substitui um texto encontrado no programa por determinada coisa. Nem espaço alocado tem.Já falei isso)

 

O que tem de grego nesse if? É uma comparação. Se o conteudo da posicao da matriz for igual ao valor mínimo de inteiro possivel de ser representado na máquina,ele vai fazer alguma coisa.Só isso. Leia o limits.h,por favor.

 

# define INT_MIN (-INT_MAX - 1)

# define INT_MAX 2147483647

 

INT_MIN = -2147483648

[gRoOvE 0]

Consegui entender o if. Mas qual o objetivo de comparar o conteudo do elemento IGUAL a INT_MIN? Achei que fizesse isso pra nao deixar entrar com valor menor que o suportado. Outra coisa, tentei alterar lá pra:

 

if (matriz[i][j] <= FLAG) {

e entrei com valor: -9999999999

retorna verdadeiro, pq?

[_Isis_ 202]

Deus do ceu... To falando grego...So pode. Quando falei em FLAG é pra marcar COM A FLAG os numeros REPETIDOS, pq se nao fizer isso vai CONTAR NOVAMENTE o que ja foi visto e sempre vai dar NUMERO MENOR DO QUE O VERDADEIRO porque comeca de i+1.

 

 

Certeza que não dá overflow?

 

#include <stdio.h>
#include <limits.h>
#define FLAG INT_MIN
int main(void) {
 int N = -9 999 999 999;
 printf("%d\n",FLAG);
 printf("%d\n",N);
  if (N <= FLAG)
  puts("Y");
 return 0;
}

 

leitura.c: In function ‘main’:

leitura.c:5: warning: integer constant is too large for ‘long’ type

leitura.c:5: warning: overflow in implicit constant conversion

 

isis@linux-0khy:~/src> ./a.out

-2147483648

-1410065407

[gRoOvE 0]

Deus do ceu... To falando grego...So pode. Quando falei em FLAG é pra marcar COM A FLAG os numeros REPETIDOS, pq se nao fizer isso vai CONTAR NOVAMENTE o que ja foi visto e sempre vai dar NUMERO MENOR DO QUE O VERDADEIRO porque comeca de i+1.

O porque da FLAG eu entendi, não tinha entendido o pq desse if na leitura. Da overflow sim, sou meio burro, malz. Nesse caso o que teria que ser feito pro usuário não entrar com -9999999999, onde ia passar do tamanho limite do int e transformar esse numero em lixo.

 

essas informações, conseguiu debugando? Se sim, onde?

[_Isis_ 202]

não tem o que fazer pro usuario nao entrar com esse numero.A partir do momento que você lê já perdeu bits.

 

Edit: Em C ISO é um parto mas em C++ dá pra fazer assim:

 

#include <iostream>
#include <string>
#include <sstream>
#include <limits.h>
using namespace std;
int main(void) {
 string IN_STR;
 cout <<  "leitura:";
 cin >> IN_STR;

 ostringstream OUT;
 OUT << INT_MIN;
 string LIMITE_MINIMO = OUT.str();
 OUT.clear();

 OUT << INT_MAX;
 string LIMITE_MAXIMO = OUT.str();

 /* Overflow */
 if (IN_STR.compare(LIMITE_MINIMO) < 0 || IN_STR.compare(LIMITE_MAXIMO) > 0)
 return 1;

}

[gRoOvE 0]

hmm, deu pra entender a lógica