introdução linguagem c++

1

CEFET-SP CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE SÃO PAULO CURSO DE ENGENHARIA AUTOMAÇÃO E CONTROLE PROF. FRANCISCO VERÍSSIMO LUCIANO

INTRODUÇÃO À LINGUAGEM

2

ÍNDICE 1. Definições...........................................................................................................................3

1.1 Programas de computador ..........................................................................................3 1.2 Arquivos e programas.................................................................................................3 1.3 Linguagem de programação .......................................................................................3 1.4 O Borland C++ ...........................................................................................................4 1.5 Linguagem C ..............................................................................................................4 1.6 C++.............................................................................................................................4 1.7 Origem do C++...........................................................................................................5

2. DIGITANDO UM PROGRAMA EM C++ .......................................................................5 2.1 Arquivos Header e Diretivas #include .......................................................................6 2.2 Funções e a main()......................................................................................................7 2.3 Input/Output ...............................................................................................................7 2.4 Identificadores ............................................................................................................7 2.5 Compilando o programa .............................................................................................7 2.6 Compreendendo os Erros de Sintaxe..........................................................................9

3. VARIÁVEIS.......................................................................................................................9 3.1 Nomes de variáveis...........................................................................................................9 3.2 Tipos de variáveis.............................................................................................................9 3.3 INICIALIZANDO VARIÁVEIS ...................................................................................10

4. COMPARAÇÕES ............................................................................................................11 5. OPERADORES................................................................................................................11

5.1 PRECEDÊNCIA DE OPERADORES...........................................................................11 5.2 Ordem de avaliação ........................................................................................................12 5.3 Operador De Incremento e decremento..........................................................................12 5.4 Operadores Aritméticos de atribuição ............................................................................12 5.5 Operadores Relacionais ..................................................................................................12 5.6 Operadores Lógicos........................................................................................................12 5.7 Operador Condicional Terciário.....................................................................................12

6. COMANDOS DE DECISÃO – ESTRUTURA CONDICIONAL ..................................13 6.1 O comando "IF"..............................................................................................................13 6.2 O Comando "IF-ELSE" ..................................................................................................14 6.3 O comando "IF-ELSE-IF" ..............................................................................................14 6.4 IF’s ANINHADOS.........................................................................................................14 6.5 SWITCH.........................................................................................................................14

7. COMANDOS DE REPETIÇÃO......................................................................................15 7.1 Flexibilidade do laço "For".............................................................................................16 7.2 O laço "While"................................................................................................................16

8. LISTA DE EXERCÍCIOS................................................................................................17 8.1 Exercícios Resolvidos ....................................................................................................17 8.2 Exercícios Propostos .....................................................................................................21

3

INTRODUÇÃO À LINGUAGEM C++

1. Definições

1.1 Programas de computador

São também conhecidos como software, eles, são formados por uma série de instruções que o computador executa. Quando um programa é criado, é preciso especificar as instruções que o computador precisará executar para realizar as operações desejadas.

O processo de definir as instruções que o computador deverá executar é conhecido como programação.

1.2 Arquivos e programas De uma maneira geral, tudo o que manipulamos no computador são os arquivos. Arquivo é um conjunto de registros agrupados segundo uma regra organizacional e que contém informações sobre uma determinada área de atividade. Tudo no computador é armazenado sob a forma de arquivo, os seus programas, os programas do fabricante, os textos digitados e os dados. Um arquivo cujos registros são instruções ou comandos para o computador executar, é um programa. Todo programa é um arquivo, mas nem todo arquivo é um programa. Depende exclusivamente do conteúdo.

1.3 Linguagem de programação Os seres humanos podem comunicar-se com os computadores exatamente como se comunicam entre si: através de uma linguagem estabelecida. Se os participantes usam a mesma linguagem, a comunicação é direta, e não requer tradução. Entretanto, pessoas falando linguagens diferentes também podem se comunicar, se uma é bilingüe e pode traduzir a linguagem do outro para a sua própria. Nos primórdios dos computadores, os programadores eram forçados a escrever seus programas como seqüências de códigos numéricos. Dizia-se que estes programas eram escritos em linguagem de máquina. A linguagem de máquina potencialmente produz os programas mais eficientes porque permite controlar diretamente o "cérebro" do computador - o seu processador - com um mínimo de tradução de código para sinal elétrico. Mas esta conveniência tem um preço: a programação em linguagem de máquina requer que as instruções sejam entradas em forma numérica, como grupos de dígitos binários ou hexadecimais. Por exemplo, para entrar uma instrução de adição em linguagem de máquina deveríamos introduzir o padrão binário 10000011 no computador, ou seu equivalente hexadecimal 83. Similarmente, para uma instrução de subtração, deveríamos introduzir o padrão binário 00101101, ou seu equivalente hexadecimal 2D. Como seria de se esperar, este procedimento além de demorado e difícil, é extremamente sujeito à erros. Com o passar dos tempos, os computadores foram usados para resolver problemas cada vez mais complexos (significando muitas vezes, maiores programas), e alguém teve a idéia de substituir cada código numérico pela abreviatura de uma palavra em inglês, que os programadores pudessem facilmente recordar. Assim, instrução de adição seria representada pela abreviatura ADD, ao invés do binário 10000011, e uma instrução de subtração seria representada por SUB ao invés de 00101101. Isso, é claro, também requer um programa adicional para converter as abreviaturas em códigos numéricos que o computador pudesse reconhecer. O programa que faz estas conversões é chamado de assembler (montador) e a gama de abreviaturas possíveis que o assembler pode converter é chamada de linguagem assembly (de montagem).

