My life in English

Aiming to be a Canadian citizen.

Archive for the ‘C/C++’ Category

Seção destinada a falar sobre programação nas linguagens C/C++.

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

Advertisements

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 »

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 »

Vamos aprender a programar em C/C++? Lição 05: compilação, linkedição e chamadas a bibliotecas

Posted by fabianovasconcelos on 12 de September de 2009

Salve, galerinha do país com a maior densidade de canalhas do mundo!

Aos que acreditam piamente que José Sarney é inocente, 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 eleitor do Governador do Distrito Federal? Pois você veio parar num curso on line de C/C++! Clica aqui pra ver o índice!

A bola da vez agora são os aspectos de compilação. Tanto atendendo a pedidos, quanto porque já estava no cronograma. De agora em diante, nós vamos entender, cada vez mais, como funciona aquele programinha do “HELLO WORLD!” que a gente escreveu no post passado.

Recaptulando o que foi estudado anteriormente, eu vou citar um parágrafo do post anteior:

Na linha 2 você vê o texto #include <stdio.h>. A diretiva #include fala pro compilador (na realidade o pré-processador) incluir no seu código, MAIS CÓDIGO! pois é. É que se você tivesse mesmo que programar, digitar, escrever tudo que é necessário pro seu programa funcionar, você iria apanhar mais que cão pra ir pra missa. Só pra você ter uma idéia, #include <stdio.h> é traduzido como: “além do que eu escrever aqui, eu quero que se junte ao meu código um outro pedaço de código do arquivo stdio.h, que está num diretório, do meu compilador,  lá na casa do caramba”. O arquivo em questão são instruções de entrada e saída padrões para o programa. Ainda bem que alguém já escreveu isso por nós.

Baseado nisso daí, a gente vai começar a entender o processo de linkedição.

Imagine que você já é um programador profissional. Um cara que faz grandes programas, ou seja, um garoto de programa. Se for menina, uma garota de programa. (Garotas de programa, comentem aqui! Vocês estão em falta).

Então você é contratado pra fazer um programa bem grande, um programa que levará mais de um mês pra ficar pronto, trabalhando todos os dias, 8 horas por dia. Você começa o seu código devagarinho, com a função main, que é a primeira função de um programa em C. Inicialmente o programa tem só 10 linhas. De repente, no final do dia, ele já tem 800 linhas. No final da semana ele já tem 6000 linhas. Aí você fica espantadérrimo com aquilo tudo. “Nossa! Fui eu sozinho quem fez isso?”  Foi, sim! É porque leu o blog do NewWave, oras!

Acontece que, toda vez que você escrevia uma função nova, tinha que compilar o programa inteiro pra testar aquela função, saber se ela estava bem escrita, sem bugs (erros), se precisava ajustar algo, acrescentar algo, etc. Mas o processo de compilação de um programa é tão demorado quanto o seu tamanho, ou seja, quanto mais o programa cresce em linhas de código, mais demorado é pra transformá-lo em binário. Tem programas que demoram horas pra compilar. Pensando nisso, a galera do C resolveu permitir a divisão dos programas em arquivos, onde você pode muito bem criar seus códigos em módulos. Assim, quando você terminar de criar um módulo (em forma de um arquivo relativamente pequeno) é só compilá-lo e juntar ao restante do código que já foi compilado anteriormente. Isso se chama LINKEDIÇÃO! Agora vamos detalhar tudo isso pra uma melhor compreensão.

Ah! Como é boa e pacata a vida de programador!

Ah! Como é boa e pacata a vida de programador!

  • Bibliotecas

