====== Programas em C++ da apostila ======
===== 3.1.2.6. Construtores e Agregação =====
<code c++>
reta(float x1,float y1,float x2,float y2): p1(x1,y1),p2(x2,y2)
{
//nada mais a fazer, os construtores de p1 e p2 ja 
//foram chamados
}
</code>

<code c++>
reta(float x1,float y1,float x2,float y2):
p1(x1,y1),p2(x2,y2), identificacao(10)
{
//nada mais a fazer, os construtores de p1 e p2 ja //foram
chamados
}
</code>

<code c++>
reta (float x1,float y1,float x2,float y2):
p1(x1,y1),p2(x2,y2)
{
  identificacao=10;
  //também pode, porque tipos básicos (int) em C++ não 
  //são objetos, portanto não têm construtores
}
</code>

<code c++>
#include <iostream.h>
struct ponto
{
  float x;
  float y;
//coordenadas

 ponto(float a,float b)
 {
    x=a;
    y=b;
 }

  //construtor
  void move(float dx,float dy)
  { x+=dx; y+=dy; }
  
  //funcao membro comum
  void inicializa(float a,float b)
  { x=a; y=b; }

  void mostra(void)
  {cout << "X:" << x << " , Y:" << y << endl;}
};

struct reta
{
  ponto p1;
  ponto p2;

  reta(float x1,float y1,float x2,float y2):p1(x1,y1),p2(x2,y2)
  {
  //nada mais a fazer, os contrutores de p1 e p2 ja 
  //foram chamados
}

  void mostra(void);
};

void reta::mostra(void)
{
  p1.mostra();
  p2.mostra();
}

void main()
{
  reta r1(1.0,1.0,10.0,10.0); //instanciacao da reta r1
  r1.mostra();
}
</code>

===== 3.1.2.7. Destrutores =====

<code c++>
//destrutor de uma classe
#include <iostream.h>

struct contador{
  int num;
  contador(int n) {num=n;}
  //construtor
  
  void incrementa(void) {num+=1;}

  //funcao membro comum, pode ser chamada pelo usuario
  ~contador(void)
  {cout << "Contador destruido, valor:" << num <<endl;}
  //destrutor
};
void main()
{
  contador minutos(0);
  minutos.incrementa();
  cout << minutos.num << endl;
 {
    //inicio de novo bloco de codigo
    contador segundos(10);
    segundos.incrementa();
    cout << segundos.num <<endl;
    //fim de novo bloco de codigo
 }
 minutos.incrementa();
}
</code>

===== 3.1.3 Encapsulamento com Class =====
==== Declaração 1 ====
<code c++>
class ponto {
  float x;
  //dados membro
  float y;

public:
  //qualificador
  void inicializa(float a, float b) {x=a; y=b;};
  //funcao membro
  void move(float dx, float dy) {x+=dx; y+=dy; };
};
</code>

==== Declaração 2 ====

<code c++>
class ponto {
private:
  float x;
  float y;

public:
  //qualificador
  void inicializa(float a, float b) {x=a; y=b;};
  void move(float dx, float dy) {x+=dx;y+=dy; };
};

</code>
==== Declaração 3 ====

<code c++>
struct ponto {
private:
  //se eu nao colocar private eu perco o encapsulamento 
  //em struct.
  float x;
  float y;

public:
  //qualificador
  void inicializa(float a, float b) {x=a;y=b;};
  void move(float dx, float dy) {x+=dx; y+=dy;};
};

</code>
===== 3.1.3.1. Atributos Private, Funções Membro Public =====

<code c++>
#include <iostream.h>
  class ponto
  {
  private:
  //nao precisaria por private, em class e default
    float x;
  //sao ocultos por default
    float y;
  //sao ocultos por default

public:
  //daqui em diante tudo e acessivel.
  void inicializa(float a,float b)
  { x=a; y=b; }

  //as funcoes de uma classe podem acessar os atributos
  //private dela mesma.
  void mostra(void)
  {cout << "X:" << x << " , Y:" << y << endl;}
};
void main()
{
  ponto ap; //instanciacao
  ap.inicializa(0.0,0.0); //metodos public
  ap.mostra(); //metodos public
}

</code>
===== 3.1.3.2. Um Dado Membro é Public =====

<code c++>
#include <iostream.h>
  class ponto
  {
    float x;
    //sao ocultos por default

    public:
    //daqui em diante tudo e acessivel.
       ponto(float a,float b);
    //construtor tambem pode ser inline ou nao
       void mostra(void);
       void move(float dx,float dy);
       float y;
  
    //* Y nao e' mais ocultado
};

ponto::ponto(float a,float b)
{
  x=a;
  y=b;
}
 
void ponto::mostra(void)
{
  cout << "X:" << x << " , Y:" << y << endl;
}

void ponto::move(float dx,float dy)
{
  x+=dx;
  y+=dy;
}

void main()
{
  ponto ap(0.0,0.0);
  ap.mostra();
  ap.move(1.0,1.0);
  ap.mostra();
  ap.y=100.0;
  ap.mostra();
}

