Primeira Apostila - Noz Eh Maker

(Sere)Curso de Jogos CDJ
Apostila I
Conceitos de C/C++ I
CasaDosJogos –
http://www.casadosjogos.com.br
2007

Introdução
• Histórico e Apresentação da Linguagem:
Linguagem C
A linguagem C foi desenvolvida na década de 70, por Dennis Ritchie
e Ken Thompson, baseando-se na linguagem B, e implementado para
sistemas operacionais UNIX. Tanto C quanto B derivam da primitiva
linguagem BCPL, onde B é a primeira letra de BCPL, e C, a segunda. C
influenciou várias linguagens como D e Euphoria.
C é uma linguagem de programação estruturada, de médio nível, e
tem como ponto forte sua eficiência, leveza, poder e velocidade com
códigos bem legíveis e de fácil interpretação. Uma de suas maiores
vantagens é sua aproximação com a linguagem de leitura de máquina, ao
mesmo tempo que mantêm grandiosa abstração de dados complexos ao
programador.
Linguagem C++
De forma bastante “grosseira”, podemos ver o C++ como uma
“atualização” ou “extensão” da linguagem C, mas é bem mais que isso.
Basicamente, é definida por Bjarne Stroustrup como “C with classes”, ou C
com classes. Esses conceitos de classe veremos futuramente no próximo
curso.
Foi desenvolvida em 1983, trazendo consigo principalmente
vantagens ligadas à orientação a objetos, reutilização e aproveitamento de
código, e muita facilidade na hora de organizar e montar seu código fonte.
Essa linguagem influenciou várias outras, como C#, Java, D, PHP etc.

• Compiladores:
Um compilador é um tipo de aplicativo que cria uma “camada de
abstração” entre o programador e o computador. Em outras palavras, o
compilador traduz tudo que é escrito por um usuário de um jeito que a
máquina entenda, e de forma que interprete essa informação.
Em todo o universo computacional, existem várias linguagens de
programação categorizadas da seguinte forma:
• Alto Nível (C++, Java)
• Médio Nível (C, Pascal)
• Baixo Nível (Assembly)
Quanto mais baixo o nível, mais próximo estamos da linguagem de
montagem da máquina. Um exemplo de linguagens de baixo nível que
conhecemos é a linguagem de bits (0 ou 1) e Assembly (que trabalha
diretamente com operações de registros e endereços de memória).
Quando falamos de médio e alto nível, falamos de linguagens que
cada vez mais “encobrem” detalhes na hora de implementar, e quanto
maior o nível, menos detalhes específicos ligados a hardware teremos que
nos preocupar. Por exemplo: se estivermos mexendo com C++, não
precisaremos nos preocupar com qual endereço de memória ou parte física
do disco teremos que guardar a informação. O compilador e a linguagem de
programação se encarregará disso automaticamente.
O compilador cria a “ponte de comunicação” entre uma linguagem
humanamente simples e prática ao ser humano trabalhar, sem perder todo
o excesso de informação e detalhes que a máquina precisa.
Um compilador trabalha passo-a-passo da seguinte forma:
• O compilador lê linha após linha (levando em conta o fluxo de
código), verificando se toda a sintaxe foi descrita corretamente
(se estiver errada, retornará uma mensagem de erro
detalhada ao usuário);
• Traduz o código-fonte de C++ (por exemplo) pra linguagem de
máquina;
• Se tudo for interpretado corretamente, ele irá criar um arquivo
com extensão .OBJ, com todas as linhas traduzidas, e um
arquivo .EXE, que é executado pelo sistema operacional;
Outro aspecto importante são as evoluções na área de
compiladores, que cada dia mais deixam de ser apenas “interpretadores de
comandos”, e se tornam verdadeiros ambientes de desenvolvimento,
trazendo consigo várias opções de compilação, depuração, bibliotecas
prontas etc. Um exemplo de ambientes de desenvolvimento nesse estilo
são aplicativos como o Eclipse e o Microsoft Visual Studio.

• C ou C++:
Muitas pessoas confundem a relação entre C e C++. Trata-se de
duas linguagens diferentes.
O C é uma linguagem de programação estruturada, de médio nível,
sendo bastante semelhante à linguagem Pascal (apesar de ter uma sintaxe
bem diferente). O C++ reaproveita alguns conceitos e sintaxes do C, ao
mesmo tempo em que acrescenta novos conceitos interessantes de
bibliotecas e programação voltada à orientação a objetos.
Não é o propósito desse curso detalhar as diferenças entre
orientação a objetos e programação estruturada, por isso vamos a eles de
forma sucinta:
• Programação estruturada: Blocos de texto interpretados logicamente da
primeira a última linha, sem modificações no fluxo de leitura.
• Orientação a objetos: Vemos o conceito de classes e objetos. Ao invés de
criarmos blocos de programas únicos e lidos da primeira a última linha, na
orientação a objetos podemos interligar cada bloco de código em uma e
mais classes, que podem ser lidas e executada por outras
simultaneamente, da mesma forma em que o fluxo de leitura é
completamente variável ao programador, aumentando o reaproveitamento e
organização de código-fonte.

