Sistema de Conta Bancária com Orientação a Objetos em C++

 Neste tutorial, vamos usar todo nosso conhecimento de Programação Orientada a Objetos, e criar um exemplo real de aplicação, uma conta bancária.

Exercício: Conta Bancária

Crie um sistema em que uma conta bancária de usuário é criada, onde ele pode checar seu saldo, depositar e sacar dinheiro, use os conhecimentos de orientação a objetos.

Seu sistema deve iniciar exibindo um menu com essas opções, e permita que o usuário faça essas operações quantas vezes ele quiser, e decida quando fechar o sistema.

A classe: Client.h

O saldo do cliente vai ficar armazenado na variável cash. Ela é inicializada com valor 0, na função construtor, ou seja, o cliente obviamente começa com 0 de dinheiro.

Temos a função menu(), que vai ficar exibindo o menu de opções, ou seja, a tela do caixa eletrônico do sistema bancário. Ela invoca a função action(), que vai chamar cada operação específica.

A primeira operação é a checkBalance(), que vai checar o balanço, o saldo da conta. 

Depois tem a função depositCash(), que serve pra adicionar dinheiro na sua conta.

Por fim, a função withdraw(), pra sacar dinheiro.

Nossa classe fica assim:

#ifndef CLIENT_H
#define CLIENT_H


class Client
{
    public:
        Client();
        void menu();
        void action(int);
        void checkBalance();
        void depositCash();
        void withdraw();

    private:
        double cash;
};

#endif // CLIENT_H

Código-fonte: Client.cpp

Tudo vai começar por onde deve começar, pela função construtor Client().
Ela simplesmente zera seu dinheiro, pois é como se sua conta fosse criada no momento que instanciou o objeto.

A função menu() vai ficar exibindo um menu de opções pro usuário, e pedindo pra ele digitar algum valor. Esse valor é armazenado na variável op e enviado para a função action(), isso é feito dentro de um laço do while, que só terminar se você digitar 0. Ou seja, só sai do menu, se digitar 0 pra sair.

A action() vai tomar uma ação, avaliando o valor op recebido da menu(). Isso é feito num teste condicional switch.
Se for 0, diz que o sistema está encerrando.

Se for 1, invoca a função checkBalance(), que simplesmente vai exibir a variável cash. Nada demais.

Na depositCash(), pedimos um valor ao usuário. Mas temos que testar se esse valor é positivo, pois obviamente não tem como depositar valor negativo. Esse teste é feito num IF ELSE. Se o valor for positivo, simplesmente adicionamos ele ao cash e exibimos o balanço do usuário.

Na função withdraw(), perguntamos o valor que o usuário deseja sacar. Antes de retirar esse valor da variável cash, precisamos avaliar se ele é menor que cash. Afinal, você só pode sacar algo abaixo, ou no máximo igual ao seu saldo. Esse teste é feito com um IF ELSE também.

Veja como fica o código:

#include "Client.h"
#include <iostream>
using namespace std;

Client::Client()
{
    cash = 0;
    menu();
}

void Client::menu()
{
    int op=0;

    do{
        cout<<"0. Sair"<<endl;
        cout<<"1. Checar saldo"<<endl;
        cout<<"2. Depositar dinheiro"<<endl;
        cout<<"3. Sacar dinheiro"<<endl;
        cin >> op;

        action(op);

    }while(op);
}

void Client::action(int op)
{
    switch(op)
    {
        case 0:
                cout << "Fechando sistema."<<endl;
                break;
        case 1:
                checkBalance();
                break;

        case 2:
                depositCash();
                break;

        case 3:
                withdraw();
                break;

        default:
                cout << "Opção inválida"<<endl;
    }

}

void Client::checkBalance()
{
    cout<<"\nSeu saldo atual é: R$" << cash <<endl;
}

void Client::depositCash()
{
    double val;

    cout<< "Valor que deseja depositar: ";
    cin >> val;

    if(val>0){
        cash += val;
        checkBalance();
    }
    else
        cout<<"Valor inválido! Tente novamente"<<endl;

}