Provavelmente você já deve ter ouvido falar, no mundo da informática, das “bibliotecas”. Não, não se trata de um lugar grande, cheio de prateleiras e livros. Eu estou falando de subprogramas de computador, arquivos binários, geralmente não executáveis que ficam armazenados em diretórios específicos de sistema.
Como você já deve ter entendido, as bibliotecas podem ser anexadas ao programa em tempo de compilação ou em tempo de execução. Para isso existem dois tipos de biblioteca: a biblioteca dinâmica (dynamic library) e a biblioteca estática (static library). A diferença de uma pra outra é o momento de atuação. Não se apavore! Eu falei atuação e não autuação.

Falando de bibliotecas dinâmicas, quando um programa é compilado, ele fica igual a um queijo suiço, ou seja, cheio de buracos. No momento em que ele é executado e todas as vezes que ele é executado, as bibliotecas dinâmicas são chamadas pelo linker pra tapar esses “buracos” e o programa rodar certinho. Aí sim ele ficará completo. Bibliotecas dinamicas mas são, praticamente, programas como qualquer outro, a diferença é que não são chamadas diretamente pelo usuário, mas carregadas apenas por outros programas. Exemplos de bibliotecas dinâmicas: as dll’s do windows e os .so do linux.
Já no caso das bibliotecas estáticas, as coisas acontecem um pouco diferente. No processo de compilação, o linker une o programa que você escreveu (compilado) com as bibliotecas estáticas necessárias ao funcionamento do programa. Após esta operação, acontece a fusão, tornando-se tudo um só arquivo, programa e biblioteca(s). Essa fusão não acontece com a linkedição dinâmica e esse processo só acontece uma única vez. Exemplos de bibliotecas estáticas: as .a e as .lib.

Bibliotecas geralmente são de uso genérico, ou seja, uma mesma biblioteca pode ser o complemento de muitos programas. Por exemplo, a biblioteca vbrun.dll, do Micro$oft Rwindows, é requerida em muitos programas que tem como base o VB (visual basic) pra que estes consigam rodar. Isso livra o programa de ter um tamanho monstruoso. Pensa aí: se eu tenho cem programas, no mesmo HD, que necessitam de uma mesma biblioteca, e esta biblioteca é relativamente grande em bytes, pra que é que eu vou incorporar a mesma biblioteca cem vezes em cada programa, se eu posso ter apenas uma cópia compartilhada para todos os programas? Seria idéia de eleitor do Collor, não é mesmo? Mas aí já sabe: se a biblioteca requerida pelo programa não estiver presente no seu PC ou se estiver na pasta errada que não a pasta padrão das bibliotecas, o programa não vai rodar e vai emitir um erro.

Em alguns casos as bibliotecas são escritas em Assembly (linguagem dos deuses), porque existem coisas que C/C++ não consegue manipular nativamente. Os dispositivos e instruções de entrada e saída, por exemplo. Como lidar com o teclado, mouse, monitor, etc? Pra isso não tem jeito: é coisa de baixissímo nível e deve ser escrito em baixíssímo nível. ASM neles! Por isso se optou por usar o sistema de bibliotecas. Tem coisas que, mesmo o C/C++, poderosíssimos como são, não dão de conta. Agradeçam aos caras que implementaram a linguagem. Se não fosse por eles, você é quem teria essa dor de cabeça.

O nome do processo de linkar um programa com suas respectivas bibliotecas, sejam elas dinâmicas ou estáticas, chama-se linkedição.

  • Arquivos de cabeçalho

Voltemos ao programinha “Hello, World!”. Lembram daquela primeira linha? A #include <stdio.h>? Pois é. Aquela linha, como já foi dito antes, é a responsável pela inclusão (linkedição) do seu programa com as bibliotecas necessárias a execução do programa. Como já foi dito anteriormente, o linker é que é o responsável em linkar bibliotecas a programas e os arquivos de cabeçalho dão as instruções para que o linker faça tudo direitinho. Todas as vezes que você vir num código em C/C++ uma cerquilha # acompanhada de mais alguma coisa, pode ter certeza de que aquilo é uma diretiva do pré-processador. As diretivas do pré-processador servem pra colocar o pré-processador em ação. Umas das diretivas do pré-processador é a diretiva #include (não esquente a moringa, você vai ver o resto das diretivas depois, aos poucos). A diretiva #include diz ao pré-processador para incluir um determinado arquivo ao código. No caso do nosso programa, o arquivo a ser incluso é o <stdio.h> (o nome do arquivo deve ficar entre os sinais menor que e maior que). O arquivo stdio.h é um arquivo de cabeçalho, ou header, por isso .h. Não confunda: o pré-processador não é responsável por linkar bibliotecas e programas, quem faz isso é o linker. A unica coisa que o pré-processador faz é substituir macros e resolver os includes. Arquivos .h não são bibliotecas, são apenas arquivos de definições.

