Hoje em dia, com a popularidade da internet, os vírus digitais, que tem como principal propósito: capturar logins, se tornaram tão epidêmicos que, logo quando se trata de um, num curto período de tempo surge outro incrivelmente pior. A proliferação dos vírus de computador se tem, também, graças a inclusão digital, que insere-se num movimento maior: inclusão social, justo por isso:

Comunidades como o próprio Orkut se tornaram hospedeiras de vírus e a maioria dos perfis ali presentes deveriam ser mantidos sob quarentena.

Sendo assim, para assegurar que nenhum humano ou máquina tenha acesso a sua conta ou login, vamos alterá-las: Para realizar esta tão simples proeza, vamos visitar a página que a Microsoft reserva para tal finalidade, portanto, entre com seus dados de conta de Hotmail (MSN) no seguinte link:

https://login.live.com/

Após conectar-se como você mesmo, no alto a direita você verá seu nome de usuário, clicando nele você terá um menu em cascata surgindo com diversas opções, no entanto, clique em contas.

A página que surgi se chama “Visão geral da conta“, nela você pode facilmente alterar não somente sua senha, mas também: seu nome de usuário, data de nascimento, pode-se alterar também as informações para a redefinição de sua senha, simplesmente clicando no link “Alterar“.

Tendo clicado no link para redefinir sua senha, surgirá uma página denominada “Altere sua senha“, nela você recebe três campos sendo: “Senha antiga”, “Digite a nova senha”, e por fim, “Digite novamente a nova senha”, onde você deve fazer justamente o que o titulo do campo propõe. Clique em salvar e terá sua nova senha atualizada.

Bom, agora vamos alterar a senha de acesso ao Google, que só não é tão simples quanto ter o Orkut hackeado. Entre na página inicial do Google e digite lá seu login. A direita, assim como na página da Microsoft, clique em seu nome de usuário e logo no menu que surgir, clique em “Configurações da conta”, na página que segue, “Visão geral da conta”, altere sua senha e pronto!

Com isso, você esta mais seguro, detalhe, escreva suas novas senhas num arquivo de texto por segurança, até que você se familiarize com elas.

Noutro canto da rua encontram-se as empresas de ônibus, que são campeãs no quesito: Indústrias de Transporte com Menor Número de Seguidores no Twitter e amigos no Facebook. Viajar de ônibus é sem dúvida a tortura “mor” para o trabalhador. Nem por isso a fatia de bolo das empresas de ônibus não deixa de ser enorme! Baixa remuneração ao trabalhador, baixa manutenção dos veículos e pressos amargos para os clientes.

Estas características desgostosas, entre muitas outras, tem dado forças e inspiração para a criação de meios de transportes conceituais dos mais diversos e improváveis tipos. Um dos mais impressionantes, que é econômico e de custo acessível para os grandes centros urbanos, saiu do papel e esta correndo a aproximadamente 430 km/h em Xangai:

O Maglev ou Magnetic levitation transport (Transporte de Levitação Magnética), é um Trem que, literalmente, voa baixo. É isso mesmo, este trem voa ou levita – como você preferir.

É “Trem” pra Mineiro nenhum botar defeito!

Dizem que os opostos se atraem e os semelhantes se afastam, no caso dos imãs e eletroímãs isso é verdade e é justamente por este princípio básico que o Maglev funciona. Graças ao campo magnético, criado pela bobina elétrica que há no trilho guia, repelindo os grandes imãs que há no trem, temos uma levitação de até 10 cm de altura do solo. O mesmo princípio é utilizado para mover o trem: um sistema de campos magnéticos dentro das paredes do trilho que, puxam e empurram o trem pelo trilho guia, empurram o veículo a uma velocidade incrível e praticamente sem ruído algum.

No Brasil, temos como alternativa o Maglev Cobra, desenvolvido pela UFRJ, Coppe e pela Escola Politécnica através do LASUP, que fica pra trás dos competidores apenas em questão de velocidade (sua velocidade normal de operação ocorrerá dentro de uma faixa de 70 a 100 km/h, não muito diferente do Metrô de Belo Horizonte). Bom… em relação ao Maglev de Xangai, a nossa versão, em comparação de velocidade, ainda esta se arrastando, mas poderia ser pior, imagina se o nosso trem se chamasse Maglev Saci?

Deixando de lado o fato de não ser o mais veloz, o Maglev Cobra apresenta um grande número de vantagens como:

• Baixou custo global
• Rapidez de aplicação e implantação
• Leveza
• Baixo custo de obras civis
• Não poluente e
• Racionalização

Pois é, com todas estas vantajosas características, só resta agora colocar em prática, ou seja dar início as obras e implantá-lo dos grandes centros comerciais do Brasil até as cidades dormitório (tomara que não demore tanto quanto o ônibus que me leva ao trabalho).

—————-

Now playing: Elvis Presley – Hound Dog

via FoxyTunes

ASUS P5KPL SE

A placa mãe que incorpora meu Quad é uma ASUS P5KPL SE, que tem, como um dos principais destaques, o sistema de som Realtek ALC 662 (6 canais de áudio de alta definição). No entanto, até alguns dias, eu não conseguia obter uma saída de som 5.1 no meu mais novo sistema operacional o que inutilizava meu Home Theater (um modesto Goldship). A solução foi procurar e isso nunca me seria problema, pois, como todo geminiano, sou um tanto curioso!

Caminhando pela internet, notei que muitíssimos internautas passavam pelo mesmo que eu. Quando cheguei no site da ASUS, uma surpresa, dei de cara com algo que até então não havia: não sei desde quando mas a ASUS possui suporte para Windows 7, sendo que, o DVD que integra a placa mãe, vem escrito em letras brancas sobre um fundo amarelo: Vista Drivers Inside.

Portanto, você que possui uma P5KPL SE, baixe e instale o novo driver de áudio neste endereço: http://www.asus.com/Motherboards/Intel_Socket_775/P5KPL_SE/#download, e divirta-se com seu som de cinema!
—————

Now playing: The Beatles – Lucy in the Sky With Diamonds via FoxyTunes

Para eliminar as dúvidas produzidas pela ambigüidade, temos os operadores lógicos, que estabelecem uma linguagem protocolar, clara e precisa. O retorno de um operador lógico é denominado “Valor Lógico”, que somente pode ser de dois tipos: verdadeiro ou falso.

Tabela 03_Operadores Lógicos

OR: Disjunção não exclusiva

END: Conjunção

NOT: Negação

O operador lógico OR (||), analisa as duas expressões, se uma delas for verdadeira ou diferente de zero, o retorno de OR será verdadeiro:

((a + b = 3) || (a + b = 6)) {comando}

Se “a + b = 3” ou “a + b = 6” for verdadeiro execute o comando seguinte.

O operador lógico AND (&&), analisa duas expressões, para ele retornar valor verdadeiro, as duas expressões devem ser verdadeiras.

((a + b = 3) && (y + z = 3)) {comando}

Se “a + b = 3” e “y + z = 3”  for verdadeiro o comando seguinte deve ser executado.

O operador lógico NOT (!) que pode ser interpretado como “Diferente de”, avalia uma única expressão por vez, se o valor avaliado for verdadeiro ele retorna falso, se for falso ele retorna verdadeiro.

(a != b) {comando}

Se “a” for diferente de “b” o comando seguinte deve ser executado.

Há exemplos a respeito dos operadores lógicos no capitulo if.

Operadores Relacionais