void Client::withdraw()
{
    double val;

    cout<< "Valor que deseja sacar: ";
    cin >> val;

    if(val<=cash){
        cash -= val;
        checkBalance();
    }
    else
        cout<<"Saldo insuficiente"<<endl;
}

main.cpp

Nossa main vai simplesmente instanciar um objeto. Automaticamente ele aciona a função construtor, e tudo começa a acontecer:

#include "Client.h"

int main()
{
    Client c;
    return 0;
}

Veja como nossa main() é simples, enxuta e direta ao ponto.

Desafio Hacker

Tem uma maneira de burlar esse sistema. De adicionar dinheiro na sua conta de uma maneira 'hacker'. Você consegue descobrir como é? Digite nos comentários.

Array de Objetos em C++

 Neste tutorial de nosso livro de C++, vamos aprender a criar um array de objetos, bem como manipulá-los.

Criando um array com Objetos em C++

No tutorial passado, criamos uma classe que calculava médias de duas ou três notas, de estudantes. Vamos fazer algo parecido neste tutorial.

Vamos criar a classe Student, e inicialmente ela recebe duas notas. A função construtora seta corretamente as variáveis, e tem uma função chamada getAverage() que retorna a média das duas notas:

#include <iostream>
using namespace std;
class Student
{
    private:
        double grade1, grade2;

    public:
        Student();
        Student(double, double);
        double getAverage();
};

Student::Student()
{
    grade1 = 0;
    grade2 = 0;
}
double Student::getAverage()
{
    return (grade1+grade2)/2;
}

int main()
{
    Student NeilPeart(10, 8);
    cout<<NeilPeart.getAverage()<<endl;

    return 0;
}

Note que criamos apenas um objeto, o aluno Neil Peart. Mas que escola tem apenas um aluno? Tem milhares, mas vamos com calma. Vamos trabalhar agora com 5 alunos. Poderíamos fazer:

• Student alu1, alu2, alu3, alu4, alu5;

Mas, e se fosse um projeto real, com mil alunos? Ia fazer até o alu1000?
Claro que não, né, mané!

Você estudou pelo C++ Progressivo, é uma pessoa esperta e vai logo se lembrar dos nossos amados e queridos arrays, para se trabalhar com muitas variáveis ao mesmo tempo.

Para declarar 5 inteiros, fazemos:

int num[5];

Para declarar 5 chars, fazemos:
char letter[5];

Então adivinha só o que fazemos pra criar 5 objetos da classe Student? Isso mesmo:

• Student alu[5];

Rode o código o código abaixo:

#include <iostream>
using namespace std;

class Student
{
    private:
        double grade1, grade2;

    public:
        Student();
        Student(double, double);
        double getAverage();
};

Student::Student()
{
    grade1 = 0;
    grade2 = 0;
}

Student::Student(double g1, double g2)
{
    grade1 = g1;
    grade2 = g2;
}

double Student::getAverage()
{
    return (grade1+grade2)/2;
}


int main()
{
    Student alu[5];
    cout<<alu[0].getAverage()<<endl;

    return 0;
}

O resultado vai ser 0, pois não inicializamos os objetos do array.

Como inicializar Objetos de um Array

Poderíamos inicializar os objetos um por um, depois de declarar:

    Student alu[5];
    alu[0] = Student(10,9);
    alu[1] = Student(10,8);
    alu[2] = Student(10,7);
    alu[3] = Student(10,6);
    alu[4] = Student(10,5);

Ou poderíamos inicializar logo tudo na hora de instanciar os objetos:

    Student alu[5] = { Student(10,9),
                       Student(10,8),
                       Student(10,7),
                       Student(10,6),
                       Student(10,5) };

Ou até diretamente:

    Student alu[5] = { {10,9},
                       {10,8},
                       {10,7},
                       {10,6},
                       {10,5} };