Ainda está obscuro? Calma que eu ainda não terminei. Isso é mais fácil do que entender a cabeça das meninas.

Vejamos o nome do arquivo em questão: stdio.h. std, vem de standard, ou padrão. io, vem de input e output, ou seja, entrada e saída. Não é preciso ser Stephen Hawking pra concluir que esse arquivo trata exatamente de como manipular a entrada e saída padrão nos programas feitos em C/C++, né? Pois é! Na real, os arquivos de cabeçalhos são intermediários. Eles não contém exatamente o código que se deseja usar. Eles contém informações de onde pode ser achado o código desejado. Ao invés de conter a função toda escrita, eles contém simplesmente os protótipos das funções e, falando a grosso-modo, aponta qual(ais) a(s) biblioteca(s) deve(m) ser usada(s) na ocasião.
Se, ainda assim, estiver obscuro, se acalme! No decorrer do curso nós veremos mais coisas relativas ao assunto deste capítulo.

  • Padrão ISO/ANSI

Vocês já ouviram falar em ISO? E ANSI?

Sim! ISO (International Organization for Standardization) é aquela daquela conversa de ISO9002, ISO9001, etc. que estamos acostumados a ver as empresas se gloriando de ter recebido. É um comitê internacional de padronização. Eles arrumam tudo que está bagunçado (nem pense, eles não arrumam o seu quarto e nem o seu casamento). Quer ver um exemplo do trabalho deles? O CD que você escuta (ou escutava, antes de aprender a baixar músicas via P2P) tem aquele formato redondo, naquela espessura, com aquele tamanho de raio, diâmetro do buraco no meio, com todas aquelas características por conta de uma padronização. Esta padronização é reconhecida pelo ISO e publicada em um documento.

Paralelamente, como sempre, os estadunidenses, com as suas manias de não quererem se misturar com o resto do mundo e quererem enfiar goela abaixo o seu estilo de vida, criaram o ANSI (American Nacional Standartd Institute), que é o orgão de padronização estadunidense. Como todo mundo sabe, eles não usam, pro exemplo, o metro como medida padrão, nem quilos, nem qualquer outra medida do Sistema Internacional. O basquete da NBA tem regras diferentes das regras oficiais olímpicas. A mesma empresa que vende o sistema operacional mais usado no mundo quer impor um HTML diferente, que só eles usam. Por que não também não inventar uma linguagem C e C++ diferentes, só pra dizer que “não se misturam”? Pois foi. Senhoras e senhores, existe também, além do C ISO e C++ ISO, o C ANSI e C++ ANSI. Mas não esquentem com isso. Programem em C/C++ ISO.

Da mesma forma acontece com as linguagens C e C++. A galera que as criou, deixou-as soltas, e aos poucos cada um vinha e metia o bedelho nelas, fazendo uma bagunça sem tamanho. Mas, rapidamente, notou-se que a coisa tava virando cabaré e resolveram padronizar a linguagem. Hoje, as palavras-chave, as bibliotecas padrão (aquelas oficiais, escritas pelos implementadores do C e C++), o estilo de programação, tudo está documentado e padronizado.

