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
}

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
}

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
}

#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();
}

//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();
}

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; };
};

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; };
};

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;};
};

#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
}

#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();
}

//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
};

//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;}

//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
}

//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
};

//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;
}

#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;
}