4

Num nível acima estão as linguagens que fazem a linguagem de máquina completamente "transparente" para o programador, substituindo um grupo inteiro de instruções de nível de máquina por uma única palavra ou frase em inglês. Estas linguagens de "alto nível" (tais como BASIC, Pascal, FORTRAN ou C) permitem desenvolver programas muito mais rapidamente do que com linguagem assembly. Neste caso, o programa tradutor poderá ser um interpretador ou um compilador. Os termos compilador e interpretador se referem à maneira como um programa é executado. Na teoria, qualquer linguagem de programação pode ser tanto compilada como interpretada, mas algumas linguagens são geralmente executadas de uma maneira ou de outra. Por exemplo, BASIC é geralmente interpretada, e C é geralmente compilada. O modo como um programa é executado não é definido pela linguagem em que ele é escrito. Os interpretadores e os compiladores são simplesmente programas sofisticados que operam no código-fonte de seu programa (arquivo que contém as instruções em "inglês" como ele foi escrito). Um interpretador lê o código-fonte de seu programa uma linha de cada vez e efetua as instruções específicas que estão na linha. Um compilador lê todo o programa e depois o converte em código-objeto, que é uma tradução do código-fonte do programa para uma forma que o computador possa executar diretamente. O código-objeto é também chamado de código binário ou código de máquina. Depois de compilado o programa, o código-fonte não será mais necessário para a execução deste. Arquivo executável é um arquivo que contém um programa que já foi compilado e está

pronto para rodar.

1.4 O Borland C++ É um ambiente de desenvolvimento de software que inclui um compilador bem como outras ferramentas. No campo da computação existem muitas linguagens de programação. Para cada linguagem, existem muitos compiladores diferentes, vendidos por várias empresas.

1.5 Linguagem C É uma linguagem de programação que está em algum lugar entre uma linguagem de alto nível e uma de baixo nível

1.6 C++ É uma linguagem de programação orientada a objetos. Cada nova versão de um novo programa ou aplicativo, é maior que o seu antecessor e contém mais recursos. Uma coleção dessas novas idéias está baseada em uma nova filosofia chamada programação orientada a objetos. Apesar de programas orientados a objetos poderem ser escritos em linguagem C mas, esta linguagem não oferece certos recursos necessários. Por exemplo: o c não oferece nenhum recurso para proteger variáveis contra acessos não autorizados. C também não permite que uma classe seja declarada como subclasse de outra. Esses novos recursos foram acrescentados na linguagem C e esta nova linguagem foi chamada de C++. Borland C++ pode ser usada como plataforma de desenvolvimento tanto para programas estruturados por procedures (por procedimentos) como programas orientados a objetos. Ao criar um programa, armazena-se as instruções em um arquivo ASCII cujo nome normalmente contém a extensão c para um programa C, e cpp para um programa C/C++. Por Exemplo, um arquivo de folha de pagamento feito no C, poderia ser chamado de folha.c e, se fosse no C++ seria chamado folha.cpp.

5

Quando se criam programas, as instruções desejadas devem ser especificadas usando uma linguagem de programação. C e C++ são somente duas dentre as muitas que existem. Cada linguagem de programação oferece certos recursos exclusivos, e tem seus pontos fortes e fracos. Em todos os casos, existem para permitir que definamos as instruções que queremos que o computador execute. As instruções que o computador executa são, na verdade, séries de 1s e 0s, (dígitos binários) que representam os sinais eletrônicos que ocorrem dentro do computador. Para programar os primeiros computadores (nos anos 40 e 50), era preciso compreender como eram interpretadas diferentes combinações de 1s e 0s, pois, os programas eram escritos usando dígitos binários. À medida que ficaram maiores, ficou inviável trabalhar com esses dígitos, por isso, foram criadas as linguagens de programação.

1.7 Origem do C++

2. DIGITANDO UM PROGRAMA EM C++

1. Abra o O Borland C++ - Versão 3.1;

2. Selecione a opção New no menu File. O Borland C++ - Versão 3.1 criará o arquivo noname00.cpp.

3. Digite o seguinte código na janela noname00.cpp:

main()

{

}

4. Selecione a opção Save As no menu File. O Borland C++ - V. 3.1 exibirá a caixa de diálogos Save File As.

