Criar tipo de dado novo

[AMON-HÁ 0]

Olá,

 

Preciso guardar o número de um CPF, só não quero fazer isso usando vetor...

Não dá pra fazer usando um tipo de dado já existente, como o int... mesmo usando 'unsigned long int', no qual o valor máximo suportado é de 4294967295...

 

Eu queria então criar um tipo de dado novo, chamar, sei lá, de 'sint' (superint)...

um tipo com as caracteristicas do int (4 bytes), mas com 5 bytes já me servia...

 

E aí, como eu posso fazer isso?

[_Isis_ 202]

Use array de char ou array de int.

[AMON-HÁ 0]

Use array de char ou array de int.

 

Pois é, mas como eu disse, não quero usar vetor...

[_Isis_ 202]

E por que? É mais fácil (principalmente se você for iterar p/ validar o cpf e o zero à esquerda também deve aparecer) e não tem os problemas de underflow e overflow. Mesmo que você use um tipo inteiro enorme (long long), isso ainda vai existir.

você pode usar struct com 11 campos inteiros, mas é um canhão p/ nada, já que o limite de cada campo desses é mais de 2 bilhões e você só vai usar p/ representar um dígito de 0 a 9 e não consegue iterar dentro da struct.

[guidjos 65]

Já tentou usar long double? Se não, tem bibliotecas prontas que servem pra manipular números muito grandes (ordem de centenas a milhares de casas).

 

Não sei em que você vai aplicar seu código, mas se for na arquitetura x86 acho que long double usa 12 bytes... se for esse o caso, 2^96 é bem mais do que você precisa pra armazenar um CPF.

 

@_Isis_

Ele nunca teria problemas de underflow... só overflow. Tou errado?

[AMON-HÁ 0]

E por que? É mais fácil (principalmente se você for iterar p/ validar o cpf e o zero à esquerda também deve aparecer) e não tem os problemas de underflow e overflow. Mesmo que você use um tipo inteiro enorme (long long), isso ainda vai existir.

você pode usar struct com 11 campos inteiros, mas é um canhão p/ nada, já que o limite de cada campo desses é mais de 2 bilhões e você só vai usar p/ representar um dígito de 0 a 9 e não consegue iterar dentro da struct.

 

Não quero usar vetor porque terei que fazer um monte de equações com o número, e pra isso eu teria que criar um monte de operator (sobrecarga de operador)...

Não só quero facilitar minha vida, como também verificar se tem como criar um novo tipo de dado até para uso futuro em outras aplicações...

Não vou fazer calculo de digito verificador do CPF, por isso não tem a necessidade de vetor...

Outra coisa... como guidjos disse, só teria problemas de overflow, não de underflow...

 

Já tentou usar long double? Se não, tem bibliotecas prontas que servem pra manipular números muito grandes (ordem de centenas a milhares de casas).

 

Não sei em que você vai aplicar seu código, mas se for na arquitetura x86 acho que long double usa 12 bytes... se for esse o caso, 2^96 é bem mais do que você precisa pra armazenar um CPF.

 

@_Isis_

Ele nunca teria problemas de underflow... só overflow. Tou errado?

 

Opa começamos a chegar aonde eu quero...

Você sabe dizer que bibliotecas são essas?

Na verdade, escrevi esse tópico porque eu já tinha lido em algum lugar que tanto era possível criar um novo tipo de dado, como com características que sobrepusesse os limites do processador... ou seja, números bem grandes...

 

Outra coisa, long double não me serve. preciso que seja inteiro...

E mais, não sei quantos bytes o long double tem, mas acredito que 12 é impossível, pelo menos pra arquitetura x86... Já que, 2^32 dá 4294967296...

e processadores de 32 bits só suportam blocos de 4 bytes (4*8=32) por vez...

[guidjos 65]

Sim. Long double é uma estrutura de dados composta. Até por que, o tipo int já usa os 4 bytes (que tomariam os 32 bits do x86) :)

 

Preciso dar uma pesquisada, porque nunca trabalhei com nenhuma biblioteca deste tipo. Sei que um amigo meu desenvolveu uma dessas bibliotecas (ele tava fazendo testes com cálculo de valores enormes da seqüência de fibonacci, e precisava representar números com milhares de casas decimais), quando tiver um tempo falo com ele e depois respondo aqui, pode ser?

 

Enquanto isso, pesquise pra ver se já não tem alguma coisa bem difundida por aí. Qualquer coisa, me mande uma PM e eu te passo meu MSN pra gente conversar melhor.

 

Falou cara, até mais.

[_Isis_ 202]

Já tentou usar long double?

 

Porque long double? Dado que o CPF é fixo em 11 dígitos, com unsgined long long dá perfeitamente p/ acomodar um CPF no intervalo de 0 a 18,446,744,073,709,551,61, sem dividir os bits como um double (e você nunca vai usar a parte fracionária por causa do problema de representação de certos números).

 

Ele nunca teria problemas de underflow... só overflow. Tou errado?

 

Você pode conhecer underflow só de FP, mas ele existe em inteiros também. Se você compilar um programa com INT_MIN - 1 e com os warnings (all e extra) habilitados, vai receber uma mensagem falando sobre overflow na operaçãoo.

 

http://blog.moryton....rflow-when.html

http://weblogs.asp.net/dvravikanth/archive/2008/03/10/integer-overflow-amp-underflow-revisited.aspx

 

