Escolar Documentos
Profissional Documentos
Cultura Documentos
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
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.
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).
Arquivo executável é um arquivo que contém um programa que já foi compilado e está
pronto para rodar.
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.
BCPL SMALLTALK
C linguagem pioneira e
de sucesso em
conceitos de
orientação a objeto
C++
Java
2. Selecione a opção New no menu File. O Borland C++ - Versão 3.1 criará o
arquivo 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.
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.
2. Selecione a opção New no menu File. O Borland C++ - Versão 3.1 criará o
arquivo noname00.cpp.
#include <iostream.h>
void 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 boanoite.cpp e pressione
Enter. O Borland C++ - V. 3.1 salvará o arquivo de programa boanoite.cpp.
Os comentários podem ser feitos de duas maneiras: ou eles começam com “/*” e
terminam com “*/” ou eles utilizam “//” sem finalização.
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.
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.
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.
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.
#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.
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:
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.
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.
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”;
É 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)
Parênteses
*, /, %
+,-
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)
OPERADOR SIGNIFICADO
== Igual a
> Maior que
< Menor que
>= Maior ou igual a
<= Menor ou igual a
!= Diferente
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.
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 }
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;
}
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;
}
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;
}
}
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.
b) Usando caracteres
A variável do laço for pode ser do tipo char.
Exemplo:
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.
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º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
#include<iostream.h>
#include<conio.h>
main()
{
int x, y;
double media;
19
#include <iostream.h>
void main()
{
int a, b;
if( a == b )
cout<<"Os valores são iguais!";
else
cout<<"Os valores sao diferentes!";
cout<<endl;
cin.get();
}
#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;
}
BIBLIOGRAFIA
21