5. Dentro da caixa de diálogo Save File As, digite o nome primeiro.cpp e pressione Enter. O Borland C++ - V. 3.1 salvará o arquivo de programa primeiro.cpp.

Todo início de instruções deverá ser aberta uma { (CHAVES) e todo término de instruções deverá ser fechada uma } (CHAVES).

BCPL SMALLTALK

C

C++

Java

linguagem pioneira e de sucesso em conceitos de

orientação a objeto

6

Quando o programa começa ele executa o código de inicialização e chama uma função especial main(), onde é colocado o código primário para o programa. Função é um conjunto de instruções com um nome que desempenha uma ou mais ações.

{ e } são usadas para expressar agrupamentos em C++. No exemplo, indicam o início e o fim do corpo da função vazia main() . Cada programa feito em C++ precisa ser inicializado com a função main().

Tipicamente, um programa possui uma ou várias saídas. Exemplo:

1. Abra o O Borland C++ - Versão 3.1;

2. Selecione a opção New no menu File. O Borland C++ - Versão 3.1 criará o arquivo noname00.cpp.

3. Digite o seguinte código na janela noname00.cpp:

//Programa Boa Noite

#include <iostream.h>

void main()

{

cout<< “Boa Noite!/n”;

}

4. Selecione a opção Save As no menu File. O Borland C++ - V. 3.1 exibirá a caixa de diálogos Save File As.

5. Dentro da caixa de diálogo Save File As, digite o nome boanoite.cpp e pressione Enter. O Borland C++ - V. 3.1 salvará o arquivo de programa boanoite.cpp.

A linha #include <iostream> instrui o compilador a incluir as declarações das facilidades de um fluxo de entrada e saída padrão encontradas na biblioteca <iostream.h>. Sem esta declaração, a expressão cout << “Boa noite!\n” não faria sentido. O operador << (colocar em) escreve seu segundo argumento no primeiro. Neste caso, o string “Boa noite!\n” é escrito no fluxo de saída padrão cout. Um string é uma seqüência de caracteres entre aspas duplas. As aspas servem para o compilador entender o texto delimitado, isto é para que ele não processe os caracteres circundados como se fossem instruções de programas ou com outros comandos. Em um string, o caracter “\” seguido por outro caracter denota um caracter especial.; neste caso “\n” é o caracter de nova linha, então é escrito, “Boa noite!”, seguido de outra linha.

Sempre que um comando termina, é necessário ser determinado com um ponto e virgula.

Os comentários podem ser feitos de duas maneiras: ou eles começam com “/*” e terminam com “*/” ou eles utilizam “//” sem finalização.

2.1 Arquivos Header e Diretivas #include

Cada implementação de C++ vem com uma biblioteca de funções pré-definidas, operadores e outras entidades. Programas são estimulados a utilizar estas entidades pré-definidas, mas primeiro precisam declará-las em cada arquivo fonte no qual são utilizadas. Para evitar que os programas tenham que memorizar as declarações necessárias e escrevê-las repetidamente, são fornecidos vários arquivos header, cada um contendo as declarações para uma certa parte da biblioteca. Um arquivo header é inserido em um programa através da diretiva #include, a qual, o pré-processamento troca pelo conteúdo do arquivo header. No exemplo anterior, o programa “Boa noite!\n” usa as facilidades da biblioteca para o fluxo de saída, onde as declarações necessárias

7

estão contidas no arquivo header iostream.h que o programa inclui com a diretiva #include <iostream.h>.

2.2 Funções e a main()

Os blocos básicos da construção dos programas C++ são funções, que correspondem a funções, procedimentos e subrotinas em outras linguagens. Cada função implementa um conjunto de procedimentos logicamente relacionados para a execução de uma operação bem definida. Uma função é chamada ou invocada sempre que a operação é necessária. Funções podem ser definidas no programa ou podem ser pré-definidas da biblioteca.

Quando as funções de uma biblioteca são utilizadas, os arquivos header contendo as declarações necessárias devem ser incluídos. As funções recebem uma lista de parâmetros, que pode ser vazia. Neste caso, parênteses são associados com funções e sempre aparecem nas declarações, definições e chamadas de funções. Quando um nome de função aparece no código, é convenção do C e do C++ que um par de parênteses seja colocado após o nome da função para indicar que o nome diz respeito a uma função. Se não tiver nada entre os parênteses significa que a função não possui argumentos. Funções também retornam apenas um ou nenhum valor (quando o retorno é do tipo void).

Quando um programa é executado, a primeira função que ele chama é a main().

2.3 Input/Output

