~> Original em inglês (no qual essas aulas são baseadas): http://www.relisoft.com/book/

Todas as dúvidas deverão ser tiradas por MSN ou PM.

Esse tutorial não segue normalmente as aulas " clássicas " de C++, onde simplismente apareceria uma mensagem " Olá Mundo ", mas aqui, vamos criar um mundo e fazer com que ele consiga responder a esse chamado, nos retornar uma resposta ( a longo prazo ).

 

#include <iostream>class Planeta{public:    Planeta ()  { std::cout << "Oi!\n"; }    ~Planeta () { std::cout << "Tchau!\n"; }};Planeta Terra;int main() {  }

 

Esse programa é dividido em 4 partes, sendo elas :

* Include;

* Class;

* Objeto;

* Função Main;

Include

Este atributo serve para incluir alguma biblioteca ( lib ) ao programa. No caso do nosso programa, inclue o <iostream> que seria a lib utilizada para escrever na tela do programa. O include é chamado da seguinte maneira :

 

#include <arquivo>

 

Ex :

#include <stdlib.h>

Class

Agora é um pouco mais complexo. Eu imagino da seguinte maneira, existe várias pessoas no planeta terra e todos contém características em comum, criando uma classe, a dos Humanos, dentro dessa classe vamos conter todas as características dos seres humanos, Nome, pele, altura, peso, idade, etc..

Objeto

O Objeto que irá mostrar as diferenças entre as classes. Lembra daquela nossa classe, a dos Humanos? Então, pelo menos eu não sou igual a minha mãe, então é 2 instânceas diferentes, porém da mesma classe, então eu sou uma instância da classe dos Humanos.

Um Objeto ( ou instância ) pode ser declarado da seguinte maneira:

 

Classe  Nome_do_Objeto;

 

Ex:

Planeta Marte;

Função Main

Bom, se você mostar somente a função main do nosso programa para algum programador ele irá falar que o nosso programa não faz nada.

A função main é a função principal do programa, ela é a única função realmente obrigatória em qualquer programa.

As funções contém um limite, e esse limite no caso é demarcado pelas chaves ( { e } ), no futuro estudaremos a fundo as funções.

Agora vamos trabalhar com o que aprendemos até agora no nosso programa, vamos vê-lo de trás para frente, pois assim será mais fácil.

 

int main() {  }

 

Essa é a função pricipal, mesmo sem nada dentro dela ( repare que as chaves estão vazias ) é obrigatória a sua presença no programa.

 

Planeta Terra;

 

Esse é o Objeto que foi declarado, que no nosso caso é a Terra.

Repare como é feito, pegamos uma classe ( Planeta ), e declaramos um nome ( instância ) para fazê-lo diferente. Repare também que ele está fora de uma função, quer dizer ele é Global. Um termo ser Global significa que ele está fora de qualquer função, fora das chaves de limitação de uma função.

 

class Planeta{public:    Planeta ()  { std::cout << "Oi!\n"; }    ~Planeta () { std::cout << "Tchau!\n"; }};

 

Agora vamos ver a classe Planeta, vamos ver linha por linha.

 

class Planeta

 

Cria uma classe e suas características, se você desejar também pode criar a classe dos humanos, vamos aprender a mecher com variáveis no futuro, para então realmente criar uma classe. Repare logo em seguida o " { " demarcando que existe um limite dessa função.

 

public:

 

Fala que o que vamos mecher é público. Imagine da seguinte maneira, uma conta de banco, Conta, depósitos, Retiradas, Saldo, etc., nenhum atributo da conta pode ser público, pois se não iríamos ver a conta do nosso amigo e rouba-lo .

Vamos ver isso a fundo no Futuro também.

 

Planeta ()  { std::cout << "Oi!\n"; }

 

Isso é um 'constructor', vamos dizer, toda vez que um objeto dessa classe é criado será executado esse bloco de código. O constructor obrigatóriamente tem que ter o mesmo nome da classe, se a classe fosse Humano, o constructor também seria Humano.

O constructor seria uma mini função, podendo conter atributos.

std::cout << "Oi!\n";

É uma função que contém na lib iostream, se nós não tivessemos incluido a lib no começo do projeto não iriamos conseguir utilizar essa função, a função é simples de se usar :

std::cout << "Mensagem";

Este pequeno bloco de código imprime a mensagem Oi! na tela, o " \n " seria uma nova linha.

 

 ~Planeta () { std::cout << "Tchau!\n"; }

 