Usando o compilador
• Criando projeto no Microsoft C++ 2005 Visual Studio
Express:
Primeiro passo:
1) Baixe-o em:
http://msdn.microsoft.com/vstudio/express/visualc/default.aspx/, instale e
execute o Visual Studio.
2) Quando o programa abrir, na guia principal do programa ao alto, clique
em File
3) Depois clique em New e depois Project, ou simplesmente aperte
Ctrl+Shift+N
Segundo passo:
Se abriu uma janela escrita "New Project", então em "Project Files"
escolha "Win32" e em "Templates", clique em "Win32 Console
Application". Agora embaixo em "Name" dê qualquer nome ao projeto (por
exemplo, chame-o de teste) e aperte OK.
Terceiro passo:
Em "Win 32 Application Wizard" aperte "Next >".
Quarto passo:
Em "Application Type" deixe "Console Application" como está, e abaixo,
em "Additional options" marque a opção "Empty Project". Agora aperte
"Finish".
Quinto passo:
1) É aqui que mais as pessoas confundem. Você sempre deve criar um
projeto (como fizemos até o quarto passo) e em seguida adicionar os
códigos fonte e coisas do gênero que ficam vinculados ao projeto criado,
ok? Adicionaremos uma página de código fonte pra gerarmos nosso
primeiro código.
2) Agora na guia do alto, procure "Project" e depois "Add New Item". Ou
apenas aperte CTRL+SHIFT+A
Sexto passo:
Com certeza em "Visual Studio installed templates" a opção "C++ File
(.cpp)" deve estar marcada. Só vá em "name", dê um novo nome como
teste1 e aperte Add.