Apesar das bibliotecas padrão, tanto em C, quanto em C++, serem relativamente ricas em conteúdo, contendo, por exemplo, funções matemáticas* que você não precisará escrever, ou funções de manipulação de strings (calma, você saberá o que é isso no seu tempo certo, não se afobe), existem certos códigos que não foram implementados na biblioteca padrão, então, se você precisar de um código em particular, você tem duas opções: (1) crie a sua pŕopria biblioteca (o que não é nada difícil e até mesmo eu encorajo a você a criar); (2) adiquira de alguém ou alguma empresa a biblioteca pronta. O princípio do C e C++ é: reutilizar, reutilizar, reutilizar. Pra quê ficar feito pateta reescrevendo código que já existe? Se já existe e você tem como pegar, linke com o seu código e pronto! Cuidado: existem códigos proprietários que você só pode ter mediante pagamento. Não vão sair dizendo por aí que eu tô incentivando a pirataria.

Existem duas coisas que eu preciso dizer a respeito de criar as suas própias bibliotecas: (1) outras pessoas podem usar o código que você escreveu, e poupar o trabalho de monte de gente; (2) não tente reescrever os códigos da biblioteca padrão pensando que você vai fazer melhor que do que já está lá. Esses códigos foram testados e retestados um milhão de vezes,e dificilmente você fará melhor que os caras. Mesmo assim, se quiser tentar, fique a vontade. Se você conseguir algo de significativo, parabéns, você ganha uma bolsa de estudos no MIT bem rapidinho.

Existe uma parte significativa e notável da biblioteca oficial C++ que se chama STL (Standard Template Library) e foi criada por Alexander Stepanov e Meng Lee, na Hewlett-Packard.

  • DLL, LIB, .a e .so

Não é possível que um usuário do rwindows, que goste de tecnologia e tenha interesse em aprender, não tenha ouvido falar, mesmo que seja de longe, na sigla dll. Pois é. Dll significa Dynamic-link library (Biblioteca de ligação dinâmica). Esta é a principal implementação de biblioteca da Microsoft. A implementação padrão deles. Outro formato bastante usado por quem programa pra windows é o .lib. Apesar de existirem mais formatos, vamos ficar com esses dois na memória, pra não complicar.

No caso do Linux, os formatos mais conhecidos e usados são: .a e .so. Também vamos ficar só com esses dois. Pro nosso estudo, tá de bom tamanho. Querem saber mais sobre esses formatos? Google!

Well, eu espero que esse post tenha sido esclarecedor. Mais uma vez, me desculpem a demora em postar, mas é que apareceram aí uma ruma de pepinos que eu tive de desembargar. Na realidade, esse foi o post mais complicado que eu tive que escrever. Eu sou réu confesso que tive que estudar bastante pra escrevê-lo. E já sabem: se acharem erros ou algo que não concordam, postem! Não paga nada.

Por fim, cliquem AQUI, para ler um artigo filé mignon sobre pré-processadores, by UNICAMP. Eu recomendo deixar essa preguiça nojenta de lado e ler de verdade. Pra sair e beber cachaça ou transar não tem preguiça não, né? Se não entenderem agora, não se preocupe: não se trata de burrice e nem em linguagem difícil de aprender. É que eu ainda preciso explicar muita coisa que tem escrito lá. Mas a simples leitura, mesmo sem entender, já abre a mente, desperta a curiosidade e você se familiariza com a linguagem.

Um grande abraço aos cuecas e um selinho nas calcinhas. Fiquem com DEUS!

Fui!

*O arquivo de cabeçalho usado aqui é <math.h>.


NA CLÍNICA PARA DEFICIENTES

Na hora do almoço, um interno ia passando pelo refeitório, quando o cozinheiro lhe pergunta:
– Quer uma torta, amigo?
– Agora não, obrigado! Acabei de comer uma ceguinha!


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

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

Vamos aprender a programar em C/C++? Lição 04: as palavras-chave de C e C++

