My life in English

Aiming to be a Canadian citizen.

Posts Tagged ‘banco porcaria’

Variáveis e identificadores – Parte II

Posted by fabianovasconcelos on 25 de August de 2010

Salve, galerinha do país em que o presidente deu moral ao Banco Bradesco!

Aos que acreditam piamente que eleição é a solução dos nossos problemas, notem que alguns termos são um link para páginas externas. Clique neles se necessitar de alguma informação complementar a respeito.

Tá mais perdido que surdo em bingo? Pois você veio parar num curso on line de C/C++! Clica aqui pra ver o índice!

Aê, povo nerd!

Nem vou tentar me explicar, porque seria em vão. Sei que estive ausente por muito tempo, mas estou aqui de novo. Muitos abestados estudantes de programação me escreveram, me pediram em casamento, falaram que tava muito bom e que eu não parasse que eles tavam quase gozando conseguindo entender C/C++. Sendo assim, atendendo a pedidos, aqui estou eu, de novo, pronto para ensebar um monte de gente ajudar a humanidade a progredir, sendo que eu não sei porra nenhuma de nada de programação meus vastos conhecimentos de C/C++ sempre estarão a disposição de vocês, meus amigos e companheiros! Fico muito feliz em saber que tem gente que dá valor ao meu trabalho e faço isso com o maior prazer!

Muito bem, fieis leitores e amigos, vocês lembram onde paramos a um milênio alguns dias atrás? Temos que continuar falando de variáveis e identificadores. Algumas perguntas que eu fiz no post anterior precisam ser respondidas e outras precisam ser feitas.

A primeira pergunta que eu lancei, foi: o que nós faremos quando precisarmos armazenar um valor maior que o tipo suporta? Por exemplo, no caso de variável do tipo int o que nós faríamos se ele precisasse receber um valor maior que 32.767 ou menor que -32.767 ou se a ele fosse atribuido, por acidente, um valor fora dessa faixa? Bom, para isso existem alguns truques.
Antes de mais nada, caro aspirante a programador, esteja certo que aquela variável que você declarou não vai receber um valor fora do intervalo que ela suporta. Isso eu já falei anteriormente. Não tente armazenar o número de átomos de um tijolo numa variável int. Certamente vai dar merda.

Não tente armazenar mais que suporta o recipiente. Respeite os limites de cada coisa.

O primeiro dos segredos que eu tenho a lhes contar: existem modificadores de tipos!!! Sim, os tipos em C e principalmente em C++ não são nada fixos e você pode começar, de já, a modificar os tipos básicos mencionados anteriormente! E se você ligar agora, eu te darei de presente além dos modificadores de tipos, uma lindíssima almofada absorvedora de gazes intestinais!

Se prepare que eu vou dar a lista de modificadores de tipo AGORA:

signed
unsigned
long
short

Entendeu alguma coisa, caro molusco? Não? Vamos explicar, então:

unsigned

Colocado antes de um tipo, como na declaração

unsigned int meu_nome;

diz ao compilador: “Por favor, senhor compilador, eu não quero que a faixa deste int comece em -32.767 e termine em 32.767. Em vez disso, comece do 0 (zero) e extenda o alcance desta variável até 65.535 (o dobro de 32.767)”.
Unsigned, quer dizer sem sinal. Na prática, a variável int funcionaria com números positivos, apenas. A tentativa de armazenar números negativos numa variável int, modificada dessa forma, poderia – ou não – resultar em erro. Para manter seu código compatível com tudo quanto for de máquina ou plataforma, é favor não cair na besteira de escrever código de maneira não padrão. Pensem nos outros infelizes que terão que desfazer uma possível merda que você pode fazer. Se o código compila e roda legalzim na tua casa, ele pode não compilar e nem rodar legalzim na máquina do teu vizinho ou cliente.
Prosseguindo, em compensação, o que faltou de lado, tem que sobrar do outro. Em vez da variável só chegar até 32.767, ela será extendida isonomicamente até 65.535 e nem um centavo a mais (em modo padrão).

Quer ver só uma coisa? Na minha máquina o código abaixo compila e roda sem problemas.

01 #include <stdio.h>
02
03 int main ()
04 {
05     unsigned int teste;
06     teste = -1;
07     printf(“%i \n”, teste);
08 }
[Mesmo que você não esteja entendendo 100% do que está escrito nesse código, olhe pra ele e comece a se familiarizar com a linguagem.]