São eles:

Tabela 04_Operadores Relacionais

Os Operadores Relacionais comparam a expressão e retornam verdadeiro quando a comparação esta correta. São usados em expressões lógicas.

A seguir, exemplos.

Controle de Fluxo

Como já foi escrito diversas vezes: um programa é lido de cima para baixo. Há certos momentos que necessitamos fazer alguns “desvios” pelo corpo do programa, ou pular para uma outra área. Justo para estes momentos existe os comandos de controle lógico de fluxo:

If

//13° if

# include <iostream.h>

# include <conio.h>

int main ()

{

bool falso = (2 + 2 != 4);     //expressão lógica

if (falso == 0 )       //expressão lógica

{

cout << ” Falso!”;

}

getch();

return 0;

}

O “if” tem como parte integrante um par de parênteses onde uma determinada condição deve ser alojada, e um corpo limitado por chaves. Há códigos fontes onde se encontram o controlador de fluxo if sem as chaves que limitam seu conteúdo ou instruções, embora não aja – em casos distintos – a necessidade de usá-las em determinados códigos, o programador deve ter total conhecimento sobre onde param os saltos de seu código fonte. As chaves não só limitam o corpo do if como orientam o programador ao indentar.

Acima temos uma típica exemplificação do “if”, que somente será executado se o valor da variável falso do tipo bool for zero. O bool recebeu o identificador falso, que atribuído a ele foi a expressão: 2 + 2 é diferente de 4, como a expressão esta errada o bool envia o zero que o if aguarda.

If & Else

O “else” é chamado quando o valor do parâmetro de if é dado como falso, o else também possui um corpo limitado por um par de chaves.

(1)       if (a > 0)

(2)                   {

(3)                   cout <<“A é maior que zero…”;

(4)                   }

(5)                   else

(6)                               {

(7)                               cout <<“A é menor de 0”;

(8)                               }

Acima temos na primeira linha o parâmetro do if dentro dos parênteses:

Se “a” for maior que “0” escreva: “A é maior que zero”. Vamos supor que “a” e uma variável que a ela foi atribuído o valor duma divisão. Mesmo sabendo a procedência de “a” ainda não sabemos o valor. O if avalia o valor de “a” presente entre os parênteses com a condição “maior que zero”, se o valor de a em relação a condição for falso o else entra em ação, ou seja, o comando reservado ao bloco do else será executado. Verdade é e que o else é opcional, é possível utilizar o if sem o apóio do else:

O else, que começa na linha cinco tem seu corpo notavelmente limitado por um par de chaves, finalizado na linha oito. O corpo destes operadores de fluxo é semelhante ao do int main (), portanto todo conteúdo que se encontra entre as chaves deve ser finalizado com o ponto e vírgula.

//if else

# include <iostream.h>

# include <conio.h>

int main ()

{

int numero1;

int numero2 = 10;

cout << “Digite um valor para Numero 1: ”;

cin >> numero1;

if (numero1 >= numero2)  //linha 11

{

cout << “Numero 1 maior ou igual a Numero 2”;

}

else

{

cout << “Numero 1 menor que Numero 2”;

}

getch();

return 0;

}                                              //fim do main

No exemplo acima: temos duas variáveis do tipo int, o valor 10 foi atribuído a variável “numero2”, já a variável de nome “numero1” receberá um valor a partir da interação do usuário com o programa, ou seja, o “cin” da família do iostream vai capturar o valor e o atribuí-lo a variável numero1. Na linha 11 temos o if e seu parâmetro que exibira o conteúdo do bloco apenas se: o valor de numero1 for maior ou igual ao valor do numero2; caso contrário – se o valor for menor que o esperado: o else exibe o conteúdo confinado em seu bloco.

Se, unicamente, a variável numero1 for maior ou igual a numero2 o conteúdo de if será exibido, todas as outras possibilidades são cabíveis ao else. O corpo do int main acima pode ser escrito de outras formas, dando mais opções, ou eliminando a onipotência do else:

if (numero1 >= numero2)  //linha 11

{

cout <<”Numero 1 maior ou igual a Numero 2″;

}

if ((numero1 < 10) && (numero1 >= 0))  //substitui o else

{

cout <<”Numero 1 menor que 10″;

}

if (numero1 < 0)       //adiciona outro if

{

cout << “Numero 1 negativo”;

}

Acima temos a inclusão de um novo if para aumentar as possibilidades do programa o tornando mais… flexível. O else foi substituído por um if com o seguinte parâmetro: se numero1 for menor que 10 e numero1 for maior ou igual a zero, exiba: Numero 1 menor que 10. Portanto o segundo if toma para si todas as possibilidade de numero1 estar entre o zero e o nove. Todas as possibilidades abaixo de zero serão representadas pelo terceiro if, que tem como parâmetro: se o numero1 for menor que zero exiba: Numero1 negativo.

If Encadeado

Dentro do corpo de if & else pode se inserir ou declarar qualquer comando possível da sintaxe do C++, assim sendo, pode se haver um outro if & else:

//if & else encadeado

# include <iostream.h>

# include <conio.h>

int main ()

{

int numero;

cout << ” Digite um numero do conjunto dos inteiros: “;

cin >> numero;

if (numero < 10)       //primeiro if

{

if (numero > 0)        //segundo if dentro do corpo do primeiro

{

cout << ” Numero entre ZERO e DEZ ou igual a ZERO ou DEZ”;

}

else //ßprimeiro else

{

cout << ” Numero menor que ZERO”;

}

}           //fim do primeiro if

else //ßsegundo else

{

cout << ” Numero maior que DEZ”;

}

getch();

return 0;

}

Após todo processo de atribuição de valor para a variável numero, o primeiro if e o segundo avaliam o valor concedido para a variável: se for menor que dez e maior que zero a frase: Numero entre ZERO e DEZ ou igual… será exibida.

Se o valor atribuído a variável for maior que dez – contradizendo a condição do primeiro if – o segundo else entra em ação exibindo o conteúdo confinado entre suas chaves. Observe que o segundo “else” esta alinhado com as chaves do primeiro if, isso quer dizer que ele pertence ao primeiro if e: se o valor da variável não estiver de acordo com a condição do primeiro if, o else será chamado. Longa vida a Indentação!

Se a variável numero for menor que zero, contradizendo a condição do segundo if, o primeiro else – alinhado às chaves do segundo if – entra em ação exibindo o conteúdo confinado no seu bloco.

While

O Controlador de Fluxo while é capaz de repetir uma determinada área do código infinitas vezes, ou repetir uma função ou opção se a condição for verdadeira.

while (Condição) {sentença}

A condição pode ser formada utilizando operadores lógicos ou relacionais ou simplesmente uma variável.

Como o programa vai repetir um número indeterminado de vezes, não é mais necessário a inclusão da biblioteca conio e sua função getch.

No exemplo seguinte, temos um código fonte que quando compilado e executado dará ao usuário o número ASCII de um caractere, símbolo ou número.

Duas variáveis do tipo char foram criadas. O parâmetro do while recebeu a variável loop que tem como valor “s” atribuído.

Após o cout exibir seu ultimo conteúdo, chegamos ao fim do bloco do while, portanto, o while confirma se loop é igual a “s” como a confirmação é verdadeira, o while repete todo o conteúdo confinado em seu bloco novamente.

//While

# include <iostream.h>

int main ()