No C++ a entrada é lida de e a saída é escrita em streams, sendo que o tipo da variável determina o tipo de valor de entrada e/ou saída. Quando iostream.h é incluída em um programa, vários streams padrão são definidos automaticamente. O stream “cin” é usado para entrada, que normalmente consiste em uma leitura do teclado. O stream “cout” é usado para saída, que normalmente é enviado para o monitor. O operador de inserção “<<” insere dados em um stream, e o operador de extração “>>” retira dados de um stream e armazena-os em variáveis. Quando um string (série de caracteres que aparecem entre aspas) é inserido em cout, o seu conteúdo é imprimido. Se cin não for explicitamente redirecionado, a entrada será feita através do teclado. C++ usa seqüências escape para representar caracteres que não são representados por símbolos tradicionais como a, b e c. Uma seqüência escape consiste no caracter \ seguido de uma letra ou número. Algumas seqüências comuns são \n (nova linha), \a (alerta), \t (tab) e \” (insere aspas em um string).

2.4 Identificadores

Um identificador consiste em um conjunto de letras, dígitos ou _, sendo que o primeiro caracter deve ser obrigatoriamente, uma letra (incluindo_). Um identificador não poder ser igual a uma palavra reservada. C++ diferencia letras maiúsculas de minúsculas, portanto ‘nome”, “Nome” e “NOME” são três identificadores diferentes. Deve-se evitar a criação de identificadores que comecem ou terminem com _, a menos que eles já sejam definidos pela implementação de C++, pois este usa tais identificadores para evitar conflitos com identificadores criados pelo programador.

2.5 Compilando o programa

No exemplo anterior, você criou o arquivo-fonte, boanoite.cpp, que contém o comando cout que exibirá a mensagem Boa noite! na sua tela quando você executar o programa.

Um arquivo-fonte contém instruções em um formato que você pode compreender (ou pelo menos poderá compreender após aprender C). Um programa executável, por outro lado, contém instruções expressas como 1s e 0s que o computador compreende. O processo de converter seu arquivo-fonte C em código de máquina é chamado compilação. Dependendo do compilador C que você estiver usando, diferirá o comando

8

que você precisa executar para compilar seu arquivo-fonte. No caso do Borland C++ - Versão 3.1, o comando utilizado para compilar um arquivo-fonte é CTRL + F9.

No Borland C++ - Versão 3.1, existe um comando para você só compilar, um outro, caso você prefira, para compilar e executar imediatamente após a compilação. Para compilar e executar basta entrar no menu Run e selecionar Run ou pressionar CTRL + F9.

Para ver o que o programa boanoite.cpp faz, pressione CTRL + F9 para compilar e executar o teste. Se a mensagem "Success: press any key" aparecer na tela, é sinal que o seu programa não contém nenhum erro, e foi compilado com sucesso, pedindo que você pressione qualquer tecla. Se o compilador não criar o arquivo boanoite.exe, mas, em vez disso exibir mensagens de erro na sua tela, provavelmente é porque foi violada uma regra de sintaxe de C.

Se os comandos c foram digitados sem erro, o compilador C criará um arquivo executável chamado boanoite.exe.

Quando o programa for executado, sua tela exibirá a seguinte saída: Boa Noite!

Só que ele será executado e voltará imediatamente para a tela de edição. Para ver o que aconteceu basta pressionar ALT + F5.

Podemos também utilizar um comando que paralisa o resultado na tela. É o comando getch() . Se você utilizar o comando getch(), não será necessário utilizar o comando ALT + F5, basta compilar e ele paralisará o resultado na tela.

Para utilizar este comando é necessário declarar uma outra biblioteca. A biblioteca a ser utilizada será a conio.h. Veja o exemplo segundo.cpp logo abaixo para ver como ficará o programa.

1. Entre no menu File e selecione New no Borland C++ - V. 3.1 para iniciar um novo arquivo.

2. Digite o seguinte programa escrito abaixo na janela noname01.cpp:

#include <stdio.h> #include <conio.h> void main(void) { cout<< "Aprendendo Linguagem de Programação!"; getch();

}

3. Salve o arquivo com o nome de segundo.cpp.

4. Pressione CTRL + F9.

O programa será compilado e executado, mostrando a Mensagem Aprendendo Linguagem de Programação. Observe que o resultado permanecerá na tela como previsto anteriormente. Para voltar a tela de edição, basta pressionar qualquer tecla.

Se você pressionar CTRL + F9 mais uma vez, o Borland C++ jogará novamente o resultado na tela só que ficará junto com o último resultado. Ficará dessa forma:

Aprendendo Linguagem de Programação!Aprendendo Linguagem de Programação

9

Então, para não acontecer isto, recomenda que se limpe a tela toda vez que o programa for executado. O comando clrscr() será usado para fazer isso. Sendo assim, toda vez que o programa for compilado (CTRL + F9) a tela será limpa e impresso o resultado apenas do arquivo que está sendo executado no momento.

Só é possível utilizar o comando clrscr() quando a biblioteca conio.h for declarada.

2.6 Compreendendo os Erros de Sintaxe

Toda linguagem de programação tem um conjunto de regras, chamadas regras de sintaxe, que precisam ser obedecidas no momento da especificação dos comandos. Se for violada uma regra de sintaxe, seu programa não será compilado com sucesso. Em vez disso, o compilador exibirá mensagens de erro na tela que especificam a linha do programa que contém o erro e uma breve descrição do erro