Se você tiver outras funções construtoras (que recebam uma nota ou 3, por exemplo), também pode colocar diretamente no código, o C++ vai saber chamar a construtor correta. E se você não fornecer nenhuma informação de algum elemento do array, o C++ vai invocar o construtor padrão (é sempre bom ter um, na classe).

Como acessar membros do Array de Objetos

Ok, já declaramos e inicializamos vários objetos de uma vez só, agora precisa aprender a acessar seus membros.

Quando tínhamos um objeto de nome 'name', acessávamos seus membros usando ponto:

• name.var
• name.func()

Aqui é a mesma coisa, mas a variável é um elemento de array:

• arr[0].grade
• arr[1].getAverage();

Ou seja, mesma coisa, só usar o array bonitinho e o pontinho, seguido do membro da classe/objeto.

O programa a seguir cria 5 objetos, já inicializa com a nota dos alunos e exibe suas médias com a função getAverage():

#include <iostream>
using namespace std;

class Student
{
    private:
        double grade1, grade2;

    public:
        Student();
        Student(double, double);
        double getAverage();
};

Student::Student()
{
    grade1 = 0;
    grade2 = 0;
}

Student::Student(double g1, double g2)
{
    grade1 = g1;
    grade2 = g2;
}

double Student::getAverage()
{
    return (grade1+grade2)/2;
}


int main()
{
    Student alu[5] = { {10,9},
                       {10,8},
                       {10,6},
                       {10,5} };


    cout<<alu[0].getAverage()<<endl;
    cout<<alu[1].getAverage()<<endl;
    cout<<alu[2].getAverage()<<endl;
    cout<<alu[3].getAverage()<<endl;
    cout<<alu[4].getAverage()<<endl;

    return 0;
}

Note que inicializamos apenas os quatro primeiros alunos, então o quinto foi inicializado pelo construtor padrão. Qual foi a média do quinto aluno (alu[4])?

Agora faça outro teste: crie uma classe, que apenas tem o construtor padrão, exibindo uma mensagem na tela. Crie um array de tamanho 10, desses objetos. O que acontece?

Sobrecarga (overload) de Função Construtora

Neste tutorial de nossa apostila C++ Progressivo, vamos aprender sobre overloading, ou sobrecarga, da função constructor.

Várias funções construtoras

Você foi contratado por uma universidade para criar um sistema para ajudar os professores, principalmente para trabalhar com as notas dos alunos.

Como você fez o curso C++ Progressivo, vai criar um sistema fantástico, com diversas classes e objetos comendo solto.
Mas vamos com calma.

Vamos criar uma classe de matemática, chamada Math. Pra simplificar, ela vai fazer apenas uma operação: fazer a média de duas notas, de um aluno, só isso.

A função construtor vai dizer logo de cara a média do aluno.
Veja como fica nosso código:

#include <iostream>
using namespace std;

class Math
{
    public:
        Math(double, double);
};


Math::Math(double g1, double g2)
{
    cout<<"Media: "<<(g1+g2)/2<<endl;
}


int main()
{
    Math ze(10, 8);

    return 0;
}

Resultado deu 9 certinho, tudo bonito e legal, e o aluno Zé ficou com uma ótima média.

E falando de experiência de mercado, é MUUUUUUITO comum os clientes ficarem pedindo alterações, novas funcionalidades etc. Se acostume, é sempre pedidos e reclamações.

Nesse caso, a universidade agora quer que você calcule a média de 3 notas.

Hora, é muito simples, só adicionar mais um parâmetro na lista da função construtor, criar o objeto com as 3 notas e mandar bala, já era, nosso código fica assim:

#include <iostream>
using namespace std;

class Math
{
    public:
        Math(double, double, double);
};


Math::Math(double g1, double g2, double g3)
{
    cout<<"Media: "<<(g1+g2+g3)/3<<endl;
}


int main()
{
    Math ana(10, 9, 10);

    return 0;
}

Tudo certinho e a Ana com média quase perfeita.

Mas aí chega sua universidade e diz: olha, tem aluno que vai fazer duas cadeiras e alunos que vai fazer três cadeiras, ou seja, seu sistema tem que calcular a média em ambos casos.

