C++ - Aula 01

Daremos início hoje às aulas de C++ que serão dadas aqui no blog.
Espero que aproveitem, e caso surja alguma dúvida é só postar aqui que eu farei o possível para solucionar. 
O conteúdo das aulas começa com conceitos básicos mas importantes e fundamentais, e segue até atingir conceitos mais avançados.

Essa e as próximas aulas estarão disponíveis para download, e o link ficará no final de cada aula.


C++  -  Aula 1
__________________________________________________
Conteúdo:
1. Introdução a Programação de Jogos com C++
     1.1 - Introdução a C++ 
          1.1.1 - Por que C++
          1.1.2 - Detalhes da linguagem 
     1.2 - Tipos de variáveis
          1.2.1 - Conversão de variáveis
               1.2.1.1 - Conversão implícita
               1.2.1.2 - Conversão explícita
     1.3 - Declarando e inicializando variáveis
     1.4 - Definições de constantes
     1.5 - Definições de enumeradores
   
Nota: Para os exemplos das aulas eu utilizarei o IDE Microsoft Visual C++ 2008 Express Edition, porém sinta-se livre para utilizar qualquer outro de sua preferência. Eu particularmente prefiro este por vários motivos, dentre eles o IntelliSense( recurso de auto-completar).

Para criar um novo projeto no Visual vá em File - New - Project, clique na opção General da árvore  à esquerda, e na janela à direita escolha Empty Project.

___________________________________________________
1. Introdução a Programação de Jogos com C++

1.1 - Introdução a C++

C++ é uma moderna linguagem de programação em alto nível de abstração. É uma das mais populares para criação de aplicações para computador e a mais popular no desenvolvimento de jogos.

1.1.1 - Por que C++?

- É rápido - Um dos objetivos de design do C++ é sua rapidez. Essa linguagem permite que o programador use de linguagem assembly (linguagem de baixo nível) para se comunicar diretamente com o hardware do computador. 
- É flexível - C++ é uma linguagem multi-paradigma, que suporta diferentes estilos de programação, incluindo a programação orientada a objetos, e diferente de algumas linguagens modernas o C++ não força o programador a usar um estilo de programação específico.
- É o padrão do mercado. Sendo um desenvolvedor de jogos, mais hora ou menos hora você vai se deparar com C++, e é bom estar preparado, sem contar que sabendo C++, aprender outras linguagens não será uma tarefa muito difícil.

1.1.2 - Detalhes da linguagem

- Os nomes das variáveis não podem conter outros caracteres que não as letras do alfabeto, números, e underlines ("_"). Além disso, os nomes não podem começar com um número, e não podem ser iguais às palavras reservadas da linguagem C++.

- Nomes que começam com 1 ou 2 underlines são reservados à implementação interna do programa, sendo possível, mas não aconselhável o seu uso nos nomes das variáveis que vocês forem criar.

- C++ é case sensitive, ou seja, discerne letras maiúsculas de minúsculas.

1.2 - Tipos de Variáveis

Para a criação de qualquer tipo de programa são necessárias variáveis. Variáveis são instâncias que armazenam valores  que serão utilizados no programa. Para lidar com números inteiros existem os tipos int, char, short e long, chamados tipos de variáveis inteiras. Cada um desses tipos tem um tamanho em bits diferente, e eles podem ser modificados pelos prefixos signed e unsigned. O prefixo unsigned determina que a variável só irá conter valores positivos (sem sinal); já o prefixo signed indica que a variável poderá conter dados positivos ou negativos. Por padrão as variáveis inteiras e as reais (que lidam com números reais) declaradas em C++ são signed. Esses prefixos são chamados de modificadores de faixa. Confira abaixo os detalhes sobre cada tipo:

Tipo	Tamanho em bits	Tipo de dados armazenados	Intervalo
char	8	Caractere	-128 a 127
unsigned char	8	Caractere	0 a 255
int	16	Inteiros	-32768 a 32767
unsigned int	16	Inteiros Positivos	0 a 65535
short	16	Inteiros	-32768 a 32767
unsigned short	16	Inteiros Positivos	0 a 65535
long	32	Inteiros	-2147483648 a 2147483647
unsigned long	32	Inteiros Positivos	0 a 4294967295

Existem também variáveis para armazenar números reais. São elas float e double. Confiram abaixo os detalhes de cada tipo de variável real

Tipo	Tamanho em bits	Tipo de dados armazenados	Intervalo
float	32	Números Reais (com parte fracionária) com precisão simples	1,2e-38 a 3,4e+38.
double	64	Números Reais (com parte fracionária) com precisão dobrada	2,2e-308 a 1,8e+308

O prefixo long também pode ser usado em um float, gerando assim uma faixa de valores igual à de double, e também pode ser utilizado em um double, aumentando ainda mais a faixa de valores. Tipos reais também são chamados de ponto flutuante, indicando as casas decimais após o ponto.

Além dos tipos acima há ainda o tipo lógico (booleano). Trata-se de um tipo que pode armazenar apenas dois valores: verdadeiro ou falso (true ou false), sendo o valor 0 (zero) interpretado como falso, e qualquer outro valor diferente de zero interpretado como true. Declara-se uma variável lógica por bool.
 

Você pode ainda definir novos nomes para os tipos existentes. Para isso é necessário o uso da palavra-chave typedef, seguida dos tipos e por fim do nome que será dado. Exemplo:
typedef unsigned short int ushort;
O código acima define um nome alternativo para variáveis do tipo unsigned short int.