Para corrigir os erros de sintaxe dentro de seus programas, acompanhe os seguintes passos:

A) Escreva o número da linha de cada erro e uma breve descrição. B) Edite seu arquivo-fonte, movendo o cursor para o número da primeira linha que o

compilador exibir. C) Dentro do arquivo-fonte, corrija o erro e mova o cursor para o número da próxima

linha. A maioria dos editores exibe o número da linha atual para lhe ajudar a localizar linhas específicas dentro do arquivo.

3. VARIÁVEIS

Variáveis – espaço de memória reservado para armazenar tipos de dados, com um nome para referenciar seu conteúdo. Observações importantes � Todas as variáveis devem ser declaradas antes de serem usadas. � Mais de uma variável do mesmo tipo: separam-se seus nomes por vírgulas.

3.1 Nomes de variáveis

� Escolher nomes significativos; � Apenas 32 caracteres do nome da variável são considerados. � Pode-se usar quantos caracteres forem necessários, sendo o primeiro,

obrigatoriamente, uma letra ou o caracter “_”.

3.2 Tipos de variáveis

Tipo Descrição Gama de valores Bits

Int número inteiro -231 a 231-1 (-2147483648 a 2147483647)

32

Float número decimal (com vírgula)

1.17549435 × 10-38 a 3.40282347 × 1038 (e negativos)

32

Char caractere (usa código ASCII)

Qualquer caractere. Exemplos: 'a', 'A', '1', '!', '*', etc.

8

Short [int] número inteiro -215 a 215-1 (-32768 a 32767) 16 Unsigned short [int]

número inteiro positivo

0 a 216-1 (0 a 65535) 16

Unsigned [int] número inteiro positivo

0 a 232-1 (0 a 4294967295) 32

Long [int] número inteiro a mesma que int 32 Unsigned long [int]

número inteiro positivo

a mesma que unsigned int 32

10

Double número decimal de precisão dupla

2.2250738585072014 × 10-308 a 1.7976931348623157 × 10308 (e negativos)

64

Long double número decimal de precisão tripla

3.36210314311209350626e × 10-4932 a 1.18973149535723176502 × 104932 (e negativos)

96

a) Tipo int: � Representam inteiros. � long int – aumenta a capacidade de armazenamento do int. � unsigned int – faz o programa aceitar apenas valores positivos, economizando

memória. Regras: � Número positivo – não é necessário o sinal de +. � Números negativos – usa-se o sinal de -. � Pontos decimais não podem ser usados quando escrevemos inteiros. � Vírgulas não podem ser usadas para escrever inteiros. b) Tipo float: � Representação de números reais. � Sinais: como em int. � Valores devem ser expressos com o uso de ponto. Ex : 10.34 c) Tipo double: � Semelhante ao float, porém com mais memória. d) Tipo char: � Representação de caracteres. � Incluem letras do alfabeto (maiúsculas e minúsculas), dígitos de 0 à 9 e símbolos

especiais, tais como #, &, !, +, -, *, /, etc. � Devem ser escritos entre apóstrofos. String : � Não é uma variável. � Representa conjunto de caracteres. � Aparece entre aspas. EX: letra=”A”;

3.3 INICIALIZANDO VARIÁVEIS É possível combinar uma declaração de variável com o operador de atribuição para que uma variável tenha um valor inicial no instante da sus declaração. Exemplo:

#include<iostream.h> #include<conio.h> void main( ) { int evento=5; //cria a variável do tipo inteiro que recebe o valor 5 char corrida=’C’; //variável do tipo caracter que recebe o valor C float tempo = 27.25; //variável real que recebe 27.25 cout<<”\nTempo: “<<tempo; cout<<”\nCorrida: “<<corrida; cout<<”\nCompetição: “<<evento; getch( ); }

11

4. COMPARAÇÕES

PORTUGOL C++ � = = ==

<> != < < > >

<= <= >= >= / /

Div / Resto %

E && OU ||

NÃO ! Se if

Senão else senão se else if Enquanto while

Para for Inteiro int Real float

Caracter char

5. OPERADORES Atribuição : = Ex: x=3; x=y=3; Aritméticos: +, -, *, /, %. OBS: / (divisão inteira)

% (resto da divisão – módulo) Ex: int result, resto;

result = 5/2; //o conteúdo de result será 2 (parte inteira) resto=5%2; // o conteúdo de resto será 1 (resto da divisão)

5.1 PRECEDÊNCIA DE OPERADORES Forma de avaliação da expressão.

int x=5, y=3, z=1, n; n=z + y*x; //O valor de n será 16

O operador * tem precedência maior que o operador +. O uso de parênteses pode mudar essa ordem. Expressões entre parênteses são avaliadas primeiro. n = (z + y) * x; //O valor de n será 20 Os operadores + e - têm a mesma precedência e a regra de associatividade é da esquerda para a direita. Os operadores *, / e % têm a mesma precedência e associatividade da esquerda para a direita. n = z % y / x //o resto da divisão de z por y será dividido por x.