E agora? Como o construtor vai adivinhar? Uma hora calcula a média dividindo por 2 e no outro exemplo ele dividiu por 3 pois tinha uma variável a mais.

Criar uma classe para cada caso? Claro que não, pois isso é complicação.
Programação foi feito pra tornar o mundo mais fácil! É aí que entra a sobrecarga (overloading) de construidor.

A sobrecarga de Construtores

O C++ tem uma carta na manga: ele te permite criar quantos construtores quiser. Isso mesmo, funções com mesmo nome.
Mas uma coisa tem que ser diferente: a lista de parâmetros.

Exemplo de lista de parâmetros diferentes:

• Math(double, double)
• Math(double, int)
• Math(int, double)
• Math(double, double, double, float, char, int)
• ...

Então, no nosso exemplo das médias, basta criar duas funçoes constructors, uma que recebe duas notas e a outra que recebe três notas:

#include <iostream>
using namespace std;

class Math
{
    public:
        Math(double, double);
        Math(double, double, double);
};

Math::Math(double g1, double g2)
{
    cout<<"Media: "<<(g1+g2)/2<<endl;
}

Math::Math(double g1, double g2, double g3)
{
    cout<<"Media: "<<(g1+g2+g3)/3<<endl;
}


int main()
{
    Math ze(10, 8);
    Math ana(10, 9, 10);

    return 0;
}

Veja como o C++ é inteligente. Quando você criou o objeto Zé, só passou dois argumentos, e o objeto invocou a função construidor que só trabalha com dois números.

Quando criou o objeto ana, chamou a outra função construidor, a que trabalha com três valores.
Ou seja, o C++ chama o construtor correto!
Isso é a sobrecarga de construtor.

Agora se você tiver dois construtores com a lista de parâmetros iguais, aí não tem como o C++ adivinhar que função você está querendo invocar, ok?

Vamos aprender um pouco mais sobre sobrecarga quando estudarmos uma classe super especial, a string, que faz loucuras e maravilhas com overloading.

Função Construtor em C++- Orientação a Objetos

 Neste tutorial, vamos aprender sobre um tipo especial de função, a função Construtora, que desempenha um papel muito importante na orientação a objetos.

A função Construtora do C++

Existe uma função muitíssimo importante e utilizada em orientação a objetos, é a função construtora.
E ela possui algumas características únicas e especiais.

A primeira delas é que seu nome é o mesmo nome da classe. Ou seja, se sua classe se chama "MyClass", a função construtora tem que se chamar "MyClass()", obrigatoriamente, ok?

Outra característica dela é que, assim que instanciamos um objeto, a função construtora é sempre automaticamente invocada!

Por fim, uma última característica, ela não retorna nenhum valor! Não escreva void, int, doublet etc, nada em seu cabeçalho e implementação.

Vamos ver um teste de uma função construtora funcionando? Vamos criar a classe "MyClass" que tem apenas um membro, a função "MyClass()", que simplesmente vai exibir uma mensagem, ela fica assim:

#include <iostream>
using namespace std;

class MyClass
{
    public:
        MyClass();
};

MyClass::MyClass()
{
    cout << "Curso C++ Progressivo"<<endl;
}

int main()
{
    MyClass c;

    return 0;
}

Prontinho! Apenas criamos o objeto 'c' e veja o que apareceu na tela:

Função Construtora: Para que serve?

Ok, já vimos como fazer, como funciona e o resultado...mas pra que serve isso? Só pra mostrar umas mensagens bobinhas na tela?

Claro que não, jovem!

Como o próprio nome diz, ele serve para 'construir' coisas, no caso, ele constrói coisas automaticamente. Quando criamos um objeto, é interessante que ele já faça algumas operações internas de imediato, sem precisarmos sempre fazer tudo manualmente.

A este tipo de construtor, chamamos ele de default, pois ele não recebe nenhum argumento. Porém, a maneira mais comum e útil de usar uma função construtora é com uma lista de parâmetros, que são informações que vem de fora pra dentro do objeto, e vão desempenhar algum papel importante lá dentro.