{

char loop = ‘s’;

unsigned char letra;

while (loop)

{

cout << “\n Digite uma letra para recebe-la em ASCII :\b”

“\n\tOu CTRL + C para sair :\b”;

cin >> letra;

cout << “\t   ” << letra <<” >> ASCII >> ” << (int) letra <<endl;

}

return 0;

}

A outros meios de se criar um laço infinito como o que temos no exemplo acima, pode-se, simplesmente, colocar entre os parênteses do while a palavra reservada True (verdadeiro) ou o numero 1 que tem valor igual.

Do While

Para que o while de um suposto programa seja executado pelo menos uma vez temos o auxiliar do. A final, se a condição do parâmetro do while nunca for verdadeira o conteúdo dele nunca será exibido.

do {sentença} while (condição);

//Do While

# include <iostream.h>

int main ()

{

char resposta;

unsigned char letra;

do

{

cout << “\n Digite uma letra para recebe-la em ASCII : “

“\n\tOu CTRL + C para sair :\b”;

cin >> letra;

cout << “\t   ” << letra << ” >> ASCII >> ” << (int) letra <<endl;

cout << “Para continuar pressione [S]“;

cin >> resposta;

}

while (resposta == ‘S’ || resposta == ‘s’);

return 0;

}

No código fonte acima, duas variáveis do tipo char foram declaradas. O do, logo de imediato, exibe o valor confinado entre as chaves sem passar por condição alguma. O cin é utilizado na ultima linha do bloco para capturar um valor igual a “S” ou diferente e atribuí-lo a variável resposta. O while analisa o valor atribuído a variável resposta, a condição é:

Se for igual a “s” minúsculo ou maiúsculo, o laço se repete, se diferente o programa termina naturalmente. Se a condição do while não for previamente especificada pelo programador, o laço assume o valor verdadeiro ou true e repetira seu conteúdo um número indeterminado de vezes.

O do while somado as características do switch são a ferramenta perfeita para se fazer menus em C++ estruturado.

Break & Continue

A palavra reservada Break é incluída em um laço quando não se há mais a necessidade deste continuar a executa sua rotina, ou seja, quando o objetivo do laço foi concluído o break surge para quebrar a rotina previamente definida.

No exemplo Raiz Quadrada do capitulo For temos uma exemplificação perfeita do uso do break, onde: quando a raiz é encontrada o laço é quebrado pelo break e o programa retorna ao ponto onde havia parado.

Já a palavra reservada continue da um fim na linha atuante mas não sai do while. O continue é utilizado quando o conteúdo que o sucede deve ser sob qualquer hipótese, exibido.

O exemplo abaixo exibe, a partir da interação com o usuário, uma reta do conjunto dos Inteiros.

// Break & Continue

# include <iostream.h>

# include <conio.h>

int main ()

{

int num;

cout << “Digite um numero do conjunto dos \n”

“inteiros entre 1 a 10: *\b”;

cin >> num;

cout << “\nZ = {(…”;

int num2 = (num * (-1));

while (true)

{

num2 ++;

if (num > num2)

{

cout <<num2 << “, “;

continue;

}

cout << “…)}”                        //linha 20

“\n\n\tAcima a reta do conjunto”

“\n\tdos inteiros entre -”<<num2 << ” e ” <<num;

break;

}  //fim do while

getch();

return 0;

}

Uma variável denominada num foi declarada e o comando cin atribui valor a ela. Outra variável denominada num2 foi definida na linha 10, o valor atribuído a ela é igual ao valor da primeira variável vezes menos um, ou seja, se o valor atribuído a variável num for igual a 5, o valor da variável num2 será igual a 5 negativo.

O while tem true como parâmetro, que permite que ele seja infinito – verdade é que o break quebra o while, então ele não é realmente infinito. Após o num2 ser incrementado, o if surge com uma condição para exibir o valor incrementado:

Se num for maior que num2 exiba.

Portanto, se num for igual a 3 num2 será igual a um laço que começa em -3 e vai incrementando: -2, -1, 0, …, 3, até ser maior que o num. Quando o num2 for maior que num o if não mais o exibe, o continue pula para a linha 20, após o conteúdo do cout ser exibido o break encerra o while.

Observe na linha 22, (…inteiros entre -”<<num2 << ” e ” <<num) após a palavra “entre” há um traço representando o sinal negativo, como o num2 termina com o mesmo valor do num foi necessário inserir este sinal para representar o primeiro número do conjunto.

Como o break encerra o while, para o programa não fechar após a exibição do ultimo cout, o getch da biblioteca conio foi inserido no código fonte.

For

A sintaxe do for:

for ( inicialização; condição; incremento) {sentença}

A sentença será executada até que o valor da condição seja falso.

A inicialização pode ser uma expressão ou condição, ela é a primeira a ser executada. Variáveis definidas dentro do parâmetro do for são válidas apenas dentro do for, por exemplo:

for ( int i = 0; i < 10; i ++) {sentença}

No caso acima, temos o “i” do tipo inteiro com valor inicial igual a zero, a condição determina que “i” vai até 9, o incremento produz todos os valores entre  0 e 9 e os atribui a variável int i.

Se no parâmetro do for não houver valor algum, temos um laço for infinito:

for ( ; ; );

O exemplo a seguir encontra raízes quadradas a partir da interação do usuário. Este exemplo é muito interessante por sua simplicidade, nele é utilizado não só o controlador de fluxo for, mas o if também dentro do corpo do for.

//Raiz Quadrada

# include <iostream.h>

# include <conio.h>

int main()

{

int r, i;

cout << “Digite um numero do conjunto dos inteiros positivo: “;

cin >> r;

for (i = 0; i < r; i ++)                    //Se: r = 9, i = {0, 1, 2, 3, 4, 5, 6, 7, 8}

{

if (i * i == r)

{

cout << “A raiz de ” << r << ” eh: ” << i;

break;

}

}

if ( i * i != r)   //linha 18

{

cout << “\tRaiz Inexistente!”;

}

getch();

return 0;

}

Duas variáveis do tipo int foram declaradas, mas nenhum valor foi atribuído a elas. O cout é usado para informar ao usuário que deve digitar um número do conjunto dos inteiros para que o programa lhe envie a raiz – se existente -, o cin logo abaixo captura o valor e o atribui a variável “r”. A variável int i é utilizada dentro do parâmetro do for tendo inicialmente seu valor igual zero até r – 1, ou seja:

Se “r” for igual a nove, i = {0, 1, 2, 3,…, 7, 8}, um laço de 0 até 8.

No bloco do for tem os comandos para com este laço:

O controlador de fluxo if que se encontra entre as chaves do for, testa todas as combinações possíveis entre o conjunto de números que foram atribuídos ao “i” dentro do parâmetro do for.

A condição do parâmetro do if será verdadeira quando:

Se “i” vezes “i” for igual a r, execute o cout. Graças ao break o laço é interrompido logo no momento em que o if encontra a raiz, se a raiz não for encontrada entre todas as possibilidades, temos a partir da linha 18 as ações decorrentes:

Se i * i for diferente de r, exiba Raiz Inexistente. Simples e eficiente!

Switch

Muito usado para criar menus em C e C++ estruturado, o Switch tem lá suas semelhanças com as funções do capitulo 11, ora, pois:

O switch recebe um argumento do bloco principal que passa por instruções em seu próprio corpo. As instruções de seu corpo comparam o argumento recebido com um distinto número de alternativas, que podem variar entre qualquer expressão válida em C++. O switch avalia o argumento e o compara com as possibilidades presentes em seu próprio corpo.