12

5.2 Ordem de avaliação � Parênteses � *, /, % � + , -

5.3 Operador De Incremento e decremento X= X + 1; X++; X--; (pós-fixados) ++X, --X; (pré-fixados) EX: a = x + y; �a=8 x=3 e y=5 a = x++; �a=3 e x=4 // a atribuição precede o incremento mas não a soma a = ++y; �a=6 e y=6 //incrementa o y e atribui ao a.

(a = y = y+1)

5.4 Operadores Aritméticos de atribuição += ( exemplo: x + = 6 � x = x + 6 ) *= ( exemplo: x * = 6 � x = x * 6 ) /= ( exemplo: x / = 6 � x = x / 6 ) -= ( exemplo: x - = 6 � x = x - 6 ) %= ( exemplo: x %= 6 � x = x % 6)

5.5 Operadores Relacionais OPERADOR SIGNIFICADO == Igual a > Maior que < Menor que >= Maior ou igual a <= Menor ou igual a != Diferente

5.6 Operadores Lógicos

OPERADOR SIGNIFICADO && E || OU ! NÃO

5.7 Operador Condicional Terciário ?: valor = (a>b)?a:b; //se for verdadeira, pega o valor anterior aos dois pontos e armazena na variável valor Exemplo: Resposta = (a+b>c)?a:b; a = 3; b = 2 c = 5

13

Analisando a expressão, veremos que o seu resultado será FALSO. Logo, o valor armazenado em resposta será 2.

ANALISANDO UM PEQUENO EXEMPLO

1 #include<iostream.h> 2 //Programa Exemplo 1 3 void main( ) 4 { 5 int idade; 6 idade=22; 7 cout<<”A minha idade é”<<idade; 8 } 1a linha: inclui um arquivo de biblioteca (conjunto de funções existentes no ambiente Borland C++) 2a linha: comentário 3a linha: declaração da função principal 4a linha: início da função principal 5a linha: determinando uma variável 6a linha: atribuição do valor 22 para a variável idade. 7a linha: impressão de uma mensagem e o conteúdo da variável idade. 8a linha: fim da função principal.

6. COMANDOS DE DECISÃO – ESTRUTURA CONDICIONAL Até o momento, estudamos apenas a estrutura seqüencial, ou seja, a estrutura na qual as ações são executadas seqüencialmente, na ordem que aparecem no programa. Na estrutura condicional é possível determinar qual será a ação a ser executada, com base no resultado de uma expressão condicional

6.1 O comando "IF" Sintaxe do comando if if ( condição) { instrução 1; instrução 2; instrução 3; } Exemplo: #include<iostream.h> #include<conio.h> void main ( ) { int anos; cout<<”Quantos anos você tem? “: cin>>anos; if (anos<30) cout<<”\n Você é muito jovem!”; getch( ); }

14

6.2 O Comando "IF-ELSE" Neste caso temos dois blocos de ações (instruções)> o primeiro deles está associado ao comando if e o segundo, ao comando else.

if (condição) {

instrução 1; instrução 2; instrução n;

} else {


}

6.3 O comando "IF-ELSE-IF" if (condição 1) {


} else if (condição 2) {


} else {

instrução; }

6.4 IF’s ANINHADOS Um if aninhado é uma declaração if que é colocada dentro de um outro if ou um else. Ex: if (X > 0 ) {

if (y == 0) {

a = x/y; }

} else {

a = y; }

6.5 SWITCH switch ( variável) {

case constante 1; instrução1; instrução2; break;

case constante 2;

15

instrução; default

instrução; instrução;

}

Há três coisas importantes sobre o comando switch: 1. Ele difere do if, pois só testa igualdades. 2. Nunca, dentro do mesmo switch, duas constantes case poderão ter valores iguais. 3. Uma declaração switch corresponde a um encadeamento if-else-if, porém é mais eficiente. No switch, uma variável é sucessivamente testada contra uma lista de inteiros ou constantes caracter. Quando uma igualdade é encontrada, a instrução ou seqüência de instruções associada ao case da constante é executada. O corpo de cada case é composto por um número qualquer de instruções. Geralmente a última instrução é o break. O comando break causa a saída imediata de todo o corpo do switch. Na falta do comando break, todas as instruções após o case escolhido serão executadas, mesmo as que pertençam ao case seguinte. A declaração default é executada se nenhuma igualdade for encontrada. Nota: o default é opcional.

Exemplo: programa que executa operações matemáticas

#include<iostream.h> #include<conio.h> void main ( ) {