1.2.1 – Conversão de variáveis

É possível realizar conversões entre tipos de dados. Para tal existem dois tipos de conversão: a implícita e a explícita.

       1.2.1.1 – Conversão implícita

       É realizada pela linguagem sem que o programador tenha explicitamente solicitado (por isso implícita ¬¬). As principais conversões implícitas da linguagem são a de inteiro para caracteres e ponto flutuante; de ponto flutuante para inteiro e caracteres; de caractere para ponto flutuante e inteiro. Vale ressaltar que quando se converte de ponto flutuante para inteiro ou caractere a parte fracionária é ignorada. Exemplo:

float x = 1.2345;

       int y = x;

       Nesse caso a variável y terá o valor 1.

       Conversões implícitas geram “warning” (avisos) no momento de compilação indicando a conversão.

       1.2.1.2 – Conversão explícita

       Conversões explícitas deixam sua intenção mais clara. Com ela você deixa o compilador ciente de que você quer fazer a conversão e não gera nenhum “warning” no código.

       A conversão explícita é feita passando o tipo para que seja feita a conversão (chamado de cast) entre parênteses antes da variável que contém o dado original. Exemplo:

       float x = 1.2345;

       int y;

       y = (int) x;

       Nesse caso a variável y também terá o valor 1, mas dessa vez não aparecerá nenhum “warning” na compilação.

Um projeto não vai deixar de compilar, e conseqüentemente executar, por ter “warning”, mas é uma boa prática da programação deixar o código o mais limpo o possível.

1.3 – Declarando e inicializando variáveis

Entendidos os tipos de variáveis, vamos agora utilizá-las de fato, e para isso precisamos primeiro declará-la. A declaração de variáveis segue o padrão ; , por exemplo:

int var;

Note o uso do ponto-e-vírgula no final da declaração. Ele é utilizado após cada instrução dada ao compilador, esquecer dele no fim de dada instrução irá gerar um erro de compilação.

Você pode seguir esse padrão para qualquer tipo de variável, adicionando o prefixo, caso esse exista, antes do tipo, por exemplo:

short int varShort;

Ao declarar uma variável você pode inicializá-la (atribuir valor a ela), como por exemplo:

int var = 10;

Com isso você instanciou uma variável do tipo int e atribuiu a ela o valor 10.

Não é necessário inicializar todas as variáveis ao declará-las, mas é necessário fazer isso antes de utilizá-las.

Lembre-se de atribuir um valor compatível com o tipo da variável. Atribuir um caractere a uma variável do tipo int não causaria erro de compilação, mas causaria um efeito inesperado.

Em programação é sempre bom manter suas intenções claras, então se a sua intenção é usar um caractere, então declare um char.

1.4 – Definições de Constantes

Apesar de não haver problema algum em usar valores que variam durante a execução do seu programa, alguma hora você vai preferir que um determinado valor não seja passível de mudança, por exemplo a constante PI, que será sempre (podando várias casas decimais) 3.141592. Esse valor é fixo e não mudará. E como eu disse antes, na programação é sempre bom buscar manter seus objetivos claros. Uma boa maneira de entender constantes é considerá-las variáveis de valor fixo.

Algumas considerações a fazer sobre constantes:

- Ela deve ser inicializada no momento de sua declaração

- Uma vez inicializada, você não poderá trocar seu valor durante a execução do programa.

 A declaração de constantes segue o padrão = ; . Por exemplo:

const float PI = 3.141592;

1.5 – Definições de enumeradores

Enumeradores são basicamente uma série de constantes de dados inteiros. Para declararmos um enumerador usamos a palavra-chave enum e obedecemos à seguinte sintaxe: enum { , , ...}; .

Dentro de um enumerador as constantes seguem uma ordem crescente. Será mais fácil entender com exemplos:

enum { A, B, C};

Notem que não é necessário definir o tipo da variável, já que enumeradores são seqüências de dados inteiros.

No caso acima as variáveis são inicializadas implicitamente no momento de sua declaração. Como dito antes um enumerador segue uma ordem crescente, logo, à variável A é atribuído o valor 0(zero), a B o valor 1, e a C o valor 2.

No entanto não precisamos ficar presos a seqüências começando em 0. Observe o exemplo a seguir:

enum { A = 20, B, C};

Nesse exemplo à variável A é atribuído o valor 20, a B o valor 21, e a C o valor 22.

Vocês também podem atribuir valor a uma variável no meio assim:

enum {A, B = 20, C};

Nesse exemplo à variável A é atribuído o valor 0(zero), a B o valor 20, e a C o valor 21.

Tentar atribuir um valor que não seja inteiro às variáveis contidas causará um erro de compilação.

___________________________________________________

Bom.. nossa primeira aula fica por aqui, e ela acabou rendendo um post maior do que eu imaginei! Antes de passarmos para a próxima aula é importante ter fixado os conceitos mostrados hoje.
Na próxima aula veremos operadores, diretivas de pré-processador, uso de namespaces, input/output, e finalmente escreveremos o aclamado "Hello World"!

Sobre essa próxima aula, talvez eu não consiga revisá-la a tempo de publicar na quarta, já que estarei no Rio para o SBGames '09, mas assim que eu voltar retomaremos o ritmo normal .


________________________
Baixe essa aula AQUI !
________________________