My life in English

Aiming to be a Canadian citizen.

  • Like me!

Porque aprender C++ [Republicação]

Posted by fabianovasconcelos on 19 de September de 2010

Encontrei este texto nas minhas navegações da vida e achei interessante publicá-lo aqui. Leiam e reflitam!

Have fun!😀

Por: Basilio Miranda

Em primeiro lugar a linguagem C++ é uma linguagem de propósito geral que pode ser utilizada para qualquer finalidade e em qualquer plataforma.

Em segundo lugar a linguagem C++ é uma linguagem flexível, multiparadigma, seguindo nesse aspecto a tradição da linguagem C: o programador é quem escolhe a técnica de programação que deseja utilizar.

Além das técnicas que já eram suportadas pela linguagem C, C++ permite o uso de Orientação a Objetos e também de Programação Genérica, adaptando-se assim às diferentes necessidades requeridas pela criação de softwares.

Em situações críticas de escassez de memória e pequeno poder de processamento, o programador poderá adotar um estilo de mais baixo nível.

Em outros casos, poderá usar Orientação a Objetos, Programação Genérica ou uma combinação de ambas.

Em terceiro lugar a linguagem C++ é a linguagem de programação mais completa que já foi criada, sendo também uma linguagem altamente expressiva e lógica. E por isso muitas linguagens criadas posteriormente (Java e C#, por exemplo) são inspiradas em C++.

Quem aprende C++ terá assim grande facilidade de aprender novas linguagens, pois C++ criou novos paradigmas, sendo assim um modelo daquilo que esperamos de uma linguagem de programação de propósito geral.

Por isso mesmo é difícil, atualmente, conceber um curso de Ciências da Computação onde C++ estivesse ausente. Tanto pela linguagem em si, como também pela arquitetura de sua Biblioteca Padrão.

Ao contrário de algumas linguagens, C++ não cria restrições ao programador. É ele quem decide se quer correr riscos ou se quer maior segurança no seu código. Há poucas regras arbitrárias em C++ (como também na linguagem C). A maioria dos conceitos e regras de sintaxe são combináveis e aplicáveis por decorrência lógica.

Isto é positivo para o aprendizado de computação e é positivo também em situações em que é necessário extrair o máximo de uma determinada plataforma sem limites ou barreiras.

Evidentemente isso não significa que só se deva programar em C++.

Hoje um programador deve conhecer mais que uma linguagem pois, para determinadas aplicações, determinada linguagem pode ser melhor.

De um modo geral, podemos dizer que um programador que dificilmente terá problemas de emprego é aquele que conhece C++, Java e C# (e, eventualmente, alguma ferramenta adicional para gerar interfaces gráficas, além de linguagens de script como python, php ou asp).

Conhecendo C++, o programador tem uma base sólida em programação e, ao mesmo tempo, pode ser empregado em qualquer área (e não apenas gestão/banco de dados) e também em áreas onde só se pode usar a linguagem C (e elas existem) – pois ao aprender C++ ele também saberá programar em C, quando necessário.

Além disso aprenderá facilmente linguagens como Java , C# e mesmo certas linguagens de script, que herdam muito de C e/ou C++.

Por isso eu não afirmo: aprenda somente C++. Não se trata disso .

O que afirmo é que um bom programador é aquele que conhece C++ e, além disso, ao menos mais alguma linguagem.

Base sólida e versatilidade: eis a receita – e que na verdade é a receita de sempre.

Pois isso não é novidade. No passado era comum que uma equipe de programação contasse com muitos programadores Cobol e, além disso, com alguns programadores que além de Cobol também conhecessem Assembler.

O Cobol era mais simples e seguro, mas não podia resolver todos os problemas. Nas emergências e situações críticas era o programador que conhecia Assembler que era acionado.

Naturalmente esse profissional, mais completo e mais versátil, tinha melhor remuneração.

E é disso que estou falando. Por tudo isso, e por experiência própria, recomendo fortemente o aprendizado de C++.


Basilio Miranda

Perfil do Autor

Microsoft Certificate Professional em Visual C++. Certificado em Qt – cursou o Treinamento Oficial de Qt (Trolltech / Integrated Computer Solutions) em Boston – EUA. Programador de computadores desde 1974, quando trabalhou na Honeywell Bull (com Assembler Ge-120 e Cobol).
A partir de 1985 começou a trabalhar com microcomputadores nas linguagens Basic e Clipper, e 1988 começou a desenvolver Softwares na linguagem C. Participou da criação da Agit Informática em 1992, exercendo a função de programador. Em 1993, também como Instrutor de C (C++ a partir de 1994).
Atualmente é Diretor Técnico da Agit Informática, tendo como função principal a coordenação das áreas de Desenvolvimento e Treinamentos: em C e C++, Visual C++.NET para Windows, C++ para Linux e Qt – Biblioteca C++ Multiplataforma (Windows, Unix/Linux e MAC).

Fonte do Artigo – http://www.artigonal.com/tecnologia-artigos/por-que-aprender-c-620793.html

Posted in C/C++ | 1 Comment »

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.

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

Ainda tem dúvidas sobre a Claro 3G?

Posted by fabianovasconcelos on 16 de April de 2010

Para quem ainda não acredita que a CLARO não presta, acha que eu estava de brincadeira, exagero, birra, pirraça, capricho ou qualquer outra coisa do gênero, eu vou deixar aqui um post fixo pra postar as indignações de outras pessoas contra essa quadrilha liderada pelo Carlos Slim (atual homem mais rico do mundo). Quem avisa, amigo é! Mas, se conselho fosse bom, não se daria, se venderia!

Assistam os vídeos abaixo pra vocês terem uma idéia vaga do que é ser cliente da CLARO. Se quiserem ter uma experiência real, fiquem a vontade pra assinar o (des)serviço. Meus pêsames!

Read the rest of this entry »

Posted in Genéricos, mas de confiança! | Tagged: , , , , , | 1 Comment »

Tarifas de celular no Brasil estão entre as mais caras do mundo

Posted by fabianovasconcelos on 23 de March de 2010

Pesquisa da consultoria europeia Bernstein Research sobre as telecomunicações aponta o Brasil como um dos três países com as mais altas tarifas de telefonia celular do mundo, junto com a África do Sul e a Nigéria. O estudo levou em conta o Produto Interno Bruto (PIB) e os preços médios das tarifas em 17 países.

No Brasil os usuários dos serviços de telefonia móvel pagam em média US$ 0,24 o minuto, valor similar aos US$ 0,23 da Nigéria e os US$ 0,26 da África do Sul. Entre os países com tarifas mais baixas e com PIBs próximos ao do Brasil estão a Índia, onde a tarifa é de US$ 0,01, a Indonésia e a China onde o minuto custa em média US$ 0,03. Rússia, Egito e México têm tarifas de US$ 0,05 e se aproximam do valor praticado nos Estados Unidos. Entre os países europeus, a Espanha tem o minuto mais elevado do bloco com US$ 0,21. O Reino Unido pratica a tarifa mais baixa: US$ 0,14.

O grande vilão das altas tarifas, segundo Robin Bienenstock, analista sênior da Bernstein Research, é a taxa de interconexão ou VUM (Valor de Uso Móvel), tarifa que as operadoras pagam umas às outras pelo uso de suas redes. A analista destaca que em alguns países da Europa a taxa de interconexão foi quase zerada para incentivar o uso da telefonia celular. “Não dá para colocar a culpa apenas nos impostos. Outros países da América Latina e Caribe, como o Chile conseguiram reduzir em 50% o valor do VUM, afirma a analista. Para ela, não é surpresa que no Brasil 82% dos celulares são pré-pagos, ou seja, apenas recebem chamadas.

As operadoras celulares argumentam que manter o cliente pré-pago, que gasta em média R$ 8 por mês, não remunera o serviço e gera lucros mais baixos em países em desenvolvimento, afetando o valor do minuto. Essa distorção se reflete em lucros antes dos juros, impostos, depreciação e amortização (lajida) menores que a média mundial, diminuindo a capacidade de investimento na operação.

Elcio Zilli, vice-presidente de regulamentação da Vivo, aponta que o ciclo de investimentos em redes móveis, de dois a três anos, é muito mais rápido que a das redes fixas. Aqui 35% da receita das operadoras móveis vem da interconexão e mexer aí exigiria colocar algo no lugar, como a queda de impostos, sob pena de aumentar ainda mais as tarifas, diz o executivo.

Para a consultoria, a queda na taxa de interconexão em um primeiro momento poderá reduzir o lucro das operadoras móveis, mas incentivará o uso do celular para fazer chamadas e outros serviços, compensando a queda da receita.

As tarifas de interconexão são negociadas entre as operadoras móveis e fixas e a Agência Nacional de Telecomunicações (Anatel) que homologa o valor. O VUM do fixo para o móvel custa em torno de R$ 0,40 o minuto e do móvel para o fixo R$ 0,025. No começo, foi um incentivo para a telefonia móvel, incipiente no Brasil, mas criou-se um desequilíbrio.

Segundo Luiz Cuza, presidente da Associação Brasileira das Prestadoras de Serviços de Telecomunicações Competitivas (TelComp), a Anatel planeja rever as taxas de interconexão mas antes será necessário fazer um estudo sobre o modelo de custos nas telecomunicações, definido após a avaliação de uma série de variáveis para determinar os gastos das empresas com a prestação dos serviços, o que pode atrasar ainda mais essa decisão. O modelo de custos também deve analisar o peso dos impostos, que no Brasil representam em média 42% das tarifas, enquanto a média mundial é de 17%.

“A agência deve prover estabilidade regulatória para as operadoras que investiram no Brasil, sem a quebra brusca das regras. Desde a privatização das telecomunicações, o Ministério das Comunicações baixou em 50% as taxas de interconexão”, afirma Nelson Mitsuo Takayanagi, gerente geral de comunicações pessoais terrestres da Anatel. Ele destaca que a agência já contratou uma consultoria que tem até 18 meses para analisar o modelo de custos e apresentar recomendações.

Sem um aumento de renda, o assinante pré-pago continuará gastando o mesmo valor com telefonia celular independente da queda da tarifa. Além disso, vai usar mais a rede e a operadora terá que investir mais e aumentar o preço de outros serviços no pós-pago, gerando outro desequilíbrio. “No fim das contas, para compensar a queda do VUM, as empresas poderiam optar por aumentar o preço do minuto pós-pago para não perder margem de lucro”, diz Takayanagi. Para ele, a escala de serviços, já alcançada em países desenvolvidos, é outra variável a ser considerada.

Robin Bienenstock, da Bernstein Research, reforça que o corte na tarifa de interconexão não provocaria queda de investimentos das operadoras celulares no Brasil, um dos mercados de maior crescimento de telefonia móvel entre os emergentes. “Nos países de maior renda não há mais aquisição de novos usuários”, afirma.

As altas tarifas do VUM no país têm incomodado as operadoras fixas, principalmente aquelas que não têm serviços móveis. No fim de 2007, a GVT entrou na Justiça contra a taxa do VUM, reivindicando uma queda de 50% no valor. “No Brasil as operadoras celulares querem ganhar com a tarifa de interconexão e não com a prestação de serviços”, diz Gustavo Gachineiro, vice-presidente Jurídico da GVT.

A empresa paga para as operadoras móveis R$ 0,28 e deposita R$ 0,08 em juízo. Para o executivo, o valor justo seria de R$ 0,18. “Mesmo assim, esta já seria uma das tarifas de interconexão mais altas do mundo”, argumenta Gachineiro. A GVT também recorreu à Secretaria de Direito Econômico (SDE) para que o setor de telefonia móvel seja auditado em seu modelo de custos o mais rápido possível para que fique demonstrado a distorção do valor da interconexão.

A Comissão Europeia publicou uma recomendação orientando as operadoras da região a baixarem as tarifas a patamares entre € 0,03 e € 0,01 até 2012. Takayanagi, da Anatel, afirma que as operadoras brasileiras estão cientes desse horizonte mundial e devem se preparar para esse cenário gradualmente. Outra variável que deve entrar na conta da queda do preço do minuto no Brasil é a redução dos impostos sobre os serviços e o uso dos fundos de universalização das telecomunicações para subsidiar as tarifas do celular pré-pago.


O artigo acima foi escrito por Ana Luiza Mahlmeister, publicado no jornal Valor Econômico (28/01/10)

Posted in Nerd & Geek, Política | Tagged: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , | Leave a Comment »

Variáveis e identificadores – Parte I

Posted by fabianovasconcelos on 29 de January de 2010

Salve, galerinha do país em que vale de tudo pra se dar de bem!

Aos que acreditam piamente que a polícia do estado do Ceará está firme e forte, 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 debutante grávida? Pois você veio parar num curso on line de C/C++! Clica aqui pra ver o índice!

Aê, cambada!
Quanto tempo, heim?

Aqui estou eu, com a cara mais ensebada do mundo, de volta depois de várias promessas de voltar com força total. Ainda bem que eu sou brasileiro e cara-de-pau por natureza.
Aos que vem acompanhando essa putaria esse curso de C, e ainda mais, estão gostando, eis-me aqui para mais uma aventura, a de um cara que não sabe de nada, mas quer ensinar a alguém. Pode um cego guiar o outro?
Este post vai especialmente para três leitores em particular: o Wallace, que me deu uma alfinetada essa semana, perguntando porque eu não tinha vergonha na cara de terminar o que eu comecei, pro Daniel Habib e também pro André, que num ato de insanidade disseram que os meus posts estavam ajudando a eles (esses não tem a mínima condição de passar nem no psicotécnico do Detran, que é o exame de sanidade mental mais furreca que existe). Agora eu só posso é continuar a escrever, pois já dizia Antoine de Saint-Exupéry, no livro “O pequeno príncipe”: “Tu te tornas responsável por tudo aquilo que cativas”.
Já que eu tô aqui enchendo linguiça, queria aproveitar pra agradecer ao meu brother Bruno Sanches, leitor e meu esbofeteador corretor de erros oficial. Sem ele, os poucos doentes leitores que eu tenho já teriam ido embora e os grilos estariam aqui cantando.
Agora, sem mais delongas, vamos começar a enganação o conteúdo!
Dando continuidade ao nosso ato de auto-flagelo, eu gostaria de falar de uma coisa basicona em qualquer linguagem de programação: as variáveis e os identificadores.
Bom cambada, eu quero deixar esse conceito o mais claro e sucinto possível pra vocês. Imaginem uma calculadora. Daquelas bem simples, de mão, como aquela que você comprou ou encomendou da 25 de março na semana passada. Agora imagine que você vai lá na budega (mercearia, taverna, venda, boteco, mercadinho ou sei lá como diabos você chama na sua região) e o budegueiro vai somar a tua conta do mês. Ele vai querer te enrrolar, porque é bem típico de muitos deles querer enfiar no teu rabo as contas do teu vizinho que costuma comprar na tua nota. Ele soma na caneta. Você depois soma tudinho na sua calculadora. Dígito por dígito, você vai somando, até que você pressiona a tecla igual e vê o resultado final.
Pois bem, o primeiro ítem foi de 3 reais. Imagine-se digitando ‘3’. Ops! Onde fica guardado esse ‘3’ dentro da calculadora? Depois você, na intenção de somar, pressiona ‘+’ e depois digita o segundo ítem, que foi R$1,80. Mais uma vez eu pergunto: onde ficará armazenado, socado, alocado, cravado ou enterrado todos estes valores até o final da soma? E o resultado final, onde fica armazenado? Esta e mais outras respostas, já, já, aqui, no blog do NewWave!
Pois muito bem. Como muita gente deve saber, todos os computadores eletrônicos e programáveis possuem um tipo de memória, chamada de memória RAM. Essa memória é uma memória volátil, que se extingue quando o computador é desligado ou quando o programa é fechado. Em outras palavras, a memória RAM é como uma sala de expediente de uma repartição. Quando o expediente começa, a sala começa a encher e fica movimentada. Quando o expediente termina, a sala esvazia, diferentemente do HD (hard disk), que possui memória fixa, que não se apaga quando o computador é desligado. Bem, o objetivo aqui não é descrever com detalhes o que é uma memória RAM. Para isso, clique aqui, se ainda não estiver entendendo direito.
Observe a figura abaixo:

Uma representação de memória RAM em forma de diagrama. Cada quadradinho numerado são 8 bits ou 1 byte.

Este é um diagrama simplificado de memória RAM. Cada quadradinho representa um byte (oito bits). Se a memória RAM do teu computador é de 2Gb, por exemplo, isso quer dizer que uma representação da sua memória, nesse esquema aí, deveria ter 8 x 1024 x 1024 x 1024 x 2 quadradinhos, ou seja, aproximadamente 1,72 x 10¹º. Uma coisa monstruosa.
Agora, vamos voltar aquelas perguntas iniciais: onde ficam armazenados os dígitos da calculadora enquanto você sai digitando a conta da budega? Agora sim, podemos responder com segurança: na memória RAM do computador! É lá onde as coisas realmente acontecem. É lá onde os programas rodam, onde a festa rola.
Podem parecer desconexas as informações que eu estou descrevendo aqui, mas daqui a pouco tudo fará sentido (espero!).
Vamos falar agora de tipos de dados. Certamente nem só de números inteiros vivem os programas. Não existem só calculadoras, com seus números pra somar, dividir, multiplicar ou subtrair. Existem também processadores de texto, programas de controle de estoque, cadastros de pacientes de uma clínica, controladores de hardware, firmware para vibradores sexuais, etc. Tudo isso demanda muitos tipos de dados, não só de números inteiros.

Os tipos de dados em C, basicamente, são:

int – que representam os números inteiros (1, 3, -9, 0, 7, 876, -1000, etc);
float – que são números “quebrados” relativamente pequenos (1.7, 8.32, -9.923, 873.9002, 500.01, etc);
double – que representam números “quebrados” grandes (1.000001, 9.28347455, -0.98374455, 98384.88001, etc);
char – que representam caracteres (a, b, i, p, ç, [espaço], ‘, ~, ð, ŧ, →, j, /, ¢, ], 4 (o caractere, não o número), }, etc);
void – que representa a ausência de qualquer que seja o tipo.