float n1, n2; char opcao; cout<<”\nDigite numero operador numero”; cin>>n1>>opcao>>n2; switch (opcao) {

case ‘+’: cout<<(n1+n2); break;

case ‘-’: cout<<(n1-n2); break;

case ‘*’: cout<<(n1*n2); break;

case ‘/’: cout<<(n1/n2); break;

default: cout<<”\nOperador desconhecido!”;

} getch();

} 7. COMANDOS DE REPETIÇÃO Os comandos de repetição, também chamados de laços, permitem que um conjunto de instruções seja repetido enquanto uma certa condição estiver sendo satisfeita. O laço for é geralmente usado quando queremos repetir algo, um número fixo de vezes. Sintaxe for (inicialização; condição de teste ; incremento) {

Instrução; Instrução2; Instrução n;

16

} A inicialização é uma instrução de atribuição e é sempre executada uma única vez, antes do laço ser iniciado. O teste é uma condição avaliada como verdadeira ou falsa que controla o laço. Esta expressão é avaliada a cada volta no laço. Quando o teste se torna falso, o laço é encerrado. O incremento define a maneira pela qual a variável será alterada a cada volta no laço. É executada sempre, imediatamente após cada volta no laço. Exemplo: #include<iostream.h> void main ( ) {

for (int i=1; i,=20; i++) {

cout<<”\n”<<i; }

}

7.1 Flexibilidade do laço "For" A) O operador vírgula A vírgula possibilita que dentro de um laço for estejam contidas várias instruções separadas por vírgulas. Um par de expressões separadas por vírgula é avaliada da esquerda para a direita.

for ( int i=0; i<10; i++) for (int i=0, j=0; (i+j)<100 ; i++, j++)

cout<<(i+j); for (int i=0, j=10; i<10; i++, j++)

b) Usando caracteres A variável do laço for pode ser do tipo char. Exemplo:

for (char ch=’a’; ch<=’z’; ch++) cout<<”\nO codigo ASC de”<<ch<<”e”<<int(ch); c) Omitindo expressões no laço "For" Qualquer uma das três expressões de um laço for pode ser omitida, embora os ponto-e-vírgulas devam permanecer. Se a expressão de inicialização ou a de incremento forem omitidas, serão simplesmente desconsideradas. Se a condição de teste não estiver presente, será considerada permanentemente verdadeira.

7.2 O laço "While" Um laço while é apropriado em situações em que o laço pode ser terminado inesperadamente, por condições desenvolvidas dentro do laço. Sintaxe: while (expressão teste) {


}

17

Se o teste for verdadeiro, o laço while é executado uma vez e a expressão de teste é avaliada novamente. Este ciclo de teste e execução é repetido até que o teste se torne falso. O corpo do while pode ser uma única instrução terminada por ponto-evirgula, ou várias instruções entre chaves ou, ainda, nenhuma instrução, mantendo o ponto-e-vírgula. Em geral, o laço while pode substituir um laço for da seguinte forma: for (int i=0; i<20; i++)

cout<<i;

�

int i=0; while (i<20) {

cout<<i; i++;

}

laço "Do While"

É bastante similar ao while e é utilizado em situações em que é necessário executar o corpo do laço uma primeira vez e, depois avaliar a expressão ou teste e criar um ciclo repetido. Sintaxe: do {


}while (condição-teste); 8. LISTA DE EXERCÍCIOS

8.1 Exercícios Resolvidos

/*Este programa demonstra o uso dos objetos cin e cout, usados para entrada e saída de dados em ASCII. Salvar com o nome inout.cpp */ #include <iostream.h> int main() { char nome[70]; cout << "Digite seu nome: "; cin >> nome; cout << "\nNome digitado: " << nome << endl; return 0; } //Este programa é utilizado para declarar variáveis de tipos numéricos e caracteres //var01.cpp #include <iostream.h> void main() { int a; // declarar a variável a como inteiro a = 2; // atribuir o valor 2 à variável cout<<"a = "<<a<<endl; // exibir na tela "a = 2" double b = 1.2; //declarar e inicializar a variável b com 1.2 cout<<"b = "<<b<<endl; // exibir na tela "b = 1.2"

char c = 'C'; // declarar e inicializar a variável c com o caracter 'A' cout<<"Linguagem "<<c<<"++"<<endl; //exibir na tela "Linguagem C++" */ }

18

