Você está na página 1de 63

PROGRAMAO GRFICA 1

Prof. MSc. Karl Phillip Buhr


Curso: 620 - Engenharia da Computao
Componente Curricular: 20399
Crditos: 4
Fase: 7
#include <iostream>
int main()
{
std::cout << Hello World! << std::endl;
return 0;
}
C++ - Estrutura mnima de um programa
int main()
{
return 0;
}
C++ - Estrutura mnima de um programa
Um programa emC++ pode ser composto de um ou
mais arquivos de cdigo-fonte. Cada cdigo-fonte
pode conter:
1. Diretivas do pr-processador, emespecial a diretiva
de incluso: #include
2. Declaraes de variveis, estruturas de dados,
funes ou classes
3. Implementaes de funes ou classes
C++ - Estrutura mnima de um programa
C++ - Processo de construo do programa
C++ - Pr-processador
O pr-processador um programa que trata das
diretivas de pr-processamento antes do processo
de compilao. As diretivas so comandos que no
so compilados e so especficos ao pr-
processador.
Ele prove a habilidade de incluir arquivos de
cabealho (header), macros, compilao
condicionada e controle de linha.
O uso mais comum para incluir outros arquivos:
#include <iostream>
int main(void) {
std::cout << Hello World! << std::endl;
}
C++ - Pr-processador
As diretivas de pr-processamento comeam com o caractere #.
A seguir, a lista das que so permitidas no C++ padro:
#define Define um token
#elif A diretiva else-if
#else A diretiva else
#error O erro atual
#if A diretiva if
#ifdef A diretiva if-defined
#ifndef A diretiva if-not-defined
#include Inclui um arquivo
#line A linha atual
#pragma Funo especial executada antes do resto do cdigo
#undef Undefine
C++ - Pr-processador
Tokens pr-definidos:
__cplusplus : definido se o programa foi escrito em C++
__STDC__ : definido se o programa foi escrito em C padro
__LINE__ : guarda o nmero da linha atual
__FILE__ : guarda o nome do arquivo atual
__DATE__ : guarda a data da compilao
__TIME__ : guarda a hora da compilao
C++ - Pr-processador
Exemplo 1:
#include <iostream>
#define PI 3.1416
#define VERSAO "2.02"
int main ()
{
std::cout << "Programa verso: << VERSAO << std::endl;
std::cout << "O numero pi vale: << PI << std::endl;
return 0;
}
C++ - Pr-processador
Exemplo 2:
#include <iostream>
#define max(A, B) ((A > B) ? (A) : (B))
#define min(A, B) ((A < B) ? (A) : (B))
int main ()
{
std::cout << Maior num entre 4 e 6 : << max(4, 6) <<
std::endl;
std::cout << Menor num entre 1 e 9 : << min(1, 9) <<
std::endl;
return 0;
}
C++ - Pr-processador
Exerccio 1:
Define uma macro para multiplicar dois nmeros, de
forma que o programador possa executar:
int z = MULT(3 + 2, 4 + 2);
C++ - Pr-processador
Exerccio 1 (soluo):
Define uma macro para multiplicar dois nmeros, de
forma que o programador possa executar:
int z = MULT(3 + 2, 4 + 2);
A seguinte macro vai resultar em 13:
#define MULT(x, y) x * y
Isso porque a macro vai se expandir em:
int z = 3 + 2 * 4 + 2;
C++ - Pr-processador
Exerccio 1 (soluo):
Uma soluo melhor forar os argumentos
serem avaliados antes que o resto do corpo
da macro. Isso pode ser feito adicionando
parnteses ao redor do corpo deles:
#define MULT(x, y) (x) * (y)
E agora MULT(3 + 2, 4 + 2) ir expandir em:
(3 + 2) * (4 + 2)
C++ - Pr-processador
Exerccio 1 (soluo):
Uma soluo melhor ainda envolver todo o
cdigo da macro entre parnteses se voc
espera que a macro retorne um valor. Caso
contrrio, voc pode ter problemas ao definir
uma constante como parte da operao:
#define ADD_FIVE(a) (a) + 5
int x = ADD_FIVE(3) * 3;
Ir expandir para:
(3) + 5 * 3
Ento 5 * 3 avaliado primeiro e x se torna 18 e
no 24.
C++ - Pr-processador
Exerccio 1 (soluo):
Para consertar esse problema voc deve
envolver o corpo da macro entre parnteses
para impedir que o contexto que est prximo
afete o corpo da macro:
#define ADD_FIVE(a) ((a) + 5)
int x = ADD_FIVE(3) * 3;
C++ - Pr-processador
Exerccio 2:
Define uma macro para fazer a mdia de dois nmeros,
de forma que o programador possa executar:
std::cout << A mdia entre 5 e 7 : <<
MEDIA(5, 7) << std::endl;
C++ - Pr-processador
Exerccio 2 (soluo):
#define MEDIA(Z, W) ( ((Z)+(W))/2 )
std::cout << A mdia entre 4 e 6 : <<
MEDIA(2+2, 3+3) << std::endl;
As diretivas do pr-processador permitemdeterminar o
modo que se d a compilao, permitindo controlar de
maneira muito sofisticada quais cdigo-fontes sero
includos e at mesmo que trechos de cdigo que devem
ou no ser compilados (compilao condicional).
#ifdef __WIN32__
cout << __FILE__ << " , " << __LINE__ << " -- Windows!"<< endl;
#elif __APPLE__
cout << __FILE__ << " , " << __LINE__ << " -- Mac OS X!"<< endl;
#else
cout << __FILE__ << " , " << __LINE__ << " -- Outro sistema!"<< endl;
#endif
C++ - Pr-processador
#if 0
#ifdef __WIN32__
cout << __FILE__ << " , " << __LINE__ << " -- Windows!"<< endl;
#elif __APPLE__
cout << __FILE__ << " , " << __LINE__ << " -- Mac OS X!"<< endl;
#else
cout << __FILE__ << " , " << __LINE__ << " -- Outro sistema!"<< endl;
#endif
#endif
C++ - Pr-processador
A diretiva de incluso #include utilizada em
praticamente todos os programas e indica
quais unidades de compilao sero anexadas
ao cdigo, como geralmente feito com as
bibliotecas-padro da linguagem.
As declaraes de variveis e estruturas de
dados correspondem s especificaes desses
elementos. J as declaraes de funes e
classes podem tomar sua forma mnima ou
completa.
C++ - Estrutura mnima de um programa
Na forma completa, figuram suas declaraes
e sua implementao.
A forma mnima contm apenas as
declaraes, servindo somente como uma
especificao de suas interfaces e adequada
compilao em separado.
Finalmente, as implementaes de funes e
classes so as unidades que complementam
as declaraes mnimas realizadas em outras
unidades de compilao.
C++ - Estrutura mnima de um programa
Essas unidades de compilao podem ser
omitidas, desde que seus arquivos objeto (.o)
correspondentes estejam previamente
disponveis e sejam indicados para ligao
com o restante do cdigo gerado.
C++ - Estrutura mnima de um programa
C++ - Entrada e Sada
Sada: std::cout Arquivo: iostream
#include <iostream>
int main()
{
std::cout << Hello ;
std::cout << World! << std::endl; //endl: quebra de linha
return 0;
}
C++ - Entrada e Sada
Sada: std::cout Arquivo: iostream
#include <iostream>
int main()
{
int n_buddhas = 729; // declarao e inicializao
std::cout << Existem << n_buddhas;
std::cout << na minha coleo de esttuas!\n;
return 0;
}
C++ - Entrada e Sada
Sada: std::cout Arquivo: iostream
#include <iostream>
int main()
{
int n_buddhas; // declarao
n_buddhas = 729; // inicializao
std::cout << Existem << n_buddhas << na minha coleo de
esttuas!\n;
return 0;
}
C++ - Entrada e Sada
Entrada: std::cin Arquivo: iostream
#include <iostream>
#include <string> // oferece std::string
int main()
{
std::cout << Digite uma palavra: ;
std::string input;
std::cin >> input;
std::cout << Voc digitou: << input << std::endl;
return 0;
}
C++ - Entrada e Sada
Entrada: std::cin Arquivo: iostream
#include <iostream>
#include <string> // oferece std::string
int main()
{
std::cout << Digite 3 palavras: ;
std::string input1, input2, input3;
std::cin >> input1 >> input2 >> input3;
std::cout << Voc digitou: << input1 <<
input2 <<
input3 << std::endl;
return 0;
}
C++ - Caracteres de Escape
Podemos usar a sequncia de caracteres de
escape \n para fazer a sada pular uma nova
linha quando se usa cout. Colocar uma barra
invertida \ na frente do caractere faz com que
o C++ procure por uma sequncia de caracteres
de escape e a trate de forma especial. Chama-
se usar uma barra invertida dessa forma
escapar um caractere ou uma sequncia de
caracteres.
As sequncias de caracteres de escape
suportadas pelo C++ so mostradas a seguir:
C++ - Caracteres de Escape
Sequncia de escape Representa
\a Campainha (alerta)
\b Retrocesso (backspace)
\f Alimentao do formulrio (FF, nova tela)
\n Nova linha
\r Retorno do carro (CR, retorno ao incio da linha)
\t Tabulao horizontal
\v Tabulao vertical
\ Apstrofe
\ Aspas duplas
\\ Barra invertida
\? Ponto de interrogao
\000 Cdigo do caractere emnotao octal
\xhhh
Cdigo do caractere emnotao hexadecimal
C++ - Entrada e Sada (escape)
#include <iostream>
#include <string>
int main()
{
std::cout << Digite uma palavra: ______\b\b\b\b\b\b;
std::string input1;
std::cin >> input1;
std::cout << Voc digitou: << input1 << std::endl;
return 0;
}
C++ - Entrada e Sada (formatao)
#include <iostream>
#include <string>
int main()
{
float pi = 3.14159;
std::cout << PI: << pi << std::endl;
std::cout.precision(3);
std::cout << PI: << pi << std::endl;
return 0;
}
C++ - Entrada e Sada (formatao)
#include <iostream>
#include <string>
int main()
{
float pi = 3.14159;
std::cout << PI: << pi << std::endl;
std::cout << std::setprecision(3) << PI: << pi << std::endl;
return 0;
}
C++ - Operadores
Operador Nome ou significado
:: Resoluo de escopo
:: Global
------------------------------------- ------------------------------------------------------------
. Seleo de membro (objeto)
-> Seleo de membro (ponteiro)
++ Incremento ps-fixado
-- Decremento ps-fixado
[ ] ndice de array
( ) Chamada de funo
( ) Converso
typeid() Nome de tipo
const_cast Converso explcita de tipo
dynamic_cast Converso explcita de tipo
C++ - Operadores
Operador Nome ou significado
reinterpret_cast Converso explcita de tipo
static_cast Converso explcita de tipo
------------------------------------- ------------------------------------------------------------
sizeof Tamanho do objeto
sizeof() Tamanho do tipo
++ Incremento pr-fixado
-- Incremento pr-fixado
(tipo) Converso explcita de tipo
new Alocao de objeto
new[ ] Alocao de array
delete Liberao de objeto
delete[ ] Liberao de array
* Desreferenciao
C++ - Operadores
Operador Nome ou significado
& Endereo de
+ Mais unrio
- Negao aritmtica (unria)
! NO (negao) lgico
~ Complemento bit a bit
------------------------------------- ------------------------------------------------------------
.*
Aplicao de ponteiro a membro de classe (objetos)
->*
Desreferenciao de ponteiro para membro de classe
------------------------------------- ------------------------------------------------------------
* Multiplicao
/ Diviso
% Resto (mdulo)
------------------------------------- -----------------------------------------------------------
C++ - Operadores
Operador Nome ou significado
+ Adio
- Subtrao
------------------------------------- ------------------------------------------------------------
<< Deslocamento para a esquerda
>> Deslocamento para a direita
----------------------------------- ------------------------------------------------------------
< Menor que
> Maior que
<= Menor ou igual a
>= Maior ou igual a
------------------------------------- ------------------------------------------------------------
== Igualdade
!= Desigualdade
C++ - Operadores
Operador Nome ou significado
--------------------------------------- -----------------------------------------------------------
& E bit a bit
^ OU exclusivo bit a bit
| OU bit a bit
--------------------------------------- ------------------------------------------------------------
&& E lgico
|| OU lgico
--------------------------------------- ------------------------------------------------------------
e1 ? e2 : e3 Condicional
--------------------------------------- ------------------------------------------------------------
C++ - Operadores
Operador Nome ou significado
= Atribuio
*= Multiplicao com atribuio
/= Diviso com atribuio
%= Resto de diviso com atribuio
+= Adio com atribuio
-= Subtrao com atribuio
<<= Deslocamento para a esquerda com atribuio
>>= Deslocamento para a direita com atribuio
&= E bit a bit com atribuio
|= OU bit a bit com atribuio
^= OU exclusivo bit a bit com atribuio
--------------------------------------- ------------------------------------------------------------
C++ - Operadores
Operador Nome ou significado
throw Lanamento de excesso
--------------------------------------- ------------------------------------------------------------
, Vrgula
Palavras reservadas C++
asm auto bad_cast bad_typeid
bool break case catch
char class const const_cast
continue default delete do
double dynamic_cast else
enum except explicit extern
false finally float for
friend goto if inline
int long mutable namespace
new
Palavras reservadas C++
operator private protected public
register reinterpret_cast return short
signed sizeof static
static_cast struct switch template
this throw true try
type_info typedef typeid
typename
union unsigned using virtual
void volatile wchar_t while
Bibliotecas do C++
So 32 arquivos de cabealho (header).
Usamo espao de nomes std.
<algorithm> <iomanip> <list>
<ostream> <streambuf> <bitset>
<ios> <locale> <queue>
<string> <complex> <iosfwd>
<map> <set> <typeinfo>
<deque> <iostream> <memory>
<sstream> <utility> <exception>
<istream> <new> <stack>
<>
Bibliotecas do C++
<valarray> <fstream> <iterator>
<numeric> <stdexcept> <vector>
<functional> <limits>
Os recursos da biblioteca padro do C so
fornecidos em18 arquivos adicionais:
<cassert> <ciso646> <csetjmp>
<cstdio> <ctime> <ctype>
<climits> <csignal> <cstdlib>
<cwchar> <cerrno> <clocale>
<cstdarg> <cstring> <cwctype>
<cfloat> <cmath> <cstddef>
Estruturas de Controle
Condicionais:
if (condio)
comando;
if (condio)
comando;
else
comando;
Estruturas de Controle
Condicionais:
if (condio)
comando;
if (condio)
comando;
else
comando;
if (idade >= 21)
std::cout << Varivel maior ou igual a 21\n;
if (idade >= 21)
std::cout << Varivel maior ou igual a 21\n;
else
std::cout << Varivel idade menor que
21\n;
Estruturas de Controle
Exerccio:
Escreva um programa para verificar se a string que o
usurio digitou unoesc. Escreva uma mensagem
na tela se a pessoa acertou ou no.
Estruturas de Controle
Condicionais (mltiplas):
switch (expresso) {
case constante_1: comando;
case constante_2: comando;
case constante_3: comando;
//
}
switch (letra) {
case A:
std::cout << Digitou A\n;
break;
case B:
std::cout << Digitou B\n;
break;
case C:
std::cout << Digitou C\n;
break;
default:
break;
}
Estruturas de Controle
Exerccio (switch):
Escreva um programa que imprima a mensagemA
idade est entre 1 e 10 ou A idade est entre 11 e
20 baseado na idade que o usurio forneceu para
o programa.
Estruturas de Controle
Repetio:
while (condio)
comando;
do
comando;
while (condio);
for (inicializao; teste; incremento)
comando;
Estruturas de Controle
Repetio:
do/while:
while:
for:
int conta = 1;
while (conta <= 100) {
std::cout << conta << std::endl;
conta++;
}
int conta = 1;
do {
std::cout << conta << std::endl;
conta++;
} while (conta <= 100);
for (int conta = 1; conta <= 100; conta++) {
std::cout << conta << std::endl;
conta++;
}
Estruturas de Controle
Exerccio 1 (while):
Escreva um programa que imprima um tringulo
issceles, com altura e largura N, de forma que N =
6 ficaria:
*
**
***
****
*****
******
Estruturas de Controle
Exerccio 2 (do-while):
Escreva um programa que imprima um tringulo de
lado, com altura 2N-1 e largura N, de forma que N =
4 ficaria:
*
**
***
****
***
**
*
Estruturas de Controle
Exerccio 3 (for):
Escreva um programa que imprima um tringulo em
p, com altura N e largura 2N-1, de forma que N = 6
ficaria:
*
***
*****
*******
*********
***********
Estruturas de Controle
Instrues de salto:
For, While e Do-While permitemque seus
programas repitamum ou mais comandos at uma
condio especfica seja avaliada como verdadeira
ou falsa. Dependendo do propsito do seu
programa, algumas vezes, h necessidade de ter
uma segunda condio especfica para terminar o
lao automaticamente.
O comando break permite fazer exatamente isso,
terminando o lao imediatamente.
Estruturas de Controle
Instrues de salto (goto):
O comando goto permite que a execuo do
seu programa desvie para uma localizao
especfica, denomidada por um label (rtulo)
int conta = 1;
rotulo:
std::cout << conta++ << std::endl;
if (conta <= 100)
goto rotulo;
Estruturas de Controle
Instrues de salto (goto):
Para usar o goto o rtulo deve estar dentro
da funo atual, ou seja voc no pode usar
um goto para desviar-se de main() para um
rtulo que aparece emoutra funo.
Arrays (arranjos)
Conjuntos de elementos de um mesmo tipo,
organizados emposies consecutivas na
memria.
Arranjos so considerados estruturas
homogneas de dados por armazenarem
elementos de um mesmo tipo.
Outro aspecto importante que eles
possuemuma capacidade fixa, ou seja,
podemarmazenar uma quantidade pr-
determinada de elementos, que
especificada na sua declarao.
Arrays (arranjos)
Arranjos unidimensionais podemser
declarados da seguinte maneira:
<tipo> <identificador> [<tamanho>];
int arranjo[5];
float precos[1000];
bool flags[16];
Arrays (arranjos)
Representao de um array unidimensional:
Arrays (arranjos)
Declarao e inicializao de um array:
long v[100]; // declarao
// declarao e inicializao:
int a[ ] = { 13, -28, 946, 50, 724 };
// exibio:
std::cout << a[0] << std::endl;
// expresses envolvendo arranjos:
v[0] = 1394;
v[99] = a[2] + a[3];
Estruturas de Controle
Exerccio 1 (array):
Escreva um programa que inicialize um array de
inteiros com 10 elementos para ZERO:
Estruturas de Controle
Exerccio 2 (array):
Escreva um programa que recebe 5 strings do
usurio e armazena emum array de tamanho
apropriado. No final do programa voc deve
percorrer o array com a instruo do-while para
imprimir o contedo do array na tela.
BIBLIOGRAFIA
BOENTE, A. Aprendendo a Programar emJava 2 Orientado a Objetos. Sao Paulo: Brasport,
2003.
SANTEE, A. Programacao de Jogos com C++ e DirectX. So Paulo: Novatec, 2005. 399p.
JAMSA, K., KLANDER, L. Programando emC/C++. Makron Books, 1998. ISBN 1884133258
DEITEL, P. J., DEITEL, H. M. C++ Como Programar. Prentice Hall Brasil, 2006. ISBN
8576050560
JUNIOR, P. J. Introducao ao C++. Futura, 2003. ISBN 85-7413-172-5
HOLZNER, S. C++ Black Book. So Paulo: Makron Books, 2001.
Qt Reference Documentation: http://doc.qt.nokia.com/4.7/index.html

Você também pode gostar