Função Construtora: Como usar?

Por exemplo, vamos relembrar nossa classe  Rect, que criava retângulos. Lembra que sempre tínhamos que usar as funções setters para definir os valores de comprimento e largura. Que tal se o construtor fizesse isso automaticamente?

Veja como fica:

#include <iostream>
using namespace std;

class Rect
{
    private:
        double length, width;

    public:
        Rect(double, double);
        double getArea();
        double getPerimeter();
};

Rect::Rect(double l, double w)
{
    length = l;
    width = w;
}
double Rect::getArea()
{
    return length * width;
}
double Rect::getPerimeter()
{
    return 2*(length+width);
}

int main()
{
    double len, wid;

    cout<<"Comprimento: ";
    cin >> len;

    cout<<"Largura: ";
    cin >> wid;

    Rect r(len, wid);

    cout<<"Area: " << r.getArea() << endl;
    cout<<"Perimetro: " << r.getPerimeter() << endl;

    return 0;
}

Note que no cabeçalho do construtor, já especificamos que ele vai receber duas variáveis do tipo double.

Na implementação, chamamos essas variáveis de 'l' e 'w', que serão fornecidas mais adiante pelo usuário.. E o que nosso construtor faz? Vai setar os valores corretos de 'length' e 'width'.

Na main, pedimos os valores de comprimento e largura, e depois simplesmente instanciamos um objeto do tipo Rect, de nome 'r'. Note agora que nele enviamos dois argumentos, que são os dois argumentos que a função construtora vai usar!

Pronto, internamente, dentro do objeto, o construtor já fez tudo e as funções getArea() e getPerimeter() já podem ser usadas.

Um pouco mais sobre Função Construtora

Uma outra curiosidade sobre construtores é que eles SEMPRE existem! Mesmo que você não defina nenhum, o C++ vai lá e cria um, vazio, que não faz nada.

Quando você faz:

• MyClass c;

Ele automaticamente vai invocar o construtor, mas você não vê nada ocorrendo, pois não definiu nenhum construtor.

Outro truque que você pode precisar e usar, é através de ponteiros, declarando um ponteiro de um objeto:

• MyClass *ptrClass;

Ao fazer isso, o método construtor não será executado, pois não foi criado um objeto, apenas um ponteiro para um objeto.

Agora se fizer isso em seguida:

• ptrClass = new MyClass;

Aí sim, o objeto foi instanciado e alocado na memória, e o construtor será sumariamente executado.

Como criar um projeto com Classes e Objetos em C++: Cabeçalhos e Implementações

 Neste tutorial de nossa apostila de C++, vamos aprender a organizar nossas classes e implementações de funções, criando um projeto bem profissional.

Como criar um projeto em C++

Abra seu Code::Blocks (ou outra IDE que esteja usando).
Clique em File, depois New e escolha Project.

Escolha Console application e marque a opção C++.
Dê um nome para seu projeto, escolha a pasta que quer salvar e clique em Finish,

Vai ficar assim:

Note que já veio o arquivo 'main.cpp', vamos já usar ele.
Agora, clique naqule arquivo branco lá em cima, de 'New file', e clique em Class. Dê o nome 'Calc' para essa classe, pois vamos criar uma calculadora.

Agora veja que legal:

Ele criou dois arquivos: Calc.h e o Calc.cpp

Implementando uma Classe em um Projeto C++: .h

Ok, vamos lá, primeiro vamos trabalhar no arquivo Calc.h, ele é chamado de cabeçalho. 

Vamos ao esboço de nossa classe.

Ela vai ter dois números: num1 e num2, obviamente private.

Vai ter funções de soma (sum), subtração (sub), multiplicação (prod) e divisão (div), todas public e const (elas não vão poder alterar as variáveis).

Somente as funções setNum1 e setNum2 vão poder alterar as variáveis.

E prontinho, nosso cabeçalho da classe Calc.h fica assim:

#ifndef CALC_H
#define CALC_H