Sétimo passo:
Copie esse código como está abaixo, e cole no compilador:
#include
using namespace std;
int main()
{
cout

• Criando projeto no Dev-C++ 4.9.9.2:
Primeiro passo:
1) Baixe-o em: http://prdownloads.sourceforge.net/dev-cpp/devcpp-
4.9.9.2_setup.exe, instale e execute-o
2) Quando o programa abrir, na guia principal do programa ao alto, clique em File
3) Depois clique em New Project
Segundo passo:
1) Se abriu uma janela escrita "New Project", então na guia "Basic" escolha
"Empty Project".
2) Marque "C++ Project" abaixo.
3) Dê um nome ao projeto.
3) Aperte OK.
Terceiro passo:
Em "Create New Project" salve o projeto em alguma pasta de sua escolha.
Quarto Passo:
Aperte CTRL+N ou em “File”, e quando o compilador perguntar se “deseja anexar
esse fonte ao projeto atual?” diga que sim.
Agora basta colar o seguinte código na página de código-fonte em branco:
#include
using namespace std;
int main()
{
cout

Sétimo passo:
Deve abrir uma janela mostrando a mensagem "Estou pronto pra começar o curso
de C++ da CDJ!" e algo como "Aperte qualquer tecla para continuar...". Se isso
aparecer corretamente, então o compilador está em perfeito estado para uso!
• Erros de compilação:
Basicamente, quando terminamos de criar nosso código-fonte, o
compilador realiza dois processos até termos o aplicativo final, que são: a
compilação e a execução.
Quando compilamos um código-fonte, realizamos um processo de
verificação e interpretação de código, até ser possível que a máquina
“entenda” e possa executar esses comandos. Isso é a compilação, e é
nesse processo que se verifica se o código foi descrito corretamente.
Para isso, quando é feita a compilação, na barra inferior desse
aplicativo, são demonstrados status de verificação e integridade de erros, e
o compilador retorna uma mensagem de aviso, se o código apresentar
erros (digitação incorreta do programador) ou não. Se ele tiver erros, todo o
processo de compilação é interrompido, e o compilador especifica qual é a
causa da falha. Não se pode chegar no código-fonte final se houver erros
de compilação.
Outra informação importante, além dos avisos de erros, são os
“warnings”. A diferença entre os dois vêm do fato de um “warning” não
impossibilitar a execução de um código-fonte, mas sim que futuramente ele
pode causar erros quando o programa já estiver sendo executado (por
exemplo, um acesso a endereço de memória não especificado).
• Gerando Executável:
Feita a compilação, se ela foi executada corretamente, torna-se
possível criar uma versão .EXE de seu código. Basta apenas clicar na
opção Build de um compilador (no caso do visual Studio, é só apertar F7
num código já compilado, lembre-se disso!).
No processo de geração de executável, o compilador se utiliza de
arquivos .OBJ (gerados na compilação), e se baseia em arquivos .CPP
(arquivos de código-fonte de C++) para gerar o código .EXE final.

Primeiro programa
“Hello World” é a clássica aplicação que todo programador iniciante
cria quando começa a estudar uma linguagem, sendo um tipo de programa
bem simples. Trata-se apenas de uma mensagem de texto “OLÁ MUNDO!”
mostrada em tela.
Fizemos isso na hora que criamos o projeto, agora vamos analisar o
código linha após linha:
#include
using namespace std;
int main()
{
cout

aquela linha (apesar de que nem sempre você coloca ponto e vírgula,
iremos verificar isso com o tempo).
int main()
{
//insira todo o código do aplicativo aqui
return 0;
}
Aqui estamos definindo a função principal (main) do programa. Ela
sempre é a primeira a ser executada obrigatoriamente pelo compilador, e
todo o conteúdo do programa é executado nesse bloco de informação,
entre as chaves { e }.
O int é a definição de função integer (função de números inteiros).
Iremos explicar melhor sobre tipos de dados (inteiros, reais) no próximo
capítulo.
Todos os comandos do seu aplicativo devem estar onde eu coloquei
//insira todo o código do aplicativo aqui . Por exemplo, o comando cout
que usamos.
Já o return 0; tem a ver com o conceito de função. De forma bem
resumida, toda função é um pequeno bloco de código fonte que retorna
imediatamente um dado, ao final de sua execução. Óbvio que dependendo
do tipo de função que seja, pode ser que não retorne nada. Ao executar o
Return 0; estamos dizendo ao compilador que a função finalizou todas as
suas tarefas, e que agora deve retornar ao compilador um resultado (ou
valor) qualquer. Não se preocupe ainda com isso.
A princípio, pense nisso como um comando que precisa ser utilizado
em blocos da função int main(), de forma padrão.
cout

}
No Dev-C++ 4.9.9.2 é a mesma idéia, mas apenas com a utilização
de mais uma função:
#include
using namespace std;
int main()
{
cout

Variáveis
• Conceito:
São objetos que possuem a função de armazenar certos valores
(como números, textos) que podem ser utilizados e trabalhados ao longo de
um código.
Por exemplo, pense num jogo, e que precisamos armazenar ao
longo da partida informações vitais como vida (HP) do personagem, pontos de
mana (SP), pontos de experiência (EXP), munição da arma, dinheiro
armazenado, nome do jogador etc. Tudo isso ficaria armazenado em variáveis.
Elas são vitais num programa.
• Tipos de Variáveis:
Existem diversos tipos, mas visando o nosso curso, vamos falar dos
5 exemplos básicos mais comuns, que são:
• Int (inteiros): são números inteiros comuns, que não aceitam valores
decimais, frações, nem nada do gênero (exemplo: 1, 45, 87, 914). Uma
variável int pode armazenar do valor -2.147.483.648 a 2.147.483.648.
• Char (caracteres): Armazena um único caracter, de um possível conjunto
de símbolos e letras. Podem armazenar até 256 valores de caracteres
diferentes.
• Float (reais): diferente dos inteiros, o float guarda valores numéricos
ligados ao universo dos números reais (exemplo: 2,41 , 4,17 , 8,9592). Ele
pode armazenar de 1,2e-38 a 3,4e38 (e = número elevado a)
• Boolean (lógico): apenas determina valor do tipo true ou false, ou apenas
verdadeiro ou falso. Por exemplo, se num jogo temos uma porta que só
pode ser aberta com uma chave, podemos usar uma condição booleana
que armazena se o jogador está com a chave ou não. Se estiver, é true,
caso contrário, false.
• Double: É apenas o valor de float estendido. Se for utilizar uma variável
que precise de mais valores do que o float suporta, use double. Esse
armazena de 2,2e-308 a 1,8e308.

• Como usar variáveis:
Declarando (criando) variáveis
Basta apenas definir seu tipo (int, char, float, double) junto de um
nome qualquer, pra identificá-la. Por exemplo:
Int var;
Nesse exemplo, criamos uma variável do tipo número inteiro,
chamada var. Não se esqueça do ponto e vírgula!
Mais exemplos:
Int main(){
int pontos;
return 0;
}
int main(){
float raiz;
return 0;
}
Atribuindo valores
Vamos supor que ao criar um jogo, temos um personagem com
pontos de vida no total de 100 pontos. Faríamos o seguinte (se a variável em
questão já tiver sido declarada):
pontos_de_vida = 100;
Assim estamos definindo que a variável pontos_de_vida guarda o
valor numérico inteiro 100.
Vamos supor que, na segunda linha do código, o personagem morre.
Assim:
pontos_de_vida = 0;

Teríamos então, o seguinte código:
Teste o seguinte código:
int main(){
//declaramos a variável
int pontos_de_vida;
//aqui a vida do personagem principal é 100
pontos_de_vida = 100;
//aqui a vida do personagem principal é 0
pontos_de_vida = 0;
return 0;
}
#include
using namespace std;
int main()
{
int valor = 20;
cout

Por fim, um exemplo que se utiliza de valores booleanos e de
caracteres (bool e char especificamente):
#include
using namespace std;
int main()
{
char caracter = 'c';
bool logico = true;
cout

Operadores Matemáticos
• Conceito:
Tendo em vista o estudo de variáveis numéricas, torna-se necessário
estudar operadores que sejam aplicados a esses objetos. Falamos de cálculos
matemáticos como adição, subtração, divisão etc.
• Tipos:
Temos os seguintes tipos e suas formas de representação:
• Soma: +
• Subtração: -
• Divisão: /
• Multiplicação: *
• Resto de Divisão Inteira: %
• Exemplos:
Veremos um código-fonte que demonstra cada operação:
#include
using namespace std;
int main()
{
int soma = 15 + 15;
int subtracao = 200-50;
int multiplicacao = 15*5;
float divisao = 15.0 /4.0;
float resto_inteiro = 5 % 2;
cout

cout

Teste o código e verifique:
#include
using namespace std;
int main()
{
float x1 = (10.0+14.0)/2.0; //x1 = 12
float x2 = 10.0+14.0/2.0; // x2 = 17
cout

Comentários
• Conceito:
São usados quando queremos inserir textos ao longo de um códigofonte
sem que pra isso eles sejam necessariamente executados. São muito
úteis para escrevermos explicações sobre o que uma linha ou função do
programa faz, ou pra marcarmos algum trecho do código que não queremos
que seja executado no momento dentre outras funcionalidades. É muito útil
para testes e busca por erros.
Para isso, basta usar // antes de uma linha de código. Feito isso, ele
ficará com uma cor diferente no compilador (tanto no visual studio quanto no
dev-c++), e tudo que estiver na linha não será executado.
Para criar um comentário que contenha mais de uma linha, basta
usar /* (conteúdo do comentário) */. Tudo que estiver entre esses pares de
caracteres (barra vertical e asterisco) não é executado. Veja o exemplo:
#include
using namespace std;
int main()
{
int x;
x = 10;
//x = 100;
cout

Diretivas
#include
Essa diretiva tem como objetivo “concatenar” (ou anexar) um códigofonte
de outro arquivo com o que você está utilizando no momento. Isso vale
pra tudo que foi criado no código anterior, desde variáveis, classes, funções
etc.
Nós a declaramos da seguinte forma:
ou
#include
#include “iostream.h”
usamos < > quando estamos chamando arquivos de bibliotecas
padrões do compilador, e “ “ quando chamamos arquivos comuns que
queremos anexar ao projeto atual (que não necessariamente pertençam a
biblioteca, como um arquivo de cabeçalho que criamos). Ao utilizar include, ele
sempre verifica se a biblioteca (ou cabeçalho) está na pasta raiz do projeto ou
na pasta include do compilador.
Normalmente #include é usado em arquivos de cabeçalho (os quais
veremos mais tarde, são os arquivos .h ou .hpp), mas também pode ser
empregado em arquivos de código-fonte (.c ou .cpp).
#define
Essa diretiva tem como facilidade a função de simplificar a digitação.
Ao invés de digitar várias vezes comandos complexos e extensos que são
utilizados diversas vezes ao longo de um código, como:
cout

Veja o exemplo:
#include
#define BLA cout

Leitura e Retorno de
Dados
• Retorno:
formato:
Cout
Como já visto, é uma função que imprime textos em tela, no seguinte
cout

Repare que o símbolo >> agora está invertido com relação ao cout.
Isso ocorre porque não há mais fluxo de saída de dados, agora nós estamos
inserindo dados ao aplicativo.
Com esse comando, emitimos tudo que é digitado no teclado para
dentro de uma variável. Veja o exemplo de um programa que captura idade de
um usuário:
#include
using namespace std;
int main()
{
int idade;
cout > idade;
cout

#include
using namespace std;
int main()
{
int fator1;
int fator2;
cout > fator1;
cout fator2;
cout