Pode anotar estas palavras aí, porque elas são palavras-chave de C (e de C++), que você terá de saber obrigatoriamente: int, float, double, char e void.
Quando você escreve um programa, certamente vai ter que usar variáveis, posições de memória, pra poder armazenar os dados que serão entrados pelo utilizador.
Quando você declara uma variável, você está reservando um espaço na memória para acomodar os valores que você pretende entrar no seu programa.

Vamos analisar o seguinte código:

01 #include <stdio.h>
02
03 int main(){
04
05 int a;
06 int b;
07 int c;
08
09 printf(“Digite o primeiro número: “);
10 scanf(“%d”,&a);
11 printf(“\nDigite o segundo número: “);
12 scanf(“%d”,&b);
13 c=a+b;
14 printf(“\nO resultado da soma é: %d”, c);
15
16 return 0;
17 }

A linha 01 você já sabe pra que serve.
A linha 03 será explicada em outro tópico, quando falarmos de funções.
Já as linha 05, 06 e 07 nos interessam diretamente. Estas linhas são as chamadas declarações de variáveis. Porque declarar uma variável? Para que seja reservado espaço na memória RAM para o seu programa usar, trabalhar. Em outras palavras, quando eu digo:

int a;

eu estou dizendo ao compilador: “por favor, senhor compilador, reserve aí um espaço na memória para que eu possa entrar um dado do tipo inteiro”! O nome da variável, também chamado de identificador, nesse caso é a. Na linha 6, é declarada uma variável, do tipo inteiro, de nome b. Na linha 7, uma variável int de nome c é declarada. Os nomes de identificadores podem ser o que você quiser, desde que atenda aos seguintes requisitos: não pode começar com um número; devem obrigatoriamente começar com uma letra ou sublinhado; os caracteres subsequentes devem ser letras, números ou sublinhados.
Observe isso:

Correto:

name
Name
Adress
nome_do_cliente
numero_da_casa

Errado:

nome!dele
codigo…postal
2ovos

Por obséquio, não use palavras acentuadas. Evite também nomes de identificadores muito longos, tanto para fins de compatibilidade quanto para não ficar uma coisa amacacada:

este_nome_de_identificador_eh_muito_logo_de_se_ler

Já não é preciso repetir que C e C++ são case sensitive, né? Isso quer dizer que Count, count e COUNT, são três nomes de identificadores completamente diferentes. Também não é preciso repetir que as palavras-chave são palavras reservadas e que não devem ser usadas como nomes de identificadores, né? Olha, se eu pelo menos sonhar que algum de vocês tentou usar uma palavra-chave como nome de identificador eu urino dentro da caixa d’água de um, viu?

Bom, continuando a análise do programa acima, entenda que esse programa serve pra somar dois números. A linha 09 imprime na tela a seguinte mensagem:

“Digite o primeiro número: “

Já a linha 10 diz pro programa esperar que o usuário digite um número inteiro e armazene este número “na variável de nome a” (na verdade, armazene na posição de memória que você reservou para o seu programa e a chamou de a). A linha 11 faz coisa parecida com a linha 9: imprime na tela:

“Digite o segundo número: “