class Calc
{
    private:
        double num1, num2;

    public
        double sum() const;
        double sub() const;
        double prod() const;
        double div() const;
        void setNum1(double);
        void setNum2(double);
};

#endif // CALC_H

Veja que tem uns #ifndef, #define, #endif...não mexa neles, são super importantes, deixem eles aí que depois explicamos seus significados.

Implementando Funções de uma Classe de um Projeto: .cpp

É nesse arquivo que vamos implementar as funções de nossa classe Calc.h

Note que bem no começo, tem um "#include Calc.h", assim esse arquivo .cpp fica diretamente relacionado ao arquivo .h , entende a mágica da coisa?

Neste arquivo, vamos implementar todas as funções getters e setters que foram previamente apresentadas no cabeçalho da classe. O arquivo .cpp fica assim:

Note que não tem nenhum 'cout', se tivesse, teríamos que incluir 'include <iostream>:

#include "Calc.h"

double Calc::getSum() const
{
    return num1+num2;
}

double Calc::getSub() const
{
    return num1-num2;
}
double Calc::getProd() const
{
    return num1*num2;
}
double Calc::getDiv() const
{
    return num1/num2;
}
void Calc::setNum1(double n1)
{
    num1=n1;
}
void Calc::setNum2(double n2)
{
    num2=n2;
}

Rodando nosso projeto C++: main.cpp

Agora, na main.cpp, a única coisa que você tem que fazer é dar um #include "Calc.h" lá em cima no arquivo, e prontinho, veja como ficou a main:

#include <iostream>
#include "Calc.h"

using namespace std;

int main()
{
    Calc c;
    double num;

    cout << "Primeiro numero: ";
    cin >> num;
    c.setNum1(num);

    cout << "Segundo numero: ";
    cin >> num;
    c.setNum2(num);

    cout << "\nResultados: "<<endl;
    cout << "Soma: " << c.getSum()<<endl;
    cout << "Subtração: " << c.getSub()<<endl;
    cout << "Multiplicação: " << c.getProd()<<endl;
    cout << "Divisão: " << c.getDiv()<<endl;

}

Agora imagine por um instante se tivéssemos declarado essa classe e as implementações das funções tudo na main.cpp, a bagunça que seria e o código gigantesco.

Dessa maneira que fizemos, separando por cabeçalhos (.h) e implementações de funções (.cpp), ficou tudo mais bonitinho, organizado e profissional, é assim que fazem e usam em softwares profissionais.

Habitue-se  a fazer seus projetos com essa organização, ok?

Alocação dinâmica de objetos com ponteiros: O operador new e delete

 Neste tutorial de nosso Curso de Orientação a Objetos em C++, vamos aprender a usar ponteiros com objetos, e ver uma nova maneira de alocar memória.

Ponteiros de Objetos

Inicialmente, vamos criar um classe, chamada Student, que vai ter duas variáveis (math e english), que vai armazenar as notas do aluno. Também vai ter a get and set, e uma chamada getAverage() para calcular a média de cada aluno.

Nossa classe, toda completinha e bonitinha fica assim:

class Student
{
    private:
        double math, english;

    public:
        double getAverage() const;
        void setMath(double);
        void setEnglish(double);
        double getMath() const;
        double getEnglish() const;
};

double Student::getAverage() const
{
    return (getMath() + getEnglish())/2;
}

void Student::setMath(double m)
{
    math = m;
}
void Student::setEnglish(double e)
{
    english = e;
}
double Student::getMath() const
{
    return math;
}
double Student::getEnglish() const
{
    return english;
}

Vamos agora declarar um ponteiro de nome 'ptr' do tipo Student:

• Student *ptrStudent

Agora vamos declarar de fato um objeto da classe Student:

• Student s1;

Podemos associar o ponteiro com o objeto da seguinte maneira:

• ptrStudent = &s1
  (não esqueça o &, lembre-se que ponteiros armazenam endereços de memória, e ao colocarmos o & antes de uma variável, ele fornece o endereço daquela variável)