Posted by fabianovasconcelos on 13 de July de 2009

Salve, galerinha do país do povo que adora uma mamata!

Aos que acreditam piamente que o Michael Jackson era branco porque tinha vitiligo, 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 fã do Micheal Jackson procurando o corpo do astro? Pois você veio parar num curso on line de C/C++! Clica aqui pra ver o índice!

Pois bem, cambada! Fazia tempo que eu não postava nada aqui sobre C e C++, mas é que o tempo “ruge” como diz um conhecido meu (o certo é URGE).

Bom, eu gosto muito de cumprir com a minha palavra, sendo assim eu vou falar hoje sobre as palavras-chave!

Palavras-chave? Que diabos seria isso? Pois muito bem. Vou explicar.

Lembram de quando a gente falou de algorítimo? Não tinha ficado combinado que algorítimo é uma série de passos que devem ser seguidos para se realizar uma tarefa, e que isso se aplica a programação, escrevendo uma rotina de código, em forma de algorítimo? Pois bem!

Mas você não espera mesmo, nessa tua mente infantil, que o compilador vai entender tudo que você digita, né? Assim, de qualquer jeito, cheio de erros de português, avacalhado. Não vai mesmo, colega! Tem que escrever o programa com um certo padrão. Usar as palavras que o compilador entende. Aí você me diz: “Já sei, Fabiano! As palavras que eu devo usar para escrever o meu programa são as palavras-chave, né?” É isso aí, sensitivo! Bem pensado. Abaixo eu vou listar as palavras-chave de C. As palavras-chave de C++ são as mesmas de C e outras mais, que estarão na lista seguinte:

Palavras-chave da linguagem C:

auto * double * int * struct * break * else * long * switch * case * enum * register * typedef * char * extern * return * union * const * float * short * unsigned * continue * for * signed * void * default * goto * sizeof * volatile * do * if * static * while

Palavras-chave (exclusivas) de C++:

asm * bool * catch * const_cast * delete * class * friend * inline * new * private * protected * public * template * this * virtual * dynamic_cast * explicit * false * mutable * namespace * operator * reinterpret_cast * static_cast * throw * true * try * typeid * typename * using * wchar_t * export

Só avisando a galerinha que anda pesquisando palavras-chave por aí: tem muita lista, na internet, incompleta ou com palavras-chave que não fazem parte do escopo oficial do C++. A lista acima está de acordo com o documento oficial da ISO (ISO/IEC 14882:1998). Se estiverem duvidando, vão lá na página do ISO, comprem o PDF (ou baixem do emule), e confiram por vocês mesmos.

Outra coisa importantíssima: tem gente que tem a mania horrenda de escrever assim: “oI AmiGUinhOS! ComO EsTaUm??? :/”! Esta aberração tendenciosamente fru-fru não cola em C/C++. A palavra chave é int, tudo MINÚSCULO, e não INT ou Int ou InT. O certo é auto, não AUTO, Auto ou AuTo. Palavras-chave só existem totalmente em minúscula. Se existir uma letra maiúscula no meio já não é palavra-chave, ou seja, elas são case sensitive.

Pois muito bem. Pelo menos memorizem estas palavras-chave, porque eu duvido que algum programador do mundo use pelo menos a metade do que está aí, esta é que é a verdade. A palavra-chave goto, por exemplo, foi praticamente banida da programação, não só em C/C++, mas também de outras linguagens que a tinham no seu cerne. Veremos a inutilidade utilidade dela mais adiante. Eu não vou nem mentir pra vocês: tem muita palavrinha aí que eu juro que não faço idéia pra que serve. Mas nem se iludam, vocês não vão usar isso tudo nem por capricho! Mas, se mesmo assim chegar alguém aqui exigindo a explicação de algumas palavras que ficarão de fora, eu vou atrás de saber pra que serve e posto aqui.