A linha 12 espera que o utilizador do programa digite um número inteiro e dê enter para armazenar esse número na memória, exatamente no mesmo esquema da linha 9. E a linha 13? Se você for um pouco mais inteligente que os macacos da finada novela global Caras e Bocas, vai perceber que ela está dizendo que a variável inteira c será atribuida a soma dos valores de a e b. E será beeeem fácil, depois de duas explicações, descobrir que o valor da variável c será impresso na tela quando a linha 14 for executada, precedido pela mensagem

“O resultado da soma é: “.

Por enquanto, esqueça as linhas restantes. Este programa será esclarecido bem detalhadamente em outras oportunidades. Nada ficará sem explicação, pelo menos com respeito a esse programa. O que eu quero é que você atente ao conceito de variável: é uma posição de memória RAM, que é representada por uma palavra (identificador), batizada pelo programador e que é usada para receber um dado do programa e para o programa, seja por meio do teclado ou pelo próprio código, como é o caso da linha 13.
Mais: procure escolher nomes de identificadores que tenham a ver com o uso dele. Por exemplo, você não vai querer armazenar um CEP numa variável de nome idade, vai? Isso te confunde na hora de manter o programa. Tanto confunde você, quando outro desgraçado que vai ter o azar de revisar e dar manutenção no teu código. Entendido esse conceito, vamos nos aprofundar mais no assunto.
Well, você já deve ter desconfiado (ou não) que não se pode armazenar qualquer número numa variável do tipo int. O número 1, dá pra armazenar tranquilo. O 1000, também. 0 10.000, cabe numa variável do tipo int sem besteira nenhuma. Mas e se eu quisesse armazenar o número 1.000.000, por exemplo? Aí a coisa muda de figura. Teriamos que usar outros recursos pra manipular valores realmente enormes. Vejamos os limites mínimos (faixas) de cada tipo que foi citado anteriormente (estes são os tipos mais básicos da linguagem C, o resto, que eu ainda não falei, deriva destes):