Isso é um 'destructor', quer dizer, esse code será executado toda vez que uma classe for destruída ( provavelmente quando fechar o programa ).

O destructor é demarcado pelo ~ ( Til ) antes do constructor, e como já vimos ele envia a mensagem Tchau! a tela.

 

#include <iostream>

 

e nosso querido include que já falamos a respeito dele.

Bom... Logo após compilar, vocês irão rodar o programa, e vcs perceberão que uma coisa preta abrirá, ficará por uma fração de segundo e depois sumirá. Por isso eu utilizo o command ( cmd ), para abri-lo vá em Iniciar, Executar, então digite " cmd " e abrirá uma janela do MS-DOS.

Chegue até local do projeto e execute o arquivo .exe então vc poderá ver o que ocorreu.

Utilizando os comandos :

cd diretório

vai até um diretório

cd ..

volta uma pasta

dir

lista todos os arquivos presentes no local que vc está.

você deverá ver da seguinte maneira ( somente os diretórios diferentes )

 

 

 

Bem... Isso é tudo pessoal!~

</span>

Então significa que não há o que postar, pois cada aula será seguida de um Post...

Bom, agora vamos começar a trabalhar com espaço e argumentos.

Lembra na aula passada quando eu expliquei instance ( ou objeto )? Bom, agora então vamos começar a falar de espaço, e como conseqüência, espaço da Instance. Espaço ( scope ), é basicamente o local que ele se situa. Eu separo um programa em 2 scopes, o Global e o Local. Scopes Globais são inicializados fora de funções e eles só são destruidos ( executa o destructor ) apenas o final de main ( já executou todas as funções necessárias ), um exemplo de um Scope Global seria o nosso "Planeta Terra;" da lição anterior, ele é executado antes da função main e somente é destruido após do término da mesma. Scopes Globais são aqueles que duram somente o tempo da função ou do bloco de condição que ele se encontra.

 

#include <iostream>class Planeta {public:    Planeta (int i)    {        std::cout << "Ola de " << i << ".\n";    }    ~Planeta ()    {        std::cout << "Tchau.\n";    }};Planeta Terra (1);int main(){    Planeta Marte (2);    std::cout << "Ola de Main!\n";}

 

Vamos novamente ver o nosso programa de baixo para cima.

Função Main

Lembra de como eu ensinei vocês a declarar um Instance ( Objeto )? eu enganei vocês, pois na verdade é :

 

Classe  Nome_do_Objeto ( Variáveis );

 

Sendo cada variável separada por uma Vírgula, Ex.: Humano Adriano ( 16, 67 );

Agora, porque enganei vocês? Simples, porque caso eu falasse isso vocês iriam fazer um "( )", então o programa não funcionaria. Existem alguns casos no qual você não pode utilizar os parênteses em branco ( vazio ), um desses casos é esse.

agora vamos olhar para nosso instance já indentificado e compreendido.

Planeta Marte (2);

Planeta, chama a classe no qual ele vai utilizar. Marte, o nome escolhido. (2), variável a ser enviada ao constructor.

Toda vez que um instance é declarado com alguma variável, essa variável vai para o constructor, e não para alguma variável declarada dentro do constructor ou da classe.

Nesse caso, Marte é um Scope local, pois logo em seguida que a função acaba ele é destruído.

std::cout << "Ola de Main!\n";

uma simples chamada da função cout para escrever a mensagem na tela.

Scope Global

Existe somente um, o " Planeta Terra (1); ", que já foi explicado. Lembre que este instance será destruido somente após o término da função main.

Class

Aparece somente 2 coisas novas, o " int i " dentro dos parênteses do nosso constructor e o " << i << ".

O " int i " é a declaração de uma variável, ainda não vamos aprofundar nisso, somente vou dar uma explicação básica. Int é como se declara uma variável, int é um ' declarador ' cujo mesmo só aceita variáveis inteiras, e o conceito de scopes continua ativo nas variáveis, somente é válida no scope no qual ela se situa, basicamente isso. Não se confunda pensando que utilizamos " int main () " significa obrigatóriamente que só aceita valores inteiros, veremos isso mais para frente quando vermos funções.

Então pelo que já sabemos, o nosso constructor espera uma variável ( pois ele declarou uma! ), então ele utiliza a mesma para imprimi-la na tela depois.