Levando-se em consideração que não tem muito o que se badalar na apresentação das palavras-chave e que eu ainda tenho que encher linguiça antes de finalmente fechar este post e publicar, eu acabo de ter uma idéia pra salvar a minha reputação:

Sou Jornalista formado pela USTF. Reitor: Gilmar Mendes!

Sou Jornalista formado pela USTF. Reitor: Gilmar Mendes! Em breve, novas profissões liberadas de diplomação! Aguardem!!!

conteúdo extra pra vocês, ainda neste post! 🙂 Então, pelos poderes que me foram investidos pelo Supremo Tribunal Federal, eu, Fabiano Vasconcelos, jornalista (quáquáquáquáquáquá…), vos apresento o nosso primeiro programa em C!

1      //Este programa é mais conhecido que a perseguida da Britney, mas ainda é o melhor programa pra iniciar o aprendizado de C

2      #include <stdio.h>

3      int main (void)

4      {

5      printf(“Hello, world!”);

6      return 0;

7      }

Antes de eu começar a explicar (superficialmente) como funciona o programa, entenda que eu começarei a ensinar C e depois, muito depois, C++. Isso porque grande parte de C++ é composta de C. Então quando eu terminar com C, já terei explicado muuuuiiito de C++. Aí é só correr pro abraço. Notem também que os números nas linhas não fazem parte do código, são só pra efeito de referência mesmo. Se você pensou que fazia, procure um analista.

Entretanto, nem tudo de C pertence obrigatoriamente a C++. Tem coisa de C que não tem nada a ver com C++, mas não se trata de muito conteúdo, não. É coisa pouca. Normalmente você pode misturar código C com C++ sem problemas, mas não é recomendável. Pode virar cabaré. Programe em C puro ou em C++ puro.

Muito bem. Vamos começar!

Se você pretende escrever alguma besteira no editor de textos do compilador mas quer que ele ignore o que você escreveu, você pode fazer que nem eu fiz na linha 1, usar duas barras seguidas para fazer um comentário. Este é o modo C++ de fazer comentários. O modo C seria o texto que você quer digitar entre estes símbolos: /**/

Exemplos de comentários no estilo C:

/*Este programa se auto-destruirá em 5 segundos*/

/*Se você consegue entender isso, agradeça ao Fabiano Vasconcelos*/

/*Garotas, ficar com o Fabiano é uma experiência descomunal!*/

Exemplos de comentários no estilo C++:

//Os engenheiros são os reis! Ao cruzar com um na rua, curve-se diante dele.

//Gilmar Mendes é um cara legal (Este comentário é pura ficção. Eu realmente não estou falando sério.)

//Este programa serve para engordar a minha conta bancária (Comentário posto no código-fonte do primeiro cavalo-de-tróia do Brasil)

Geralmente (e sensatamente) se escreve coisas úteis em um comentário de código. Coisas que irão orientar as pessoas que posteriormente estudarão o seu código, ajudando-os a entender como funcionam certas partes do mesmo. Também servirá pra você se lembrar de como implementou aquela função quando o Alzheimer chegar. Só avisando que, ao comentar ao estilo C++, após as // não dê enter (retorno de carro) de jeito nenhum, nem que a vaca tussa, porque esse comentário só serve pra linha em que estiverem as barras. O que pular pra outra linha será considerado como CÓDIGO mesmo e fatalmente gerará um erro de compilação, já que o compilador não entenderá as suas besteiras.

Um compilador C++ aceita, sem problemas, um comentário ao estilo de C. Mas um compilador C não aceitará um comentário ao estilo C++.

Esqueça completamente o último parágrafo. Foi só a título de informação. Não existem mais compiladores exclusivamente de C pra baixar. É peça de museu. Hoje em dia, todo compilador C é também C++. Resumindo: você é livre pra usar os dois estilos de comentário. Essa foi a linha 1 do nosso código.