char : -127 a 127
int : -32.767 a 32.767
float : seis dígitos de precisão
double : Dez dígitos de precisão

Suponha que você queira fazer um programa que some dois números, mas que você tenha certeza de que estes números não passarão de 30.000, por exemplo. Para armazenar o primeiro número você pode usar uma variável do tipo int. O mesmo vale para armazenar o segundo número, pois ambos não passam de 32.767. Mas, e o resutado? Como fica? Se eu somar 30.000 + 30.000? O resultado será 60.000! Onde eu armazeno esse número? Que tipo de variável vai comportar esse resultado? O que acontece se eu tentar armazenar o resultado dessa soma numa variável do tipo int?
Vamos começar pela resposta da última pergunta. Bom, se você tentar armazenar o valor 60.000 numa variável do tipo int, muitos erros podem ocorrer. Um deles, particularmente ,eu chamo de erro do relógio. (Não viajem: esse nome fui eu quem inventou). Imagine um relógio de ponteiros. Ele marca três horas em ponto. O que acontece se eu somar 12 horas a ele? A resposta é: NADA! Ele simplesmente girará, dará uma volta completa, até voltar exatamente a marcar três horas. E se eu somasse cinco horas às três? Aí sim, ele marcaria oito horas. E se somassemos dezesseis horas as três que estão marcando? Ele giraria uma volta completa e mais quatro horas, parando em sete horas.