//Este programa alinha números inteiros a direita da tela #include <iostream.h> #include <conio.h> #include <iomanip.h> void main() { int lap=45, bor=2345, can=420, cad=8, fit=13050; clrscr(); cout << “\n\n\n\n”; cout << “\n Lapis “ << setw(12) << lap; cout << “\n Borracha “ << setw(12) << bor; cout << “\n Canetas “ << setw(12) << can; cout << “\n Cadernos “ << setw(12) << cad; cout << “\n Fitas “ << setw(12) << fit; getch(); } //Este programa alinha números inteiros a direita da tela e preenche os espaços em //branco a esquerda com pontinhos “.” #include <iostream.h> #include <conio.h> #include <iomanip.h> void main() { int lap=45, bor=2345, can=420, cad=8, fit=13050; clrscr(); cout << “\n\n\n\n”; cout << setfill(‘.’); cout << “\n Lapis “ << setw(12) << lap; cout << “\n Borracha “ << setw(12) << bor; cout << “\n Canetas “ << setw(12) << can; cout << “\n Cadernos “ << setw(12) << cad; cout << “\n Fitas “ << setw(12) << fit; getch(); } //Este programa alinha nºs flutuantes a direita da tela e define nº de casas decimais #include <iostream.h> #include <conio.h> #include <iomanip.h> void main() { float lap=4.875, bor=234.345, can=42.9098, cad=8.78, fit=13.050; clrscr(); cout << “\n\n\n\n”; cout << setprecision(2); cout << “\n Lapis “ << setw(12) << lap; cout << “\n Borracha “ << setw(12) << bor; cout << “\n Canetas “ << setw(12) << can; cout << “\n Cadernos “ << setw(12) << cad; cout << “\n Fitas “ << setw(12) << fit; getch(); } //Este programa soma dois valores //soma02.cpp # include <iostream.h> #include <conio.h> main() {

19

int x, y, soma; clrscr(); cout<<"Digite o primeiro número: "; cin>>x; cout<<cout<<"\nDigite o segundo número: "; cin>>y; soma=x+y; cout<<" A soma dos números é: "<<soma; } // Este programa é utilizado para declarar,escrever e inicializar uma variável //var02.cpp #include <iostream.h> void main() { int a; // declaração da variável a cout<<"introduza um número inteiro:"<<endl; cin>>a; // ler a variável que foi digitada cout<<endl<<"Acabou de introduir o número: "<<a<<endl; cout<<"Pressione ENTER para terminar o programa."; cin.get(); // espera que o utilizador pressione ENTER } // Este programa pede a digitação de 3 valores seguidos para calcular a média // media01.cpp #include <iostream.h> void main() { int a, b, c; //o mesmo que int a; int b; int c; double media; //double porque o resultado pode não ser inteiro cout<<"Introduza 3 números inteiros: "; cin>>a>>b>>c; //o mesmo que cin>>a; cin>>b; cin>>c; media = (a+b+c) / 3; // calcular a média cout<<endl<<"A média é: "<<media<<endl; // apresentar o resultado cout<<"Enter para terminar"; cin.get(): } // Este programa calcula a média entre dois números // media02.cpp #include<iostream.h> #include<conio.h> main() { int x, y; double media; cout<<"Digite o primeiro n£mero:"; cin>>x; cout<<"\nDigite o segundo n£mero:"; cin>>y; media=(x+y)/2; cout<<"\n a media ‚:"<<media; cout<<"\n pressione enter"; } //Utilizando o if, digite 2 valores e pergunte se são iguais ou diferentes //igualdif.cpp

20

#include <iostream.h> void main() { int a, b; cout<<"Introduza 2 valores inteiros: "<<endl; cin>>a>>b; if( a == b ) cout<<"Os valores são iguais!"; else cout<<"Os valores sao diferentes!"; cout<<endl; cin.get(); } //usando o if, teste se o número é maior ou menor do que a soma # include <iostream.h> #include <conio.h> main() { int x, y, soma; clrscr(); cout<<"Digite o primeiro n£mero: "; cin>>x; cout<<cout<<"Digite o segundo n£mero: "; cin>>y; soma=x+y; if (soma > 10) { cout<<cout<<cout<<"N£mero maior que 10 "<<soma; } else { cout<<cout<<cout<<"N£mero pequeno "<<soma; } } //Digitar um número e verificar se é ou não negativo //negposi.cpp #include <iostream.h> int main() { int numero; cout << "Digite um numero inteiro: "; cin >> numero; if (numero < 0) {cout << "\nO numero e' negativo\n";} //não é permitido retirar o ";" antes do "}", nem colocar ";" depois do "}" else cout << "\nO numero e' positivo ou nulo\n"; return 0; } // Programa que exemplifica o switch (Case) // case1.cpp

21

#include <iostream> using namespace std; void main() { char c; cout<<"Introduza uma vogal minúscula:"<<endl; cin>>c; switch(c) { case 'a': cout<<"Introduziu um a!"<<endl; break; case 'e': cout<<"Introduziu um e!"<<endl; break; case 'i': cout<<"Introduziu um i!"<<endl; break; case 'o': cout<<"Introduziu um o!"<<endl; break; case 'u': cout<<"Introduziu um u!"<<endl; break; default: // se a variável do switch não for nenhuma das anteriores cout<<"Não introduziu uma vogal!"<<endl; break; } cin.get(); }

8.2 Exercícios Propostos

BIBLIOGRAFIA

Borland C++ 4.0, Técnicas de Programação/ Stephen Potts, Timothy s. Monk; Tradução David de Brito Paiva - Rio de Janeiro: AxcelBooks, 1994. MIZRAHI, V.V. – Treinamento em Linguagem C++ - Módulo 1. São Paulo: Pearson, 2005.

introdução linguagem c++

Documents