O " << i << " é uma forma de imprimir uma variável na tela, é só pensar, se " inicia um texto ( string ) e foi utilizado " << " antes de começar uma string, se vc fechar as aspas e colocar << vc estará inicando outro bloco de string, porém para pular linha vc necessita do "\n".

Agora ao você compilar esse programa, você receberá a seguinte mensagem :

Ola de 1.

Ola de 2.

Ola de Main!

Tchau.

Tchau.

Bom, nosso programa está funcionando, porém quem enviou o 1° Tchau e quem enviou o segundo ? Nós sabemos graça a explicação de scopes que eu passei ao começo da aula, mas e se nós estivessemos trabalhando com um programa mais complexo, como saberíamos?

Então antes de arrumar essa falha vou voltar nos instances. Uma classe não é nada sem um instance, o instance então se torna a identidade de um novo instance em relação a classe. Não estou dizendo que a classe não é nada, mas sim que o instance não é nada sem a classe. Infelizmente o nosso destructor não é que nem o nosso constructor, quer dizer que pode ser declarado variáveis, ele infelizmente não pode. Se você tentar declarar alguma variável lá retornará um erro, pois destructors não podem haver argumentos. Então, como vamos fazer para mostrar ao Tchau a quem ele pertence já que não podemos declarar nada no destructor e não podemos utilizar a variável i que foi declarada no constructor, então só funcionará para o mesmo. Então vamos dar um pouco de memória ao programa da seguinte forma, adicionando uma segunda variável e trabalhando com ela.

Dando memória a ele, ele ficará dessa maneira :

 

#include <iostream>class Planeta {public:    Planeta (int i) : _identidade (i)    {        std::cout << "Ola de " << i << ".\n";    }    ~Planeta ()    {        std::cout << "Tchau de " << _identidade << ".\n";    }private:    const int _identidade;};Planeta Terra (1);int main(){    Planeta Marte (2);    std::cout << "Ola de Main!\n";}

 

Apareceu 3 novas coisas,

1° Private, isso significa que somente a classe em si poderá modificar esta variável;

2° const, isso significa que o valor da variável é constante, quer dizer após inicializado o valor permanecerá o mesmo até o término no programa;

3° " : _identidade (i) ", significa que o valor de _identidade será igual ao valor de i.

Reparem também que eu utilizei um underline antes da variável, isso é simplismente por uma questão de entendimento, todas as variáveis que serão private virão com um underline antes do mesmo ( se você quiser pode utilizar sem, porém lembre da declaração que deve ser igual, pois o C++ é Case Sensitive, quer dizer "ab" é diferente de "aB" que é diferente de "Ab", assim sucessivamente ).

Essa parte após os dois pontos, também é conhecida como " preamble ".

Simples não?

Para continuar, vou ensinar-lhes um loop.

Ele funciona da seguinte maneira :

 

for (função 1; função 2; função 3){   }

 

sendo:

função 1, a declaração de uma variável ( através do int, somente o que aprendemos até agora );

função 2, condição para continuar ( depois veremos todas as condições );

função 3, o que acontece caso for verdadeiro e o bloco de código for executado com sucesso.

Caso não deseja utilizar uma das expressões necessárias apenas adicione o ; como se obtivesse uma.

Ex.:

for(int id = 3; id < 6;){  }

 

Ex. 2:

for(int id = 3; id < 6; id++){  }

 

Lembrando que o for cria um scope local, quer dizer quando ele termina todas as variáveis utilizadas nele são destruidas.

Vamos a um programa simples utilizando o for :

 

#include <iostream>class Planeta {public:    Planeta (int i) : _identidade (i)    {        std::cout << "Ola de " << i << ".\n";    }    ~Planeta ()    {        std::cout << "Tchau de " << _identidade << ".\n";    }private:    const int _identidade;};Planeta Terra (1);int main(){    Planeta Marte (2);        for (int i = 3; i < 6; ++i)    {        Planeta MeuMundo (i);    }    std::cout << "Ola de Main!\n";}

 

Lembre-se sempre dos scopes, pois somente foi possível utilizar "Planeta MeuMundo (i)" pois após o término do loop do for ele checa se pode continuar, e nesse check é destruido o loop anterior e criado num novo loop, caso vc tentasse criar uma instance com um nome já apresentado anteriormente e o mesmo não foi destruído ( Ex.: Planeta Terra (i); sendo que i pode ser qualquer número inteiro ) irá retornar um erro dizendo que ele já foi declarado anteriormente.