Bem, caros leitores malucos, eu acho que não preciso explicar mais nada. Um dos erros mais comuns de quando você extrapola os limites de um tipo é rodar feito um relógio. No caso de ints, o resultado da soma dos números 32.767 + 2, por exemplo, é negativo, ou seja, -32.765. Se eu somar 60.000 a esse resultado, o novo resultado será 27.235. Se eu somar 10.000 a esse número, o resultado será novamente negativo: -4.468. E por aí vai. Esse é um dos erros que podem ocorrer. Podem ocorrer outros erros, vai depender da arquitetura do processador que você está usando. Portanto entendam: se vocês querem fazer um programa sem bugs (erros), querem que o programa funcione direitinho, escolham bem os tipos que você vai usar. Tipos apropriados para os dados que você pretende manipular.

Uma coisa interessante a ser falada aqui a respeito dessas faixas que eu citei acima, é que esses valores são valores mínimos. Os padrões pro C/C++. Normalmente, com essa ruma de processador irado de hoje em dia, um int, por exemplo, pode ir bem além de 32.767 (ou bem menor que 32.767) sem erros, mas não confie nisso. Escreva seus programas de maneira padrão, porque você não sabe em que bomba ele vai acabar rodando. E se for um PC da era mesozóica?
Como eu falei anteriormente, nem só de ints vive um programa. Se você precisar manipular nomes de pessoas, nomes de ruas, marcas de carro, nomes de doença ou qualquer outro dado que envolva uma sequência de caracteres, o tipo de dado básico pra isso é o char. Como você pode ver, ele tem uma largura de 8 bits (vai de -127 a 127). O que significa isso? Significa que esse tipo pode abarcar 256 caracteres diferentes. Eu já toquei nesse assunto aqui anteriormente. Falei também na tabela ASCII. Refrescando: a tabela ASCII é uma tabela de caracteres em que cada caractere é associado um número, e que vai de ZERO a 255. Veja os posts anteriores se quiser saber mais. Mais à frente aprenderemos a manipular strings de caracteres.
E se você quiser manipular dados números em ponto flutuante, ou seja, não inteiros, com casas decimais, se valha do float ou do double. O float, para números em ponto flutuante até 6 dígitos de precisão. Por exemplo: 29.090991 ou 23.8 ou 0.878204. De sete casas até dez de precisão, use o double. Exemplos de double: 90.0000000001, 870.1100000000, 0.7537257, etc. (veja os exemplos contando as casas decimais, depois não fique aí voando, sem saber do que é que eu estou falando).
Bem, galera, por hoje é só. Mas esse tópico não termina aqui. Vamos fazer a parte II de Variáveis e identificadores. Ainda tem muita coisa pra ser batida e algumas perguntas desse post ainda precisam de respostas. Ainda vou falar de float e double. Só espero que eu realmente tenha agradado neste post como eu penso que agradei. Qualquer dúvida, já sabem: postem aqui! Se eu falei alguma merda coisa errada, façam que nem o Bruno Sanches: esculhambem. Não se esqueçam que eu sou tão estudante quanto vocês.