O switch pode ser definido entre as chaves de uma função e ao mesmo tempo guardar instruções como chamadas de uma outra função:

switch (d)

{

case 1:

somar();

break;

case 2:

cout << “Maior Abandonado”;

break;

default:

cout << “Numero Invalido!”;

}

Acima, como exemplo, o switch tem o corpo limitado por chaves, entre estas chaves encontram se os cases – casos – que são enumerados pelo programador. Além de números podem receber letras também se a variável que estão esperando for do tipo char. Cada case é encerrada com o comando break, o default não necessita de um comando break sendo que ele é a ultima opção.

Entre os parênteses, o switch tem uma variável denominada “d”, julgando que o argumento recebido no int main seja de tipo esperado e de valor igual a 2, então, o case dois do corpo do switch será acionado – o cout terá permissão para exibir seu conteúdo. Portanto se o valor esperado pelo switch for igual a 1, o case 1 será acionado e a função somar será executada.

Atenção: A condição do switch é de igualdade, ele avalia e compara o valor recebido com o valor de seus cases, sendo assim, não se usam variáveis do tipo bool, muito menos operadores relacionais como Parâmetro do switch.

Qualquer que seja o número digitado – diferente de 1 ou 2 – o default será acionado. Embora não seja obrigatório, o default é muito útil para o tipo de aviso exemplificado acima.

O break determina até onde vai a permissão concedida ao case, por exemplo, se o primeiro break for retirado da sintaxe acima, e se o parâmetro receber o argumento de valor 1  ambos os cases serão executados.

//Menu

# include <iostream.h>

# include <conio.h>

int main()

{

cout << “Quem escreveu o Fantastico, Morbido e Febril\n”

“\tNoite na taverna ?\n\n”;

cout << “\t (1)Machado de Assis!\n”

“\t (2)Lord Byron\n”

“\t (3)Alvares de Azevedo\n”;

cout << “\t (?)Digite um valor de 1 a 3:\n”;

int b;

cin >> b;

switch(b)

{

case 1:

cout << “\t Machado de Assis!”

“\n\t Passou longe”;

break;

case 2:

cout << “\t Lord Byron”

“\n\t Quase!”;

break;

case 3:

cout << “\t\a Alvares de Azevedo”

“\n\t Correto!”;

break;

default:

cout << “\t Nao faz ideia?\n “

“\t Foi Alvarez de Azevedo”;

}

getch();

return 0;

}

O menu foi feito a partir do comando cout. Utilizando-se de seqüência de escape é possível colocar um determinado texto onde desejar. Logo após a conclusão do menu foi declarado uma variável de nome “b” do tipo int, o cin surge para pedir um valor para esta variável através da interação com o usuário.

Esta mesma variável esta entre os parênteses do switch, portanto, a resposta do switch é relativa ao valor atribuído a variável, para cada case uma resposta ou comportamento diferente. Se o número for maior que 3 ou menor que 1 o default será acionado e o cout além dele exibira seu respectivo conteúdo.

O break ao longo de todos os cases delimita até onde pode ser exibido o conteúdo do case, ou seja, o break deve estar presente como último comando do case.

As possibilidades de uso do controlador de fluxo lógico switch são ilimitadas!

<<<Anterior

—————-
Listening to: The Beatles – Oh! Darling
via FoxyTunes

Para realizar uma determinada tarefa que se repete consecutivamente no bloco do programa, temos as funções.

As funções evitam a repetição de um mesmo comando no bloco principal, ou seja, esta suposta repetição e substituída pelo nome da função.  No bloco de uma função há um conjunto de instruções declaradas pelo programador para realizar a tarefa que se repete indeterminadamente. Geralmente as funções utilizam valores – Argumentos – do bloco int main para retorna um outro valor. São também declaradas e definidas assim como as variáveis.

Sempre que uma função é chamada para aplicar suas instruções em uma área qualquer do bloco principal, ela executa algo como uma sub-rotina, a final, ela muda a direção do programa que é naturalmente executado de cima para baixo. Após retorna o valor ou simplesmente terminar a execução de uma função, o programa torna a caminhar normalmente de onde havia parado.

Todo e qualquer programa em C/C++ tem pelo menos uma função, a final, o int main () e uma função! O int main ou função principal como já foi destacado, pode receber argumentos ou parâmetros, e retorna uma variável do tipo int, se o valor atribuído a esta variável for igual a zero significa que não há erros no programa, do contrário…

Declarando & Definindo uma Função

Declarando uma função a partir de seu protótipo:

double somar (int i);

Acima há uma declaração de uma função, ou seja, basta escrever o protótipo de uma função para esta estar declarada. No exemplo acima temos um protótipo de função denominada somar, enominado palavra mos um prototipo o al xo., ela muda a direçterminados pelo criador da funç que retornará um tipo double, o parâmetro é definido pelo (int i) que define o tipo que a função irá receber quando for chamada no bloco principal – int main. A declaração de um protótipo de uma função apresenta ao compilador: a função, seu retorno, o que recebe ou se é do tipo void. Uma função só é compilada se for declarada antes de seu uso.nçapos nç

No bloco principal, a função somar receberá uma variável do tipo int e após esta variável passar pelo bloco da função recebendo todas as instruções lá presentes, sairá como um double.

Definir uma função consiste em escrever seu conteúdo – escrever para função um bloco com instruções:

double somar (int i)

{

double d = 3.6;

return (i + d);

}

Acima temos a definição do corpo de uma função denominada somar, tipo de retorno double e parâmetro int. No corpo da função foi declarada uma variável do tipo double, o identificador recebeu o nome “d” e o valor 3.6, conseqüentemente, a variável criada dentro do escopo da função será somada ao argumento que a função esta esperando. Toda variável criada entre o bloco de uma suposta função é válido somente lá dentro, uma variável é válida onde for criada, com exceções às variáveis globais.

Protótipo, Parâmetro & Argumento

//12° Funções/palavra

# include <iostream.h>

# include <conio.h>

void palavra ();        //ßprotótipo da função palavra, declarado antes do uso

int main ()

{

palavra ();          //chama a função palavra após tê-la declarado acima

getch();

return 0;

}

void palavra ()             //Definição da função palavra();

{

cout << “Brain Damage”;  //dentro do bloco da função palavra

}

O protótipo da função deve ser finalizado com o ponto e vírgula, e deve ser declarado fora de qualquer escopo ou bloco.

Como uma variável, após ser declarada, a função não precisa mais carregar seu tipo de retorno quando for chamada no bloco int main ().

Observe: o bloco da função palavra é delimitado pelas chaves assim como o do main.

Esta função por se tratar do tipo void não retorna valor algum e por não conter parâmetros e argumentos entre seus parênteses (), não recebe valor algum.

//13° Funções/somar

# include <iostream.h>

# include <conio.h>

int somar (int i, int e);        //protótipo da função somar com dois parâmetros

int main ()

{

int a = 10;

int b = 15;

int resultado;                     //ßvariável para guardar o valor da função somar

resultado = somar(a, b);  /*ßchama a função somar e atribui seu valor

de retorno a variável resultado*/

cout << “A + B = ” << resultado;            //ßexibindo o valor da função

getch();

return 0;

}

int somar (int i, int e)                                              //ßfunção somar(int i, int e);

{

return (i + e);                                            //ßdentro do bloco da função palavra

}