Também, existem vários bugs reportados cujo erro é integer underflow.

 

Não quero usar vetor porque terei que fazer um monte de equações com o número, e pra isso eu teria que criar um monte de operator (sobrecarga de operador).

 

Então você está usando C++... Dependendo do que você escolher p/ representar o CPF, nem é necessário fazer sobrecarga de operadores. O valarray suporta slicing, filtragem por máscara (exemplo: listar somente partes dos CPFs) e se duvidar, ainda dá p/ usar todos os métodos do header algorithms. Tem o header utility também, que pode ser usado p/ "desacoplar" a parte à esquerda dos dígitos de verificação.

[AMON-HÁ 0]

Já tentou usar long double?

Porque long double? Dado que o CPF é fixo em 11 dígitos, com unsgined long long dá perfeitamente p/ acomodar um CPF no intervalo de 0 a 18,446,744,073,709,551,61, sem dividir os bits como um double (e você nunca vai usar a parte fracionária por causa do problema de representação de certos números).

 

Ele nunca teria problemas de underflow... só overflow. Tou errado?

Você pode conhecer underflow só de FP, mas ele existe em inteiros também. Se você compilar um programa com INT_MIN - 1 e com os warnings (all e extra) habilitados, vai receber uma mensagem falando sobre overflow na operaçãoo.

 

http://blog.moryton....rflow-when.html

http://weblogs.asp.net/dvravikanth/archive/2008/03/10/integer-overflow-amp-underflow-revisited.aspx

 

Também, existem vários bugs reportados cujo erro é integer underflow.

 

Não quero usar vetor porque terei que fazer um monte de equações com o número, e pra isso eu teria que criar um monte de operator (sobrecarga de operador).

Então você está usando C++... Dependendo do que você escolher p/ representar o CPF, nem é necessário fazer sobrecarga de operadores. O valarray suporta slicing, filtragem por máscara (exemplo: listar somente partes dos CPFs) e se duvidar, ainda dá p/ usar todos os métodos do header algorithms. Tem o header utility também, que pode ser usado p/ "desacoplar" a parte à esquerda dos dígitos de verificação.

 

Usei long long int... deu certo!

Tem até funções de biblioteca padrão pra manipular esse tipo de dado...

Nem sabia que podia usar assim...

 

Você sabe me dizer como é feito as operações com esse tipo de dado no processador?

Acredito que o dado é dividido, já que o número é grande pra um processador de 32 bits...

[_Isis_ 202]

O long long é dividido entre o $eax e o $edx.

 

#include <limits.h>
#include <stdio.h>
int p() {
int a = INT_MAX;
return a;
}

int main() {
printf("%d\n",p());
return 0;
}

 

.file	"t.c"
.intel_syntax noprefix
.text
.globl p
.type	p, @function
p:
push	ebp
mov	ebp, esp
sub	esp, 16
mov	DWORD PTR [ebp-4], 2147483647
mov	eax, DWORD PTR [ebp-4]
leave
ret
.size	p, .-p
.section	.rodata
.LC0:
.string	"%d\n"
.text
.globl main
.type	main, @function
main:
lea	ecx, [esp+4]
and	esp, -16
push	DWORD PTR [ecx-4]
push	ebp
mov	ebp, esp
push	ecx
sub	esp, 20
call	p
mov	DWORD PTR [esp+4], eax
mov	DWORD PTR [esp], OFFSET FLAT:.LC0
call	printf
mov	eax, 0
add	esp, 20
pop	ecx
pop	ebp
lea	esp, [ecx-4]
ret
.size	main, .-main
.ident	"GCC: (SUSE Linux) 4.3.2 [gcc-4_3-branch revision 141291]"
.section	.comment.SUSE.OPTs,"MS",@progbits,1
.ascii	"ospwg"
.section	.note.GNU-stack,"",@progbits

 

#include <stdio.h>
#include <limits.h>
long long p() {
long long int a = LLONG_MAX;
return a;
}
int main() {
printf("%lld\n",p());
return 0;
}

 

.file	"q.c"
.intel_syntax noprefix
.text
.globl p
.type	p, @function
p:
push	ebp
mov	ebp, esp
sub	esp, 16
mov	DWORD PTR [ebp-8], -1
mov	DWORD PTR [ebp-4], 2147483647
mov	eax, DWORD PTR [ebp-8]
mov	edx, DWORD PTR [ebp-4]
leave
ret
.size	p, .-p
.section	.rodata
.LC0:
.string	"%lld\n"
.text
.globl main
.type	main, @function
main:
lea	ecx, [esp+4]
and	esp, -16
push	DWORD PTR [ecx-4]
push	ebp
mov	ebp, esp
push	ecx
sub	esp, 20
call	p
mov	DWORD PTR [esp+4], eax
mov	DWORD PTR [esp+8], edx
mov	DWORD PTR [esp], OFFSET FLAT:.LC0
call	printf
mov	eax, 0
add	esp, 20
pop	ecx
pop	ebp
lea	esp, [ecx-4]
ret
.size	main, .-main
.ident	"GCC: (SUSE Linux) 4.3.2 [gcc-4_3-branch revision 141291]"
.section	.comment.SUSE.OPTs,"MS",@progbits,1
.ascii	"ospwg"
.section	.note.GNU-stack,"",@progbits

 

 

http://www.swansontec.com/sregisters.html