Expressões de Caractere.

São declaradas exatamente como inteiros, mas com a palavra-chave char no lugar de int. Ex: 

char NomeDoCaractere

As constantes são definidas como um único caractere, com aspas simples. Ex:

char letraA = 'A';

Oriento para melhor entendimento, uma pesquisa sobre codificação de caracteres. Não vou entrar em detalhes aqui, basta seguir os exemplos sugeridos nos códigos com a codificação de caractere já inserida.

Vamos seguir com um programa, que permite vc brincar com os caracteres ASCII.

------------------------------------------------------------------------------------------------------------

#include<cstdio>
#include<cstdlib>
#include<iostream>


using namespace std;

int main (int nNumberofArgs, char* pszArgs[])
{
 //Vamos pedir o valor através do prompt de comando.
 int nValor;
 cout << "Digite um numero decimal: ";
 cin >> nValor;

 //Agora, vamos imprimir o caractere correspondente ao digitado.
 char cValor = (char)nValor;
 cout << "O caractere correspondente ao digitado foi: [" << cValor << "]" << endl;

system("pause");
return 0;
}
------------------------------------------------------------------------------------------------------------
#Dica.
Na execução do program acima, sugiro, apenas para ilustrar, inserir os seguintes números para ver o resultado:
63
5
6
7

O (char) que aparece na frente de nValor é chamado de cast (instrução que converte uma variável de um tipo em outro tipo), o qual converte o valor de nValor de um int para um char. 

Para facilitar nossa vida, C++ permite que vc codifique uma sequência de caracteres, fechando a string, sequência, entre aspas duplas. Ex:

cout << "Digite um numero decimal";

É possível codificar qq caractere, impresso ou não, basta colar seu valor em octal depois de uma barra invertida. Ex:

char cEspaco =  '\040';

Sugiro uma pesquisa sobre octal, base de 8 e hexadecimal, base 16.

#Informação importante!
No windows, a barra invertida é usada nos nomes dos arquivos. Ex:
C:\Base Directory\Subdirectory\File Name

Para utilizar a barra invertido nesta situação, cada barra deve ter outra. Ex:
"C:\\Base Directory\\Subdirectory\\File Name"

Expressões Inteiras.

Declarando Variáveis.

A declaração de uma variável inteira começa com a palavra-chave int seguida pelo nome da variável e um ponto e virgula. Ex:

int n1;

Todas as variáveis em C++ precisam ser declaradas antes que possa ser usadas.

Cada variável tem um valor quando é criada, porém, ate que seja designado um determinado valor a ela, uma variável simplesmente aceita qq valor inútil que esteja no mesmo local de memoria que ela foi alocada.

Para designar uma valor a variável, vc deve usar o sinal de igual (=). Ex:

int n;

n = 1;

Vc também iniciar a variável na hora que é declarada. Ex:

int n = 1;

Constantes Inteiras.

C++ entende qq símbolo que comece com um dígito e só contenha dígitos como sendo constante inteira.

Ex: 

123

1

256

Mas veja, não pode ter caracteres estranhos. Ex de errado:

123z456

Expressões.

Variáveis e constantes são úteis se usadas para fazer cálculos.

As expressões sempre envolvem variáveis, constantes e operadores. Um operador executa alguma operação aritmética em seus argumentos. Temos operadores binários e unários.

Toas as expressões retornam um valor e um tipo.

Operadores binários.

É aquele que toma dois argumentos.

*, /, %, +

Multiplicação, divisão, adição, subtração e módulo.

Uma única expressão pode conter incluir múltiplos operadores. Quando os operadores são iguais, C++ avalia a expressão da esquerda para a direita. Ex:

5 + 100 + 32

500 + 32

532

Quando são diferentes, C++ usa uma propriedade chamada precedência, que é a ordem pela qual os operadores são avaliados.

Caso queira, vc pode alterar a precedência dos operadores, envolvendo em parenteses as expressões que deseja que sejam executadas primeiro. Ex:

int n = 5 * (100 + 32);

Assim, a adição é executada antes da multiplicação.

Operadores Unários.

São aqueles que tomam um único argumento, são eles: -, ++,--.

Os operadores ++ e -- aumentam e diminuem seus argumentos em um.

Estes operadores, ++ e --, vêm também em duas versões: um prefixo e uma sufixo.

Ex: de prefixo: ++n.

Ex: de sufixo: n++.

Ambos aumentam seus argumentos em um, a diferença esta no valor retornado. O prefixo retorna valor depois da operação de incremento, enquanto o sufixo retorna o valor do incremento.

Vamos ver em um programa.

------------------------------------------------------------------------------------------------------------


#include<cstdio>
#include<cstdlib>
#include<iostream>


using namespace std;

int main (int nNumberofArgs, char* pszArgs[])
{
  //Demosntrando incremento e decremento

   int n;
   //Primeiro o prefixo
   n = 1;
cout << "O valor de n e: " << n << endl;
cout << "O valor de ++n e: " << ++n << endl;
cout << "O valor de n  depois e: " << n << endl;
cout << endl;

//Agora, o sufixo
n = 1;

cout << "O valor de n e: " << n << endl;
cout << "O valor de n++ e: " << n++ << endl;
cout << "O valor de n depois e: " << n << endl;
cout << endl;


system("pause");
return 0;
}

------------------------------------------------------------------------------------------------------------
Veja que nos dois casos, a variável n é inicializada para 1 e, após a execução, é incrementada e decrementada.