Parâmetro refere-se ao tipo que a função recebe, na função somar temos o tipo int ou conjunto dos números inteiro. Argumento refere-se ao valor que são atribuídos para as variáveis que precedem o parâmetro.

No exemplo acima, o protótipo da função somar recebe os parâmetros “int i” e “int e”, em outras palavras, a função somar esta esperando duas variáveis do tipo int. O “i” e o “e” são marcadores, como para primeiro e para segundo, ou para servir de referência para o programador, por isso as variáveis que a função somar esta esperando no bloco do int main foram declaradas com o nome de “a” e “b”, portanto, não é necessário declarar as variáveis do bloco do int main com o mesmo nome dos parâmetros, afinal, uma função não é feita simplesmente para duas variáveis mais para um escopo inteiro. O protótipo da função int somar também poderia ser escrita da seguinte forma:

int somar (int, int );

A função somar, após receber os valores, retorna um número do tipo int, este valor é a soma de a + b dentro do escopo da função.

O int resultado foi criado apenas para capturar o valor de retorno da função. Quando a execução do programa chega a: “resultado = somar (a, b)”, a função somar procura saber se os valores que estão dentro dos parênteses são do tipo esperado, se forem, são enviados para o corpo da função onde as instruções são aplicadas sobre os valores recebidos, no caso, as instruções são: somar os dois valores do tipo int coletados no bloco principal. Se os valores coletados pela função no bloco principal forem diferentes do esperado, a conversão de um tipo para outro pode terminar de forma inesperada.

Recapitulando: Uma função e definida a partir de um protótipo – um cabeçalho – que indica o tipo de retorno e o tipo e quantidade de parâmetros e argumentos que ela recebe, este protótipo deve ser declarado antes da utilização da função – antes dela ser chamada.  O corpo ou escopo de uma função é semelhante ao da função principal int main, nele ocorrem as instruções que se repetem consecutivamente. Uma função do tipo void não retorna valor algum, uma função sem argumentos ou parâmetros não recebe valor algum.

<<<Anterior Próximo>>> Operadores Lógico & Controle de Fluxo

—————-
Listening to: The Beatles – Maxwell’s Silver Hammer
via FoxyTunes

Os operadores matemáticos são utilizados para se fazer “expressões”, no total são 5 os operadores matemáticos de C++, a seguir eles e seus respectivos símbolos:

Adição (+), Subtração (-), Multiplicação (*), Divisão (/) e Módulo (%).

Exceto o ultimo operador – Módulo -, os demais funcionam da forma típica que já conhecemos.

Os parênteses são de uso comum quando se faz uma expressão matemática em C++. Os parênteses determinam qual algarismo ou grupo de algarismo deverá ter prioridade na operação, por exemplo:

1° Sentença     à      3 * 4 + 5 = 17;

2° Sentença      à      3 * (4 + 5) = 27;

Na primeira sentença, o numeral 3 é multiplicado por 4 gerando o valor 12, logo o numeral 5 e adicionado finalizando a operação com o valor 17.

Na segunda sentença, os numerais 4 e 5 são somados gerando o valor 9, logo, o numeral 3 multiplica o valor resultante de 4 + 5 finalizando a operação com o valor 27. Ou seja, quando se há parênteses numa expressão, o código é lido de dentro para fora, do contrário ele é lido da direita para a esquerda obedecendo a prioridade dos operadores – Multiplicação e divisão tem prioridade sobre Adição ou Subtração.

//5° Operadores Matemáticos

# include <iostream.h>

# include <conio.h>

int main ()

{

cout <<”\t Operadores Matematicos”;

cout <<”\n Adicao: 1 + 1 =………………….” <<(1 + 1)

<<”\n Subtracao: 2 – 1 =……………….” <<(2 – 1)

<<”\n Multiplicacao: 3 * 3 =……………” <<(3 * 3)

<<”\n Divisao: 4 / 4 =…………………” <<(4 / 4)

<<”\n Divisao Inteira ou Resto de: 9 % 2 =.” <<(9 % 2);

getch();

return 0;

}

Os pontos adicionados a partir do = são simplesmente para melhorar a visualização do programa quando este for executado.

Divisão Inteira

O operador Módulo é usado quando se necessita do resto de uma divisão entre inteiros:

10 / 3 = 3; resta 1.

Temos o “10” representando o dividendo, o primeiro “3” representando o divisor, o segundo “3” representando o quociente e, por fim, o “1” que representa o resto (nunca negativo).

Deste modo, o quociente vezes o divisor mais o resto são iguais ao dividendo.

Lembre-se, o grupo dos inteiros não admite números fracionários, portanto, para se obter o número restante que adicionado ao resultado da soma entre divisor e quociente seria igual ao dividendo, é necessário utilizar o operador de Módulo.

O exemplo a seguir determina a velocidade média de um corpo que percorre uma distância de 17 km em 3 horas.

//6° Divisão Inteira

# include <iostream.h>

# include <conio.h>

int main ()

{

cout <<” Velocidade Media: Consiste em dividir a distancia”

<<”\n total percorrida por um corpo pelo tempo de\n”

<<”\t\t viagem\n”;

int Distancia = 17, tempo = 3, Velocidade_Media, resta;

Velocidade_Media = (Distancia / tempo);

cout <<”\t\t A Velocidade Media e’: ” << Velocidade_Media

<<” km/h”;

resta = (Distancia % tempo);

cout <<” Resta: ” << resta ;

getch();

return 0;

}

Para maior compreensão:

Se de 9 partes de um determinado produto dividir-mos por duas pessoas:

9 / 2 = 4 resta 1, pois

2 * 4 = 8 + 1 = 9

Este número 1 poderia ser dividido pelas duas pessoas, sendo que cada uma ficasse com 0, 5, mas, como já mencionado acima o grupo dos números inteiros não admite número fracionário, então o 1 deve permanecer inteiro.

Atribuindo Valor a uma Expressão

//5° Operadores Matemáticos 2

# include <iostream.h>

# include <conio.h>

int main ()

{

cout <<”\t Declarando variaveis A, B, C, sem atribuir valor algum:”;

int a, b, c;

cout <<”\n Atribuindo valor para as variaveis”;

a = 10;

b = 20;

c = 30;

cout <<” e exibindo valores”

<<”\n Valor de A: ” << a <<”\n Valor de B: ” << b

<<”\n Valor de C: ” << c;

//Criando variável total para guardar a soma dos valores das variáveis a, b, c

int total;

total = (a + b + c);

//Exibindo o valor de total que é igual a: a + b + c

cout <<”\n A soma dos valores A, B e C = ” << total;

getch();

return 0;

}

Lendo o Teclado

O cin da “família” do iostream atribui a qualidade de ler o teclado aos programas de console – entenda-se por ler: capturar o que for digitado.

O cin será nossa primeira função disposta a receber entrada de dados.

Ele é simples assim com seu parceiro cout, embora seu operador de atribuição seja dois sinais de mais – o cout possui dois sinais de menos.

//10° Cin

# include <iostream.h>

# include <conio.h>

int main ()

{

int numero_digitado;

cout << ” Digite um numero: “;

cin >> numero_digitado;

cout << ” O numero e’: ” << numero_digitado;

getch();

return 0;

}

O exemplo acima exemplifica o simples funcionamento da função cin.

