You are on page 1of 21

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

1
Í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

2
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).

3
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.

4
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++

BCPL SMALLTALK

C linguagem pioneira e
de sucesso em
conceitos de
orientação a objeto
C++

Java

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).

5
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
6
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

7
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

8
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
-231 a 231-1
Int número inteiro 32
(-2147483648 a 2147483647)
número decimal 1.17549435 × 10-38 a
Float 32
(com vírgula) 3.40282347 × 1038 (e negativos)
caractere Qualquer caractere. Exemplos:
Char 8
(usa código ASCII) 'a', 'A', '1', '!', '*', etc.
Short [int] número inteiro -215 a 215-1 (-32768 a 32767) 16
Unsigned short número inteiro
0 a 216-1 (0 a 65535) 16
[int] positivo
número inteiro
Unsigned [int] 0 a 232-1 (0 a 4294967295) 32
positivo
Long [int] número inteiro a mesma que int 32
Unsigned long número inteiro
a mesma que unsigned int 32
[int] positivo

9
número decimal 2.2250738585072014 × 10-308 a
Double 64
de precisão dupla 1.7976931348623157 × 10308 (e negativos)
3.36210314311209350626e × 10-4932 a
número decimal
Long double 1.18973149535723176502 × 104932 96
de precisão tripla
(e negativos)

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( );
}

10
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.
11
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

12
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( );
}
13
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
{
instrução 7;
instrução 8;
instrução n;
}

6.3 O comando "IF-ELSE-IF"


if (condição 1)
{
instrução 1;
instrução 2;
instrução n;
}
else if (condição 2)
{
instrução 7;
instrução 8;
instrução n;
}
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;
14
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;
15
}

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)


{
instrução;
instrução;
}
16
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 {
instrução;
instrução;
}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++" */
}

17
//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()
{
18
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

19
#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
20
#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.

21