Na linha 05, a variável teste é declarada como sendo um inteiro sem sinal.
Na linha 06, eu atribuo o valor -1 a essa variável.
Na linha 07, o conteúdo da variável teste é impresso em tela.
Na minha máquina esse código compila e roda sem besteira nenhuma. Imprime -1, mas esse estilo de programação não é padrão e pode ser que, compilado em outras máquinas ou para outros dispositivos ou processadores mais fraquinhos (por exemplo smartphones), o programa não vá funcionar a contento.

01 #include <stdio.h>
02
03 int main ()
04 {
05    unsigned int teste;
06    teste = 65535;
07    teste++;
08    printf(“%i \n”, teste);
09    teste=0;
10    teste–;
11    printf(“%i \n”, teste);
12 }

[Um pouquinho mais complexo…]

Nesse código de dez linhas, idêntico ao anterior, perceba, meu caro pupilo, que na linha 06 eu atribuo o valor 65.535 a variável teste. A linha seguinte incrementa (soma mais 1) ao valaor que está armazenado em teste. Já a linha 08 imprime na tela o valor de teste, que é 65.536.
Em seguida, a linha 09, por sua vez, atribui zero ao valor de teste. A linha 10 decrementa (diminui de 1) o valor de teste. No final das contas a linha 11 imprime em tela -1, que é o resultado da operação.
Mais uma vez eu ressalto: nada desse comportamento é padrão! Não confie que isso vai sempre acontecer. Confie apenas na documentação oficial. E não se fala mais nisso!

signed

Este modificador não serve pra nada no caso de inteiros. Por default, a variável declarada int já é com sinal (signed quer dizer sinalizada). Onde o modificador signed faria diferença seria um caso especial do tipo char, em implementações em que esse tipo, por padrão, não tem sinal.

long

Quer armazenar o número de cocotas que você disse pra todo mundo que catou no último carnaval? Use o modificador long! Esse é o cara! Ele dá uma turbinada aí no teu int. E que turbinada! A faixa do int pula de 16 bits (-32.767 a 32.767) para 32 bits (-2.147.483.647 a 2.147.483.647). Alguns compiladores já colocam um long automaticamente, sem você escrever, nas variáveis int do teu código. É o meu caso. Taí a explicação porque os códigos anteriores não deram pau na minha máquina, rodaram sem besteira. Mas a partir do momento em que eu modifiquei o código para:


01 #include <stdio.h>
02
03 int main ()
04 {
05     unsigned int teste;
06     teste = 2147483647;
07     teste++;
08     printf(“%i \n”, teste);
09 }

na própria hora em que eu, na linha 06, declaro a variável teste com um valor no limite da faixa do long, qualquer incremento que eu fizer, e é feito na linha 07, vai me causar um erro real em tempo de execução. Pelo menos na minha máquina o valor que foi impresso foi -2147483648.

Note que, no meu caso, não foi preciso que eu declarasse a variável como long para que ela se comportasse como tal (NÃO CONTA COM ISSO NUNCA, PORRRAAAAAAAAA!!!).

Um exemplo de como ficaria uma variável declarada como int long seria:

long int teste;

ou simplesmente

long teste;

também funciona.

short

“Mas, Fabiano, eu lhe empresto a minha irmã se você me disser como eu forço o compilador a usar o int de maneira padrão!”
Pois não, caro amigo, já que a tua irmã é muito gostosa você está insistindo tanto, e eu odeio gente insistente, eu vou então dar a dica de como forçar o compilador a trabalhar de maneira padrão com o tipo.
Se você lascar short em vez de long, como modificador, você vai assegurar que int terá mesmo 16 bits de largura. No código abaixo, por exemplo:

01 #include <stdio.h>
02
03 int main ()
04 {
05     unsigned short int teste;
06     teste = 65535;
07     teste++;
08     printf(“%i \n”, teste);
09     teste–;
11     printf(“%i \n”, teste);
12 }