Por uma questão de estética e entedimento do programa, sempre utilize corretamente as chaves, nunca faça isso :

 

for (int i = 3; i < 6; ++i) { // Não Faça isso!    Planeta UmMundo(i);}

 

Repare sempre como está organizado o pograma que eu repasso a vocês.

Última coisa a aprender hoje :

Há 2 formas de se comentar, uma é utilizando 2 barras transversais ( // ) que pegará todo o resto da linha, e será ignorado pelo compilador na hora de compilar, ou utilizando /* e */ respectivamente para o início e o fim do bloco comentado, excelente para utilizar no meio de bloco de códigos que somente é para lembrar algo, Ex.:

 

for (int i = 3; i < 6 /* se i for menor que 6 continua */; ++i) {    Planeta UmMundo(i);}

 

Por hoje é só ^^

Lembrando...

</span>

Embedded Objects - Relações entre Instâncias

A cada aula que eu coloco aqui será necessário o saber da lição anterior, então caso você não compreendeu algo, pergunte para mim no MSN, acho que esta aula é a primeira aula complexa que teremos, se não entender, leia e releia até compreender, não há outra forma.

Basicamente, embendded é encaixar, encaixado. Quer dizer, um bloco de códigos encaixado no outro, por alguma forma. No nosso caso vamos chamar o código a ser encaixado através do preamble.

Uma classe, criada vai ter um constructor que por sua vez vai ter um preamble que por sua vez vai ter uma variável que vai chamar uma outra classe que por sua vez vai executar seu bloco de código e seguir adiante.

 

#include <iostream>class Universo{public:    Universo (int id)        : _identidade(id)    {        std::cout << "  Universo " << _identidade << " criado\n";    }    ~Universo ()    {        std::cout << "  Universo " << _identidade << " destruido\n";    }private:    const int _identidade;};class Planeta{public:    Planeta (int id)        : _identidade (id), _universo (_identidade) // inicialidando Embenddings    {        std::cout << "Ola do mundo " << _identidade << ".\n";    }    ~Planeta ()    {        std::cout << "Tchau do mundo " << _identidade << ".\n";    }private:    const int        _identidade;    const Universo   _universo; // Instance Embendded do Tipo Universo};Planeta oUniverso (1);int main (){    Planeta MeuPlaneta (2);}

 

Repare que o preamble é parecido com declaração de variáveis, porém ele não termina com ponto e vírugla ( ; ).

Repetindo toda a história do começo, agora seguindo o exemplo dado.

É criado a instance oUniverso com variável 1, então ele executa seu preamble que por sua vez executa a classe Universo e cria uma outra instance que executa o seu constructor que então retorna a onde havia parado na classe anterior.

Lembrando que é necessário ter cuidado na ordem que a classe é escrita, pois ela é executada na ordem que ela é escrita.

Somente retomando, a primeira instance será a última a ser destruída, a segunda a penúltima, assim sucesivamente.

Agora uma parte simples, como representar gráficamente. Essa classe é mais conhecida como "Embedded", provavelmente vou começar a chamar dela mais dessa forma. Caso você for fazer uma imagem, um gráfico, já existe uma forma correta de como fazer e falar, é utilizando o "has-a", Universo has-a Planeta.

E o gráfico é dessa forma :

</span>

Inheritance - Relações entre Objetos ( Parte 2 )

Basicamente, inheritance é uma classe que é uma outra classe mais utiliza atributos da classe base. Um bom exemplo seria os carros. Um carro ( class Carros ) contém obrigatóriamente porta, motor, rodas, motorista, etc., agora uma marca Ferrari ( class Ferrari ), continua sendo um carro, então utilizaremos os atributos da classe Carros sem precisar declaralos novamente. Outro exemplo. Um corpo Celestial, contém massa, e as estrelas, a estrela é um corpo Celestial, porém tem alguns stributos próprios mais todos os atributos normais de um corpo Celestial.

Para utilizar um inheritance, é simples, após a declaração da classe utilize : ( publico, privado ) Classe_Basse

Exemplo :

 

#include <iostream>class CorpoCelestial{public:    CorpoCelestial (double massa)        : _massa (massa)    {        std::cout << "Criando um corpo celestial de massa " << _massa << "\n";    }    ~CorpoCelestial ()    {        std::cout << "Destruindo um corpo celestial de massa " << _massa << "\n";    }private:    const double _massa;};class Estrela: public CorpoCelestial  // Estrela é um CorpoCelestial{public:    Estrela (double massa, double brilho)        : CorpoCelestial (massa), _brilho (brilho)    {        std::cout << "Criando uma estrela de brilho " <<               _brilho << "\n";    }    ~Estrela ()    {        std::cout << "Destruindo uma estrela de brilho " <<             _brilho << "\n";    }private:    const double _brilho;};int main (){    std::cout << "    Entrando em Main.\n";    Estrela umaEstrela ( 1234.5, 0.1 );    std::cout << "    Saindo de Main.\n";}

 

A linha:

 

class Estrela: public CorpoCelestial  // Estrela é um CorpoCelestial

 

fala ao compilador que a Estrela é um CorpoCelestial, se a classe CorpoCelestial contém um atributo de nomeado _massa, então toda e qualquer estrela também terá um atributo nomeado _massa.

Repare agora em uma coisa interessante, eu coloquei "public CorpoCelestial", isso significa que todos os atributos que contém a classe CorpoCelestial será imposto da mesma forma, se uma variável é pública, era será publica e se uma variável é private ela continuará a ser private.

Se você colocasse "private" no lugar de public, todas as variáveis ( até as publicas ) se tornariam privadas.

Como na aula anterior, também a uma forma de representar graficalmente. Utiliza-se "is-a" para Inheritances.

O gráfico deve ser da seguinte Forma :

</span>

Bom, começamos as nossas aulas definindo o que é classe, instance, brincamos de construir e destruir instances, aprendemos a mecher com constructors, destructors, aprendemos muita coisa já, porém não é nem um milésimo do que ainda vamos aprender pela frente. Afinal, instances não servem apenas para fazermos essa brincadeira, senão seria realmente inútil existir essa funcionalidade no C++. Então a partir de agora vamos dar o início do trabalho com funções, e como conseqüência começar a trabalhar com objetos e funções ao mesmo tempo. Para isso vamos rever 2 conceitos já apresentados, eles são o int e o double. int, declara uma variável que aceita somente número inteiro; double, declara uma variável que aceita números inteiros até números com casas decimais. Agora vamos aprender somente o básico de mais 2 conceitos, que são eles o void e o return. void, declara algo que não retornará nada como resposta ao término de uma função específica e ou uma condição. return VALOR;, retorna um valor como resposta da função, esse "VALOR" pode ser uma variável, pode ser verdadeiro ou falso ( true e false ), assim vai.

Agora vamos começar a trabalhar com o aprendido. Olhem esse programa :

 

#include <iostream>class  InputNum{public:    InputNum ()    {        std::cout << "Entre um numero ";        std::cin >> _num;    }    int GetValue () const {  return _num; }private:    int _num;};int main(){    InputNum num;    std::cout << "O valor e " << num.GetValue() << "\n";    return 0;}

 

Vamos separar ele em 3 partes, para poder ver melhor.

Includes, Classes e Função Main.

Includes

Nada de novo.

Classes

Agora vemos uma função nova, ela é a "std::cin", ela pega o valor digitado pelo usuário e o coloca na variável, no caso do nosso programa ele pega o valor digitado e adiciona a variável private _num ( sabemos que é private por causa do underline antes da variável, como já havia dito que ia usar para variaveis privates ).

então seguindo em frente, achamos nossa primeira função.

 

int GetValue () const {  return _num; }

 

Uma função basicamente é declarada da seguinte forma :

 

Tipo Nome (Variáveis) Atributos{}

 

Lembrando que as variáveis serão declaradas ( como no preamble ) e os atributos serão os atributos da função.

Seguindo a rotina que passei, sabemos mais sobre a função. int, é o tipo da função, retornará um valor inteiro; GetValue, é simplismente o nome da função; (), significa que não utilizaremos qualquer variável nessa função, não precisaremos pegar nenhuma informação externa quando a função é chamada ( durante a função talvez possamos precisar, por isso apenas quando é chamada ); const, é o atributo da função, diferente de preambles não precisa dos dois pontos após as variáveis, com isso podemos ver que a função é constante, quer dizer, não será aceita nenhuma mudança de valor enquanto a função estiver em andamento.

Agora nosso conceito definido no começo vai ser utilizado, o return. Ele simplismente retorna um valor como resposta a quem o chama, é equivalente a uma conversa, fulano chama ciclano ( main chama função ) como resposta ciclano percebe e responde ao chamado ( retorna um valor ).

 

return _num;

 

essa linha de código diz que quando a função for chamada o valor de _num será enviado como resposta

 

private:    int _num;

 

Vamos aprofundar apenas mais um pouco em relação a private e public, public significa que qualquer momento qualquer função poderá modificar o seu valor, diferente de private, private é privado, reservado, quer dizer somente a classe poderá mudar e acessar o seu valor ( lembre-se de que quando eu digo a classe não digo ela em si, mais sim talvez até funções contidas dentro da classe ).

Função Main

No começo dela vemos a declaração de uma instance, a chamada "num", com essa mesma instance é chamada uma função ( num.GetValue() ), como já vimos anteriormente a função GetValue retorna o valor da variável _num, então seria um simples _num, mas como não é uma variável global e sim uma variável específica do nosso instance num colocamos um ponto para acessar algo dela, assim num._num, assim retornaria o valor de _num, porém não retorna porque _num é private ( privado ) e somente quem está dentro da classe pode ver e ou modificar o seu valor, então criamos uma função para retornar o valor dela que é a GetValue() e chamamos ela para retornar o valor de _num.

Repare que _num não pode ser declarado como constante ( const ) no preamble, porque durante a execução do programa o seu valor é modificado ( se quiser tente declarar para ver o erro! )

Agora vamos criar uma função para modificar o valor de _num. Vamos lembrar que _num é private, então somente uma função de dentro da classe no qual ela pertence pode modifica-la. Como não vamos retornar nenhum valor quando a função for chamada vamos utilizar o novo termo, o void. A função espera uma variável para colocarmos o valor de _num igual a essa variável, então não se esqueça de declarar as variáveis que iremos utilizar.

Fazendo essa função ficará mais ou menos dessa forma :

 

 void SetValue (int i) { _num = i; }

 

vocês já devem saber onde ela deve ficar, e saber como chamá-la ( caso não, "instance.SetValue (VALOR)" onde VALOR seria equivalente a qualquer número inteiro ), lembre que nunca poderemos colocar essa função como constante ( const ), pois ela modifica um valor, então como vamos modificar um valor e manteremos a função const ( funções const não aceitam nenhuma modificação durante a execução de sua função ).

Wow, aula grande e complicada

lembrando apenas...

</span>

Desde o começo das aulas, viemos mandando escrever na tela através da função std::cout << e pegando valores através da função std::cin >>, como conseqüência vocês já devem estar cansados de tanto escrever "std::", então vamos aprender como omitir isso, é bem simples, da seguinte forma :

 

using std::cout;

 

Você pode utilizar o mesmo método para o cin, porém há um modo de omitir todos os "std::" ( em futuras funções que poderemos utilizar ), é da seguinte forma :

 

using namespace std;

 

Utilizando somente um seria o suficiente para todos os stds que iriamos utilizar, assim será necessário utilizar apenas "cout << " e não mais " std::cout << ".

Seguindo a aula vamos ver esse programa e estuda-lo.

 

#include <iostream>using std::cout;using std::cin;class  InputNum{public:    InputNum ()    {        cout << "Coloque um numero ";        cin >> _num;    }    int GetValue () const {  return _num; }    void AddInput ()    {        InputNum aNum;  // pega mais um valor ( adiciona uma nova instance )        _num = _num + aNum.GetValue ();    }        private:    int _num;};int main(){    InputNum num;    cout << "O valor e " << num.GetValue() << "\n";    num.AddInput();    cout << "Agora o valor e " << num.GetValue() << "\n";    return 0;}

 

Realmente essa parte é mais prática, para compreendermos...

Vamos apenas olhar a função main, depois o que ela chama.

 

InputNum num;

 

Decalra uma nova instance como conseqüência, chama o constructor da classe InputNum, que por sua vez gera uma mensagem na tela e pega um valor e o adiciona a variável _num ( que pertence a instance num ).

 

    cout << "O valor e " << num.GetValue() << "\n";

 

manda uma mensagem na tela e pega o valor de _num através da função que montamos.

 

num.AddInput();

 

Chama a função AddImput como " dono " o instance num. Então vamos para a função AddImput();

 

void AddInput ()    {        InputNum aNum;  // pega mais um valor ( adiciona uma nova instance )        _num = _num + aNum.GetValue ();    }

 

Pelo começo da função já vemos que não vai retornar nada, e também já que não há um const sabemos que modifica o valor de algo. Na primeira linha do conteúdo da função já vemos que ele cria uma nova instance chamada "aNum", que envia a mensagem e pega o valor digitado pelo usuário. Na segunda e última linha do code vemos que ele dá um novo valor a _num, que é o valor de _num somado com o valor da variável _num da instance aNum ( aNum._num ).

Então seguindo com a função main ele manda uma mensagem do novo valor de _num de instância num.

então o return da função como 0.

Agora vamos ( finalmente ) aprender os Operadores que se pode utilizar em C++.

Provavelmente vocês devem estar com dúvidas sobre esse Divisão Modular, é bem simples, ele retorna o "resto" da divisão, por exemplo 10 % 3 = 1.

O Unário positivo não serve para nada ( se pensarmos ), pois se a = 2, e utilizarmos -a ficará a = -2, se utilizarmos -a novamente voltará a = 2, porém existe este unário.

Agora vamos a um programa novo :

 

#include <iostream>using std::cout;using std::cin;class  InputNum{public:    InputNum (char msg [])    {        cout << msg;        cin >> _num;    }    int GetValue () const {  return _num; }    void AddInput (char msg [])    {        InputNum aNum (msg);        _num = GetValue () + aNum.GetValue ();    }        private:    int _num;};const char SumString [] = "A soma e   ";int main(){    InputNum num ("Coloque um numero ");    num.AddInput ("Outro numero ");    num.AddInput ("Outro ");    cout << SumString << num.GetValue () << "\n";    return 0;}

 

Primeiro vamos aprender o que é string. String é um conjunto de caracteres. Resumindo, toda palava, frase, é um string.

Agora olhe o programa, apareceu um declarador novo, ele é o char.

O char declara strings com 8 bits ( pelo menos na maioria dos computadores ) e sempre termina com um zero. Quer dizer, a string "Oi" contém 3 caracteres, "O" "i" e 0, isso quer dizer que 0 envia um término de string, porém vc pode escrever 0 em suas string normalmente, não terá nenhum problema. Para enviar um término a string utilize \0, assim omitirá o que vier a frente da string.

Ex.: "Bla Bla \0 Ble" irá exibir "Bla Bla "

Utilizamos \n para uma quebra de linha, uma nova linha, porém tambem podemos utilizar endl também, a sintase de execução é :

 

std::cout << std::endl;

 

Como endl pertence a uma lib standard você também pode utilizar a definição ( using std::endl; ) para utilizarmos somente endl, ou se utlizado o using namespace std;, não seria necessário o using.

Repare um detalhe no programa, utilizamos a função GetValue() 2 vezes seguidas na função AddInput, porém repare que uma é do objeto aNum e outra é do objeto que foi criado primeiro ( num ). Felizmente isso não faz nenhum gasto de memória a mais do que se utilizarmos simplismente _num ( que nem no primeiro programa de hoje ) e também utilizamos a função para não termos manutenções futuras.

</span>

Quanto tempo não? ^^

Bom continuando com as aulas, finalmente vamos aprender todos os tipos de variáveis e funções.

Tipos

bool - Expressa dois tipos de valores true ou false, qualquer valor diferente de 0 é interpretado como true e 0 respectivamente como false.

int - Expressa um valor inteiro.

double - Expressa um número fracionário ( com casas decimais ).

float - Expressa um número fracionário com até 2 casas decimais ( cópia barata do double ).

char - Expressa uma cadeia de caracteres ( characters ).

void - Expressa um tipo vazio, um "sem tipo".

Modificadores

short e long - Expressa respectivamente um número pequeno e um número longo ( não sei explicar de outra forma ).

unsigned e signed - seria para informar ao compilador se o número contém sinal ou não, unsigned [un ( sem ) signed ( sinal )] e signed ( sinal ).

Exemplo :

 

    char cVar = 't';    int iVar = 298;    float fVar = 49.95;    double dVar = 99.9999;    bool bVar = (2 > 3); // false    bool BVar = false;    unsigned long int = 526846864;

 

Assim vai, todos os valores contém um limite, por exemplo o int ( 2 bytes ) sem nenhum adicional pode ter um valor de -32.768 a 32.767. O maior valor que se pode obter é um long double.

Asseguir a tabela de todos os limites.

 

 

 

Perceba que na tabela contém uma coluna que é de uma função "scanf()" que veremos mais para frente.

Provavelmente você ficará cansado uma hora de tanto digitar unsigned long, long int, assim vai.

Então logicamente você pode utilizar um "atalho" esse atalho é conhecido como typedef. Basicamente é da seguinte forma :

 

typedef TIPO NOME;

 

Ex: typedef unsigned long ulong;

Assim toda vez que digitassemos ulong o compilador iria aceitar como se vc tivesse digitado unsigned long. Certas vezes vocês verão em sources de programas coisas que achamos irônicas, do tipo "typedef int INT;", ninguém sabe o porque o programador fez isso neste momento, mas ele fez.

</span>

Bom, primeiramente gostaria de parabenizar você que realmente chegou até aqui, leu post por post, entendendo aula por aula, pois eu duvido muito que isso tenha ocorrido com alguém porém tudo bem, a vida continua. Um professor não pode se jogar de um precipício porque um aluno dele não fez a lição de casa ou não entendeu a matéria.

No C++ felizmente há um recurso bem interessante, seria poder separar o seu programa em vários arquivos e como conseqüência em outros 2 tipos, headers e Arquivos de bloco de códigos. Respectivamente, headers são arquivos terminados em ".h" ( header ) ou ".hpp" ( header plus plus ) e Arquivos de bloco de códigos são os arquivos terminados em ".c" ou "c++".

Bom... vamos ver o meu stack.h :

 

const int maxStack = 16;class IStack{public:    IStack () :_top (0) {}    void Push (int i);    int  Pop ();private:    int _arr [maxStack];    int _top;};

 

Até agora nada de novo. A primeira linha declara a variável maxStack com o valor de 16 e fala que o valor dela não mudará durante a execução do programa inteiro ( const ), então é declarada a class IStack, o contructor onde faz a variável _top adiqüirir o valor 0 e então finalmente algo novo. Foi declarado 2 funções porém não foram inicializadas, quer dizer, apenas foi declarado a sua existência. Percebemos isso através da forma da inicialização, 1° porque não tem as chaves que delimitariam a atuação da função; 2° Porque tem parênteses então significa que está esperando argumentos para o início da mesma. Então a declaração da variável _arr com um delimitador que seria maxStack.

 

#include "stack.h"#include <cassert>#include <iostream>using std::cout;using std::endl;void IStack::Push (int i){    assert (_top < maxStack);    _arr [_top] = i;    ++_top;}int IStack::Pop (){    assert (_top > 0);    --_top;    return _arr [_top];}int main (){    IStack stack;    stack.Push (1);    stack.Push (2);    cout << "Popped " << stack.Pop() << endl;    cout << "Popped " << stack.Pop() << endl;    return 0;}

 

Primeiramente vamos ver os includes. Ele inclui o arquivo "stack.h" que dele tiraramos a declaração da class. Depois um novo o "cassert", não vamos aprofundar, basicamente vamos utilizar ele da sua atual forma, como um Debbuger ( para vermos onde foi o erro ), ele retornará onde foi o erro ( linha ) e qual foi o erro na tela caso ocorra um erro.

Dpois vimos as funções Pop() e Push (int i), porém com um detalhe novo, o "IStack::" antes, isso significa que as funções pertencem a classe "IStack", então vimos aquela função no qual eu disse que era mágica, ela pertence ao "cassert" e o nome é assert ( condição ). Caso a condição for falsa retorna a mensagem que eu já comentei caso for verdadeira simplismente "ignora" a função.

Depois na função main outra coisa interessante, para chamar a função Pop() foi utilizado a instância stack ( previamente declarado ), pois como a função pertence a classe IStack devemos chama-la pela classe, caso não pertencece a classe poderiamos simplismente pelo nome e atributos ( e ela não teria a "CLASE::" antes do nome ).

Agora vamos ver um conceito que será trabalhado durante o curso, que é inline e non-inline. Uma função inline é aquela função que ela é feita dentro da classe ( funções de qualquer lição anterior menos a main ), mas o nome não é simplismente por isso. Quando uma função é inline o 'bloco de código' dela é 'adicionado' a função atual, quer dizer há uma redução de espaço e tempo, aumentando a velocidade de execução do programa. E o non-inline é toda função que é declarada fora da classe ( Ex.: Pop () ), para uma função non-inline ser executada a função que a chama para, chama a função non-inline então recebe o resultado então continua a função no qual a chamou. Isso faz um gasto de tempo maior do que gastaria com uma inline. Essa é uma das razões do porque o C++ é melhor e uma das explicações da sua velocidade maior do que outras linguagens de programação.

</span>