Primeiramente, declaramos um tipo para salvar o valor digitado no teclado, logo após usarmos o cout – que finalizamos naturalmente com o ponto e vírgula – surge o cin, – com seu operador de atribuição >> – o valor digitado é atribuído à variável numero_digitado. O cout volta no fim do código fonte para exibir o valor digitado no teclado.

//10° Somar

# include <iostream.h>

# include <conio.h>

int main ()

{

int pri_parcela, sec_parcela, soma;     //declara 3 variáveis sem atribuir valor

cout << ” Digite a primeira parcela: “;

cin >> pri_parcela;                         //atribui valor para pri_parcela

cout << ” Digite a segunda parcela: “;

cin >> sec_parcela;             // Atribui valor para sec_parcela

soma = (pri_parcela + sec_parcela);             //Atribui valor para variável soma

cout << “\nTotal: ” << soma;              //ßexibindo os valores somados

getch();

return 0;

}

O código fonte acima quando compilado e executado pede para o usuário digitar a primeira parcela – digitar um número qualquer do tipo int – logo, pede para digitar a segunda parcela – digitar outro número qualquer do tipo int -, quando digitado, ambos os valores são salvos em variáveis. O valor das duas parcelas somadas é atribuído a variável denominada soma. No fim do programa o cout exibe o valor da soma das duas variáveis.

O exemplo abaixo exemplifica a captura do tipo char:

//11° Entra de Dados

# include <iostream.h>

# include <conio.h>

int main ()

{

char nome[7];

cout << ” Digite seu nome: “;

cin >> nome;

cout << “\n Seu nome e’ ” << nome;

getch();

return 0;

}

Após o cout exibir a string “Digite seu nome” o cin entra em ação, lembre-se, o programa é lido de cima para baixo. A função cin permite que o usuário digite o nome – que o cout pediu – utilizando o teclado. Após digitar o nome através do teclado, o cin o salva na variável nome do tipo char – que é o tipo apropriado para salvar caracteres.

O char nome é uma variável declarada sem atribuição para receber seis valores digitados a partir do teclado. Se por acaso for digitado um nome ou texto qualquer maior que o esperado (estouro da string), o programa pode se comportar de forma inesperada, se for digitado um espaço entre as palavras o compilador entendera este espaço como o caractere NULL, e finalizará a string, fazendo que somente os caracteres que precederem o espaço sejam salvos na variável. O cout volta no fim do código fonte para exibir o nome digitado.

Cuidado com os erros ocasionados pelo mal uso da função string, o “estouro” dela pode derrubar o sistema facilmente.

<<<Anterior Próximo>>> Funções

—————-
Listening to: The Beatles – Come Together
via FoxyTunes

Os Identificadores ou identifier correspondem as variáveis dos tipos. Todos os tipos para serem usados devem possuir um identificador:

int inteiro;

char caractere;

float flutuante;

O “inteiro” do tipo int, o “caractere” do tipo char e o “flutuante” do tipo float são os identificadores deste exemplo. Um identificador do tipo char não recebe como atribuição: numerais, tanto float quanto inteiro ou de qualquer conjunto que seja, conseqüentemente, são atribuídos aos identificadores valores respectivos a seu tipo.

Literais são os valores carregados nas variáveis dos tipos, exemplo:

int inteiro = 10;

char caractere = ‘C’;

float flutuante = 3.2;

Os valores atribuídos aos identificadores “inteiro”, “caractere” e “flutuante” são considerados literais. No int inteiro, temos o valor 10 atribuído, significa que o sistema reserva espaço na memória para dez identificadores inteiro do tipo int.

A Declaração é quando se cria uma variável de um tipo qualquer, mas não atribui valor algum a esta:

double pi;

Aqui temos uma declaração do tipo double, observe que a direita do identificador “pi” nós temos o ponto e vírgula que representa o fim da declaração.

O operador de atribuição (=) deve ser usado quando se necessita atribuir um valor a variável. Verdade é que se pode declarar a variável e imediatamente atribuir um valor qualquer a ela, embora, às vezes é necessário declarar uma variável sem atribuição alguma. Pode-se também declarar mais de um identificador a um determinado tipo, com ou sem valor atribuído, sendo que devem ser separados pelo operador vírgula (,):

int velocidade = 60,  tempo = 2, Distancia;

Foram declarados três identificadores do tipo int separados pelo operador vírgula, sendo que o identificador Distancia não recebeu valor. A partir de uma operação matemática ou qualquer outro método distinto, pode-se atribuir um valor a ele:

Distancia = (velocidade * tempo);

//4° A Declaração

# include <iostream.h>

# include <conio.h>

int main ()

{

cout <<”\t\t Um veiculo que se movimenta em velocidade constante”

“\n\t\t de 60 km/h, num tempo de 2 horas, conclui-se: \n”;

int velocidade = 60, tempo = 2, Distancia;

Distancia = (velocidade * tempo);

cout <<”\t\t A Distancia percorrida por este veiculo e’ ” << Distancia

<<”km”;

getch();

return 0;

}

<<<Anterior Próximo>>> Operadores Matemáticos

—————-
Listening to: The Beatles – Can’t Buy Me Love
via FoxyTunes

Há tipos básicos em C/C++, divididos em duas variedades, signed e unsigned – com sinal e sem sinal, respectivamente – a seguir a tabela referente aos supostos tipos e suas características:

Tabela 01_Tipos

Quando é adicionado o valor “1” a uma variável de tipo qualquer que tenha já atribuída a ela seu valor máximo, esta retorna ao valor mínimo ou recomeça, por exemplo, um tipo short que possui valor máximo de 32767, se acrescentado 1, ele retornará para seu valor mínimo -32768.

O tipo int e short: é utilizado quando necessário o uso de valores numéricos do conjunto dos números inteiros (Z):

Conjunto Z= {… -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5…}

O conjunto de números inteiros é formado por números positivos, negativos mais o zero – que é maior que qualquer número negativo.

//6° o tipo int

# include <iostream.h>

# include <conio.h>

int main()

{

cout << “2007 menos 1984 e’ igual a: “;   //exibe texto no console

int resultado = 23;          //declara variável resultado e atribui o valor 23 à ela

cout << resultado;   //exibe o valor

getch();

return 0;

}

Neste exemplo temos um uso básico do tipo int. O int foi previamente definido com o identificador “resultado”, o valor (literal) 23 foi atribuído a ele, conseqüentemente o identificador do tipo int armazena o valor 23. Quando se faz uma definição, um quinhão de memória e armazenado para a variável, o tamanho do espaço reservado é relativo ao valor atribuído à variável.

O tipo char: é utilizado para escrever (strings), seu nome já o diz: “Caractere”. Tem geralmente oito bites de tamanho ou um byte que comporta até 256 caracteres.

//7° o tipo char

# include <iostream.h>

# include <conio.h>

# include <string.h>                      //ßpara o uso de string

int main()

{

char texto [27] = “Can’t You Hear me Knocking”;         //ßstring

cout << texto;

getch();

return 0;

}

Acima temos a ilustração do tipo char. Observe que uma biblioteca foi adicionada, trata-se da string que deve ser chamada para a utilização de strings. O char previamente definido com o identificador “texto” suporta uma quantidade antecipadamente definida de caracteres, logo, não se pode introduzir um número de caracteres superior. Observe que à direita do identificador texto entre os colchetes ([]), mesmo tendo o número 27, este tipo char texto suporta apenas 26 caracteres, pois, para finalizar toda string é necessário o caractere NULL que corresponde ao número octogonal ‘00′, sendo assim, uma das “casas” da string é reservada ao NULL para identificar o fim, exemplo:

Declarando variável “palavra” do tipo char e inicia com capacidade para sete caracteres, sendo um reservado para o NULL:

char palavra [7] = “String”;

A palavra String tem seis caracteres, portanto, este número de caracteres corresponde ao máximo que a variável texto do tipo char suporta, estes mesmos caracteres ficam armazenados em posições consecutivas na memória da máquina hospedeira.

Exemplificando o funcionamento de uma string quando executada:

palavra [0] = ‘S’;

palavra [1] = ‘t’;

palavra [2] = ‘r’;

palavra [3] = ‘i’;

palavra [4] = ‘n’;

palavra [5] = ‘g’;

palavra [6] = ’00′;

Quando a string palavra é executada, um laço em cadeia contendo valores atribuídos a ela é lançado na tela em sentido crescente.

A variável “texto” do tipo char que suporta 27 caracteres tem armazenado a frase Can’t You Hear me Knockin, sendo assim, onde ela for declarada a frase passa a existir.

Uma string é uma seqüência ordenada de caracteres.

Não se preocupe se lhe parece complicado, mais a frente vamos voltar a este assunto quando tratar-mos de Arrays.

O tipo float e double: são utilizados para expressar números fracionários ou de ponto flutuante.

//8° o tipo float e double

# include <iostream.h>

# include <conio.h>

int main ()

{

cout << “Qual a velocidade do som em Km/h? “;

int metros_sec = 340;                      //o som no ar tem a velocidade de 340 m/s

double tempo = 3.6;                       //uma hora possui 3.600 segundos ou 3.6s

float resultado;                                //declara variável mas não adiciona valor

resultado = metros_sec * tempo;

cout << “\nA velocidade e’: ” <<resultado << ” Km/h”;

getch();

return 0;

}

Temos acima um exemplo mais sofisticado do uso dos tipos float e double. Como você vê, a variável tempo e igual a um número fracionário, como o tipo int não suporta este conjunto de números, utilizamos os apropriados, float ou double. Note também que a variável do tipo double foi declarada embora sem valor algum. Esta variável – resultado – foi declarada apenas para guardar o valor da multiplicação entre o int metros_sec e o float tempo. Isso ocorre constantemente em linguagens de programação, alguma variável tem que armazenar o valor.

A conversão de tipos nem sempre termina em final feliz! Para provar isso, modifique os tipos do programa acima, por exemplo, inverta o do metros_sec com o do tempo deixando-os float e int, respectivamente.

E por fim, o tipo bool: que é utilizado para expressar dois valores, sendo um por vez, verdadeiro ou falso (true e false), assim sendo, quando o valor de retorno do tipo bool for igual a “1” (um) temos um “verdadeiro”, se for “0” (zero) como retorno significa “falso”.

//9° O tipo bool

# include <iostream.h>

# include <conio.h>

int main ()

{

bool falso = (2 + 2 != 4);

cout<< falso;

getch();

return 0;

}

O tipo bool foi declarado como falso e atribuído a ele a expressão 2 + 2 é diferente de 4. Como a expressão esta incorreta o bool retornará um  zero.

Para comparar o tamanho dos tipos há uma função denominada sizeof que inserindo dentro de seus parênteses um tipo qualquer a função retorna o tamanho. Alguns tamanhos podem variar de plataforma para plataforma. O código fonte a seguir exemplifica o funcionamento da função sizeof:

//9° O Sizeof

# include <iostream.h>

# include <conio.h>

int main ()

{

cout << “>>>>Sizeof<<<<\n”;

cout << “\nbool:   ” << sizeof(bool)  << ” byte”

<< “\nchar:   ” << sizeof(char)  << ” byte”

<< “\nshort:  ” << sizeof(short) << ” byte”

<< “\nint:    ” << sizeof(int)   << ” byte”

<< “\nlong:   ” << sizeof(long)  << ” byte”

<< “\nfloat:  ” << sizeof(float) << ” byte”

<< “\ndouble: ” << sizeof(double)<< ” byte”;

getch();

return 0;

}

A tabela que se obtêm a partir da compilação e execução deste código fonte é semelhante a Tabela 02_Tipos que temos no início deste capítulo embora informe apenas o tamanho dos tipos.

Seqüências de Escape

Alguns caracteres (tipo char) não podem ser representados normalmente como geralmente fazemos, outros para serem apresentados precisam da junção entre dois caracteres. Na tabela a seguir alguns destes caracteres e suas representações entre outras informações.

Tabela 02_Seqüências de Escape

Observe o código fonte a seguir, apresenta o “\n” ou quebra de linha, o “endl” – fim da linha – também é apresentado neste exemplo:

//3° Quebra de linha

# include <iostream.h>

# include <conio.h>

int main ()

{

cout <<”Riding on the highway…”                  //1° linha do cout

“\n     Long way to the top…”             //2° linha do cout

“\n     Think it’s easy\?”                      //3° linha do cout

<<endl;                                                        //4° linha do cout

cout  <<”\n     Try playin’!”;                              //5° linha, outro cout

getch();

return 0;

}

O “\n” é responsável pela quebra de linha, ele da um fim na linha onde se encontra ou na linha atuante enviando o texto seguinte para a linha de baixo. No código fonte que temos acima: o texto “Riding on the highway…”, após o programa ser compilado, tem como lugar a primeira linha do console, a segunda linha inicia-se com um \n – que envia todo o texto da sua direita para a segunda linha. Na quarta linha temos um comando denominado “endl” ou “fim da linha” que descarrega o buffer do cout obrigando o programa a exibir imediatamente o conteúdo e, como o \n, da uma linha nova ao conteúdo.

Observe também que os operadores de inserção (<<) e as aspas orientam o programador, a partir deles você alinha o conteúdo que deseja exibir no console. O programa “Quebra de Linha” exibe as linhas 2°, 3°, 5° uma abaixo da outra, justo por este recurso.

Lembre-se: as aspas – simples ou duplas – devem estar presentes antes da string e depois, sendo que, na mesma linha da string; do contrário o compilador acusara um erro. Por se tratar de um único tipo – caractere – não é necessário utilizar o operador de inserção nas linhas 2 e 3.

Compile ambos os programas e modifique-os para que você se familiarize com os comandos apresentados neles. Naturalmente o botão F9 do teclado compila e executa os arquivos fontes, do contrário clique no botão com o respectivo nome.

Neste seguinte exemplo, apresentamos o uso do número correspondente ao BELL e ao \n em Hexadecimal.

//3° Usando valor Hexadecimal

# include <iostream.h>

# include <conio.h>

int main ()

{

char uvula = 0×07;    //atribui o valor 0×07 a uma variável de tipo caractere

char QuebrarLinha = 0x0A;

cout << QuebrarLinha      //usa o valor do ‘\n’ atribuído a variável

<<”Bells”<<uvula;    //usa o valor do ‘\a’ atribuído a variável

getch();

return 0;

}

Se a uma variável do tipo char – caractere – for atribuído o valor hexadecimal do BELL, passa esta variável a “carregar” o valor a ela aplicado.

<<<Anterior Próximo>>> Identificadores, Constantes Literais & Declaração

—————-
Listening to: The Beatles – Wait
via FoxyTunes

O código fonte C++ gera diversos arquivos quando compilado, portanto, numa determinada região de seu computador crie uma pasta com o nome Omni.  Nesta pasta salve todos os documentos derivados deste estudo, – cada exemplo em uma sub-pasta. Logo você verá que: “A organização é um passo para o triunfo em qualquer linguagem de programação que seja!”