A linha 05 declara a variável teste como sendo unsigned (sem sinal), short (pequena) e int (inteira). Logo em seguida, na linha 06, a variável teste é inicializada, ou seja, atribuida um valor inicial a ela, que seria 65.535 (se o “meu fi” não tá alternando constantemente a tela do navegador entre o RedTube e este blog, vai notar que o valor inicial de teste é o limite oficial de um inteiro sem sinal). Pois bem. Na linha 07 a variável teste é incrementada de um. Na linha 08 o valor de teste é impresso na tela e violà, o resultado não é 65.536 e sim, 0! Isso mesmo, ZERO! Isso porque o modificador short forçou o compilador a tratar a variável de maneira padrão.
Continuando, na linha 09, o valor de teste é decrementado de 1 (ou seja, 0 menos 1) e mais uma vez o compilador vai forçar o programa a se comportar de maneira padrão: imprime 65.535 quando, na linha 11, é ordenado.

Uso Geral

Bom, mas você deve estar se perguntando: “Ah! Fabiano, mas os modificadores só servem pra modificar tipos int? E quanto ao double, float, char e void?”
Well, caros, peixinhos, lógico que os quatro modificadores aqui mencionados servem também para modificar outros tipos, porém atente:

1. Apesar de long char e short char serem declarações válidas, não invente moda. char é um tipo caractere e é bom que seja usado exclusivamente para tal. O uso desse tipo de declaração é uma implementação mais avançada e eu optei por não cobrir aqui. Certamente quando você for prático em C/C++ vai notar de cara para que usá-lo. Aliás, ao fim deste post, alguns providos de mais massa cinzenta que outros vão sacar qual é o babado;
2. O modificador long pode ser aplicado a double, mas o padrão C ANSI elimina o uso de long float, porque ele viraria um double limpo e seco, portanto, sem necessidade;
3. Existem implementações – eu não vou mentir que conheço porque não conheço, morro de medo de ir pro inferno – em que a declaração signed char é nessessária. Existem implementações em que char, por padrão, não tem sinal. Um dia, se quando você for programador profissional, se você se deparar com esse tipo de implementação, use signed para modificar char;
4. Procure não usar unsigned em ponto flutuante (double ou float). Algumas implementações podem torcer o nariz para esse tipo de declaração e podem avacalhar com o teu código. Esse tipo de declaração não é prevista pelo C ANSI, portanto pode dar certo na sua máquina e errado na máquina do teu cliente;
5. void, apesar de ser um tipo, como eu já disse anteriormente, não serve para declarar nenhuma variável, pois ela representa a ausência de valor.

Considerações finais

É bom forçar o uso de long quando se quiser garantir que a variável vai alocar um valor muito alto, por exemplo o valor da dívida externa do Brasil e short quando se quiser economizar memória e alocar valores baixos, como o número de leitores diários deste blog.
Agora que vocês estão craques (espero) nessa coisa de modificadores long, short, signed e unsigned, eu deixo-vos uma tabelinha padrão ANSI pra que vocês possam consultar no caso de dúvidas:

...

E este tema ainda não parou! Teremos a parte III deste post, mas, antes, vamos dar uma pausa para vermos a programação propriamente dita em C: as funções! Depois disso retomaremos o tema Variáveis e identificadores, Parte III.

Um grande abraço a todos vocês, fiquem com Deus, obrigado pelo carinho, rezem por mim, votem nulo e até a pŕoxima! 😉


Dois argentinos chegam a São Paulo, sem grana, e ai um diz pro outro: Vamos nos separar para pedir dinheiro e ao final do dia nos reunimos para ver quanto cada um de nós arrumou.
O outro topa e então cada um vai para o seu lado.
Já bem de noitinha se encontram de novo e um pergunta para o outro: Quanto você conseguiu?
– 10 reais.
– E como fez?
Fui ao parque e pintei um cartaz: ‘NO TENGO TRABAJO, TENGO 3 HIJOS QUE ATENDER, POR FAVOR, LOS RUEGO! NECESITO AYUDA!’.
E você, quanto ganhou? Perguntou o que ganhou R$ 10,00
– Ganhei 18.970,00 reais!
– Madre mia! Como você fez para conseguir tanto?
Escrevi um cartaz assim: ‘FALTA 1 REAL PARA VOLVER A LA ARGENTINA’.


Copyright 2009, 2010 (C) Fabiano Bezerra de Vasconcelos – Todos os direitos reservados.

Advertisements

Posted in C/C++ | Tagged: , , , , , , , , , , , , , , , , , | 4 Comments »