Fiquem com Deus e um abraço a todos!😀


Geralmente eu costumo postar uma piada aqui, mas desta vez eu queria falar sério. Como todo mundo sabe, o terremoto no Haiti acabou com a cidade de Porto Príncipe e cidades vizinhas, matou milhares de pessoas e muitas ficaram desabrigadas, feridas e sem rumo. Somente crianças, são mais de um milhão, sem pai, nem mãe, desamparadas nas ruas das cidades, com fome, sede e simplesmente sem saber a quem recorrer. NÃO EXISTE ÁGUA POTÁVEL, NEM SAÚDE, NEM HIGIENE. Não existe NADA! Só destruição. As pessoas brigam por comida nas ruas, feito animais, dos mais selvagens. Os mais fortes conseguem algo, enquanto os mais fracos ficam a mercê de alguém que os ampare. E você? Vai ficar aí parado, sabendo que poderia contribuir com algo, mas se acomoda na cadeira? O dia de amanhã, só a Deus pertence. Não sabemos da NOSSA condição no futuro. Não sabemos se um dia precisaremos de comida e água potável por meio da caridade de alguém. Não fique aí parado! Pegue JÁ o telefone, ligue pra Cruz Vermelha da sua cidade e pergunte no que pode ajudar! A vida desses miseráveis está nas nossas mãos. Pense nisso!


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

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