A seguir um tutorial a respeito do Kdevelop IDE e do Bloodshed Dev-C++.

O tutorial é básico, por hora, lhe será dito o que é necessário saber sobre ambos.

Abra seu bloco de notas ou sua IDE.

Como usar o Kdevelop IDE

Primeiro passo: Crie um novo projeto com o Help do Kdevelop Application Wizard. Use o Project Type – ou tipo de projeto – Terminal C++.

Segundo passo: Edite seu arquivo de código fonte com o editor do Kdevelop e compile-o utilizando um dos botões do menu.

Como usar o Bloodshed Dev-C++

Primeiro passo – Projeto: No menu Arquivo passe o mouse sobre Novo e clique em Projeto, surgirá uma janela com diversas opções divididas em três categorias: Basic, Introduction e Multimedia. Cada uma seria um degrau como seus próprios nomes sugerem.

Na Basic, clique em “Console Aplication” e selecione mais à baixo: Projeto C++, se já não o esta. Após clicar em “Ok” o Dev abrirá uma tela para salvar o projeto, de ao projeto um nome, os caracteres válidos para nomear um programa são: a até z e A até Z. Os sinais válidos são:

& ( ) [ ] { }  + – * / = , . : ; ? \ ” ’ _ | ! # $

Salve-o na pasta Omni.

O Primeiro não se Esquece

Para escrever um código fonte decente você deve incluir Bibliotecas. Aqui neste exemplo, temos duas: iostream e conio. A primeira é uma biblioteca para entrada e saída de dados, ela nos fornece o comando “cout” – Console Out ou simplesmente c out – seguido do operador de inserção “<<”, o cout nos permite escrever frases ou “Strings” e numerais no console.

//1° Primeiro Programa

# include <iostream.h>

# include <conio.h>

int main ()

{

cout  << “Stairway to Heaven”;

getch();

return 0;         //retorna zero

}

Repare que a frase Stairway to Heaven esta entre aspas (“ ”), para se escrever diretamente no console sem utilizar uma variável que salve o valor, você deve utilizar este procedimento, quando se trata de um numeral não se deve usar aspas e quando for um único caractere utilize aspas simples (‘ ‘). O ponto e vírgula (;) determina o fim da operação. O getch () fornecido pela biblioteca conio paralisa a tela do console, ou seja, o programa quando executado exibe a frase rapidamente e fecha a tela do console, o getch () a paralisa até que uma tecla qualquer seja digitada – experimente retirá-lo para conferir o resultado. O return e uma palavra reservada do C/C++, como ele há muitas outras palavras reservadas, logo há frente temos a tabela com as palavras de uso único do C/C++. O return da um comando ao programa para que ele finalize naturalmente após exibir o conteúdo do cout e recomece a partir de onde ele foi chamado, portanto se não há nada adiante dele, o programa é finalizado naturalmente. O zero é o valor de retorno, ou seja… nada.

O iostream, o conio entre outros, são arquivos Standard do C++, em outras palavras, são Bibliotecas padrões. Somente Arquivos Standard do C++ devem ficar entre os sinais de mais e menos < >, portanto, todos os arquivos de recurso criados pelo programador devem ficar entre aspas, mais a frente você compreenderá com perfeição este comentário.

Todo programa escrito em C/C++ deve ter como corpo principal o int main (), que nada mais é que a função principal. Todas as funções recebem valores de entrada denominados Parâmetros ou Argumentos, e retornam um determinado valor, no caso, o valor de retorno do int main trata-se: de um tipo inteiro (int). Funções que não retornam valor algum são denominadas “void”. Atenção, a função int main – função principal presente em todos os programas C/C++ – sempre retorna um tipo inteiro exceto quando esta é void.

Todo o código do programa é delimitado pelas chaves {} ou block statement, onde a primeira determina o início do bloco do programa e a segunda o fim do bloco.

Em C++ caracteres maiúsculos são diferentes de minúsculos, como exemplo: cout e um comando derivado da biblioteca iostream se, por acaso, for escrito com caracteres maiúsculos não executará a função de imprimir mensagens na tela, ou seja, “A” é diferente de “a” em C++.

Como em toda linguagem que se preze, existe a possibilidade de escrever comentários no código fonte – para orientar um outro programador que venha a ler o código ou mesmo para auxiliar o dono.  No C++ há duas maneiras de se escrever comentários: do modo dele mesmo e do modo do C.

Veja no exemplo a seguir como fazer comentários:

//2° comentários

# include <iostream.h>                 //cout

# include <conio.h>                       //getch()

int main ()

{

cout << 300;  /*  1° – Comentário

de diversas linhas. */

getch();           // 2° – Comentário de uma linha.

return 0;

}

O primeiro comentário foi herdado do C, já o segundo é o comentário de C++. O primeiro permite escrever em quantas linhas desejar o, conteúdo é delimitado pelos caracteres /* */, todo conteúdo que estiver entre eles será ignorado pelo compilador; o segundo permite escrever em uma única linha, a partir da direita das duas barras (//) o código será ignorado pelo compilador.

Cabe ao programador decidir qual é o ideal para uma determinada região do código fonte, verdade é que: ambos são úteis.

Free Format

Um programa em C++ também pode ser escrito da seguinte forma:

//4° Formato Livre

# include <iostream.h>

# include <conio.h>

int main () { cout << ”The Door’s are open!”;  getch();  return 0; }

Não há ordem previamente padronizada para se escrever um código fonte que funcione, o compilador não observa a distribuição dos caracteres, mas, tenha sã consciência que: em um código fonte de mil linhas escrito desordenadamente seria um caos tentar encontrar um “goto”… Com isso, temos o que chamamos de indentação. O Dev-C++ tem uma opção denominada “Auto Indentar” – que não faz milagre, mas ajuda – para acessá-la: Clique em Ferramentas, logo em Opções do Editor, marque as opções Auto Indentar e aproveite para marcar Tabulação Inteligente também.

PS: As diretivas # include devem estar separadas.

<<<Anterior Próximo>>> Os Tipos & Seqüência de escape

—————-
Listening to: The Beatles – Girl
via FoxyTunes

O Ming é um compilador gratuito e baseado no gcc da Gnu, produzido para trabalhar em Dos e Windows. Siga o link para baixá-lo:

http://www.xraylith.wisc.edu/~khan/software/gnu-win32/

Há também o djgpp, que é um exímio compilador. Encontra-se em:

http://www.delorie.com/djgpp/

O Unix e suas implementações vêem com compilador como parte integrante. Sendo assim, digite no Shell “g++ -v” para saber qual a versão que você possui. Para compilar um programa em Unix digite:

“g++ nome_do_programa.cpp”

Para os iniciantes Windows… bom mesmo seria uma IDE, sugerimos o Bloodshed Dev-C++: Bom, Bonito e Gratuito! Produzido com a linguagem de programação Delphi, que ironia, hein? Encontra-se em:

http://www.bloodshed.net/dev/devcpp.html

Para os usuários de GNU/Linux, Unix; temos a IDE Kdevelop, que é um ambiente de programação completo, possui como parte integrante a biblioteca qt (toolkit gráfico):

http://www.kdevelop.org/

<<<Anterior Próximo>>> Iniciando Em C++

—————-
Listening to: The Beatles – Michelle
via FoxyTunes