Trabalhando com ponteiros com Classes e Objetos: ->

Como já estudando ponteiros, vimos que eles podem fazer mil maravilhas.
Pode exemplo, no exemplo anterior, para o ponteiro acessar os elementos de um objeto, devemos usar o operador ->

Vamos definir duas notas para um aluno:

ptrStudent->setMath(8);

ptrStudent->setEnglish(10);

E para sabermos a média, usando ponteiro, basta fazer:

ptrStudent->getAverage()

Nosso código completo fica:

#include <iostream>
using namespace std;

class Student
{
    private:
        double math, english;

    public:
        double getAverage() const;
        void setMath(double);
        void setEnglish(double);
        double getMath() const;
        double getEnglish() const;
};

double Student::getAverage() const
{
    return (getMath() + getEnglish())/2;
}

void Student::setMath(double m)
{
    math = m;
}
void Student::setEnglish(double e)
{
    english = e;
}
double Student::getMath() const
{
    return math;
}
double Student::getEnglish() const
{
    return english;
}

int main()
{
    Student *ptrStudent;
    Student s1;

    ptrStudent = &s1;
    
    ptrStudent->setMath(8);
    ptrStudent->setEnglish(10);

    cout << ptrStudent->getAverage()<<endl;

    return 0;
}

Note que usamos apenas um aluno, poderíamos ter criado mil alunos e ir fazendo o ponteiro apontar para cada um desses alunos, e o código seria sempre o mesmo, por exemplo:

Student s1, s2, s3, s4;

Faz: ptrStudent = &s1

Depois: ptrStudent = &s2

Depois: ptrStudent = &s3

Depois ptrStudent = &s4

E prontinho, depois é só usr

ptrStudent->setMath();

ptrStudent->setEnglish();

ptrStudent->getAverage()

Isso evita muito escrever código à toa.

Alocando espaço para objetos: Operador new

Existe uma nova maneira de instanciar objetos, é a partir do operador new.

Primeiro você declara seu ponteiro:

• MyClasse *ptr;

Nesse ponto, temos um ponteiro que serve para apontar para um objeto? Que objeto é esse? Vamos criar ele agora, da seguinte maneira:

• ptr = new MyClasse

Deletando objetos - delete

Quando criamos um objeto, via instanciamento normal, ele vai sempre existir e ocupar um espaço na memória. Uma das vantagens de fazer a alocação dinâmica de memória, através do new, é que podemos destruir esse ponteiro, destruindo esse objeto e liberando espaço na memória, para isto, basta usar o operador delete:

• delete ptr;

E prontinho, temos um espaço livro na máquina. Isso pode parecer bobeira agora, mas quando você criar sistemas super complexos que exigem o máximo de eficiência e o menor uso possível de memória (como para programar um relógio de pulso ou microondas, que tem pouca memória), é uma técnica importantíssima.

Veja o código abaixo, apenas com um ponteiro, preenchemos a nota de dois alunos e calculamos sua média, e tudo isso apenas como um objeto/ponteiro da classe Student. Veja como ficou o código:

#include <iostream>
using namespace std;

class Student
{
    private:
        double math, english;

    public:
        double getAverage() const;
        void setMath(double);
        void setEnglish(double);
        double getMath() const;
        double getEnglish() const;
};

double Student::getAverage() const
{
    return (getMath() + getEnglish())/2;
}

void Student::setMath(double m)
{
    math = m;
}
void Student::setEnglish(double e)
{
    english = e;
}
double Student::getMath() const
{
    return math;
}
double Student::getEnglish() const
{
    return english;
}

int main()
{
    Student *ptrStudent;
    ptrStudent = new Student;

    ptrStudent->setMath(8);
    ptrStudent->setEnglish(10);
    cout << "Media do Estudante 1: " <<ptrStudent->getAverage()<<endl;

    ptrStudent->setMath(6);
    ptrStudent->setEnglish(7);
    cout << "Media do Estudante 2: " <<ptrStudent->getAverage()<<endl;

    delete ptrStudent;

    return 0;
}