Na linha 2 você vê o texto #include <stdio.h>. A diretiva #include fala pro compilador (na realidade o pré-processador) incluir no seu código, MAIS CÓDIGO! pois é. É que se você tivesse mesmo que programar, digitar, escrever tudo que é necessário pro seu programa funcionar, você iria apanhar mais que cão pra ir pra missa. Só pra você ter uma idéia, #include <stdio.h> é traduzido como: “além do que eu escrever aqui, eu quero que se junte ao meu código um outro pedaço de código do arquivo stdio.h, que está num diretório, do meu compilador,  lá na casa do caramba”. O arquivo em questão são instruções de entrada e saída padrões para o programa. Ainda bem que alguém já escreveu isso por nós.

Na linha 3 você vislumbra (que palavra poética!) o seguinte conteúdo: int main (void). Int é o tipo de retorno da função main e void é o argumento passado para a função. Não entendeu? Não se desespere. Tudo ficará claro com o passar do tempo. Não ouse desistir. Não seja covarde. Acontece que eu só vou tratar de funções mais adiante. Mas essa linha é um cabeçalho de função e não pode ser explicada assim, de supetão, num post só.

Na linha 4 nós temos uma abertura de chave {. Isto significa que está havendo uma abertura de bloco de programação. Uma função, por exemplo, é uma maneira de organizar um código em um bloco legível. Por isso C é chamada de linguagem estruturada. Porque é feita de estruturas, blocos, repartições. As funções são um tipo de estrutura, mas não a única. Depois da chave aberta, escreve-se o que se deve escrever pra rechear aquela estrutura e fecha-se a estrutura com uma }, como mostra a linha 7.

Na linha 5 você vê uma chamada a uma função em específico, a função que imprime na tela a frase Hello, world! (Olá, mundo!). Intuitivamente dá pra sacar que printf tem a ver com imprimir, né? Pois é.

E finalmente, na linha 6, nós vemos return 0; Isso diz à função chamadora, no caso o sistema operacional: “Ok, brother! Eu imprimi a minha besteira na tela, cumpri o meu papel e estou te devolvendo o zero”. Zero significa que o programa terminou normalmente, sem anomalias, sem travamento. Um valor diferente de zero significa que deu merda o programa executou uma operação ilegal e teve que fechar (estranho ! eu me lembro de ter lido isso em algum lugar…).

Caso eu demore pra postar, procure o seu neurologista.

Caso eu demore pra postar, procure o seu neurologista.

Pessoal, como eu já havia dito anteriormente, tudo que eu falei aqui é superficial. Eu vou explicar tudinho, tim-tim por tim-tim, aos poucos. Esse programa foi só pra vocês se familiarizarem com a linguagem. Até lá, peçam aos seus médicos novas receitas de Lexotan® e tomem de acordo com a indicação dele.

AVISO DELICADO: VOCÊ SE DROGA? NÃO SEJA IDIOTA! AS DROGAS MATAM E ACABAM COM FAMÍLIAS INTEIRAS. AS DROGAS ILÍCITAS FINANCIAM A VIOLÊNCIA E AS LÍCITAS SÓ DEVEM SER USADAS COM ESTRITA PRESCRIÇÃO MÉDICA. QUEM SE DROGA É COVARDE, BURRO E TERÁ UM FIM TRISTE: OU NA MASMORRA OU NO IML. PROGRAMADORES BEM SUCEDIDOS NÃO USAM DROGAS! AS DROGAS COMEM OS NEURÔRIOS DO SUJEITO!

.

.

Obrigado pela atenção.

Próximo post: como funciona a compilação em C/C++ e outras coisas mais.

Fui-me com Deus!


NO PLANTÃO MÉDICO

O sujeito vai ao hospital, caindo de bêbado. Durante a consulta, vêm as perguntas de praxe:
– Nome?
– Juvenal dos Santos!
– Idade?
– 32 anos.
– O senhor bebe?
– Vou aceitar um gole, mas só pra te acompanhar!


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

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