</code>
===== 3.1.3.3. Compilando um Programa com Vários Arquivos =====

<code c++>
//Arquivo 1 ponto.h, definicao para a classe ponto.
  class ponto
  {
   public:
   //daqui em diante tudo e acessivel.
      void inicializa(float a,float b);
      void mostra(void);

   private:
     float x;
     //sao ocultos por default
     float y;
     //sao ocultos por default
};

</code>


<code c++>
//Arquivo 2 , ponto.cpp , implementacao para a classe //ponto.
#include <iostream.h>
#include "ponto.h"

void ponto::inicializa(float a,float b)
  { x=a; y=b; }

//as funcoes de uma classe podem acessar os atributos
//private dela mesma.

void ponto::mostra(void)
  {cout << "X:" << x << " , Y:" << y << endl;}

</code>

<code c++>
//Arquivo 3 . Programa principal: princ.cpp
#include "ponto.h"
void main()
{
  ponto ap;
  //instanciacao
  ap.inicializa(0.0,0.0);
  //metodos public
  ap.mostra();
  //metodos public
}

</code>

<code c++>
//header file para o TAD fracao.
//File easyfra.h
  long mdc(long n,long d);
  //maximo divisor comum metodo de Euclides.
  class fracao {
    private:
       long num;
       //numerador
       long den;
       //denominador

    public:
      fracao(long t,long m);
      //construtor comum

     void simplifica(void);
     //divisao pelo mdc

    ~fracao() { /* nao faz nada*/ }
    //Nao e preciso fazer nada.

    //operacoes matematicas basicas
    fracao soma (fracao j);
    fracao multiplicacao(fracao j);

    //operacoes de comparacao
    int igual(fracao t);
    int diferente(fracao t);
    int maiorouigual(fracao t);

    //operacoes de input output
    void mostra(void);
    //exibe fracao no video
    void cria(void);

    //pergunta ao usuario o valor da fracao
    //operacoes de conversao de tipos
    double convertedbl(void);

    //converte para double
    long convertelng(void);
    //converte para long
};

</code>

<code c++>
//implementacao para a classe fracao.
#include <iostream.h>
#include "easyfra.h"

  long mdc(long n,long d)
  //maximo divisor comum
  //metodo de Euclides +- 300 anos AC.
  {
     if (n<0) n=-n;
     if (d<0) d=-d;
     while (d!=0) {
        long r=n % d;
         //%=MOD=Resto da divisao inteira.
        n=d;
        d=r;
  }
  return n;
}

void fracao::simplifica(void)
{
  long commd;
  commd=mdc(num,den);

  //divisor comum
  num=num/commd;
  den=den/commd;
  if (den<0) { den=-den; num=-num;};
  //move sinal para cima
}

fracao::fracao(long t,long m)
{
  num=(t);
  den=(m);
  simplifica(); //chamada para o mesmo objeto.
}

fracao fracao::soma(fracao j)
{
  fracao g((num*j.den)+(j.num*den),den*j.den);
  return g;
}

fracao fracao::multiplicacao(fracao j)
{
  fracao g(num*j.num,den*j.den);
  return g;
}

int fracao::igual(fracao t)
{
  return ((num*t.den)==(den*t.num));
  //funciona bem mesmo para nao simplificada
}

int fracao::diferente(fracao t)
{
  return ((num*t.den)!=(den*t.num));
}

int fracao::maiorouigual(fracao t)
{
  return ((num*t.den)>=(t.num*den));
}

void fracao::mostra(void)
{
  cout << "(" << num << "/" << den << ")";
}

void fracao::cria(void)
{
  cout << "Numerador:";
  cin >> num;
  cout << "Denominador:";
  cin >> den;
  simplifica();
}

double fracao::convertedbl(void)
{
  double dbl;
  dbl=(double(num)/double(den));
  return dbl;
}

//conversao para long
long fracao::convertelng(void)
{
  long lng;
  lng=num/den;
  return lng;
}

</code>

<code c++>
#include <iostream.h>
#include "easyfra.h"
  //nossa definicao da classe
#include <stdio.h>

int main()
{
  fracao a(0,1),b(0,1);
  cout << " Entre com fracao a: ";
  a.cria();
  a.mostra();
  cout << " Entre com fracao b: ";
  b.cria();
  b.mostra();
  fracao c(a.soma(b));
  //c(a+b)
  cout << endl << "c de a+b:";
  c.mostra();
  cout << endl << "a*b";
  c=a.multiplicacao(b);
  c.mostra();
  cout << endl << "a+b";
  c=a.soma(b);
  c.mostra();
  cout << endl << "a>=b";
  cout << a.maiorouigual(b);
  cout << endl << "a==b";
  cout << a.igual(b);
  cout << endl << "a!=b";
  cout << a.diferente(b);
  cout << endl << "long(a) ";
  cout << a.convertelng();
  cout << endl << "double(a) ";
  cout << a.convertedbl();
  return 0;
}

</code>