Sintaxis

class nombre
{    Atributo 1;    	//llamado también miembro dato
     Atributo 2;
     ....
  public:
     Método 1 (...);    //Se conoce también como función miembro.
     Método 2 (...);    //Sólo son prototipos de funciones.
}                           
//Implementación para los métodos:

tipo nombre :: Método N ( )
{    ...
     ...    //cuerpo de la función
}

Control de Acceso a una Clase

Una de las características fundamentales en la programación orientada a objetos es la de ocultar tanta información como sea posible. Por lo tanto en una clase se pueden tener partes públicas (se puede accesar a ella desde cualquier parte dentro del ámbito del objeto) y partes privadas (sólo se puede tener acceso a ellas por medio de las funciones miembro).

Por defecto, todos los elementos de una clase son privados. Para hacer que los elementos de un objeto sean públicos deberán declararse después de la cláusula public:

La cláusula private: se emplea para denotar en forma explícita los elementos que han sido ocultados en el objeto.

Como regla general, la programación orientada a objetos, obliga a colocar todos los atributos en la parte privada, los métodos pueden ir en la parte pública.

Ejemplo:

//Definición de una clase para un rectángulo
class CLRect
{    float base;
     float altura;
   public:
     void DefineBase (float);
     void DefineAltura (float);
     float DameBase (void);
     float DameAltura (void);
     float Perímetro (void);
     float Area (void);
}

//Implementación de los Métodos

void CLRect :: DefineBase (float b)
{    base = b;    
}

void CLRect :: DefineAltura (float h)
{    altura = h;  
}

float CLRect :: DameBase (void)
{    return base; 
}

float CLRect :: DameAltura (void);
{    return altura;
}

float CLRect :: Perímetro (void);
{    return 2*(base+altura);
}

float CLRect :: Area (void);
{    return base*altura;
}

//Programa para manejar la clase rectángulo

#include <iostream.h>
#include <iomanip.h>

class CLRect
{    ...
     ...
}

void main (void)
{    CLRect Rect;    //define el objeto
     float b,h;
     cout << "Ingrese la base";
     cin >> b;
     cout >> "Ingrese la altura";
     cin >> h;
     Rect.DefineBase (b);    //mensaje
     Rect.DefineAltura (h);
     cout << "Perímetro=" << setprecision(2)
          << Rect.Perímetro ( ) << endl;
     cout << "Area=" <<Rect.Area ( ) << endl;

     //modificamos la base de rectángulo

     Rect.DefineBase (Rect.DameBase ( ) *2);
     cout << "Nueva Area=" << Rect.Area ( ) << endl;
}

Ejemplo:

/************************************************
Programa Orientado a Objetos para evaluar una expresión en postfijo
Versión 1: sin usar constructores
*************************************************/

#include<iostream.h>
#include<iomanip.h>
#include<string.h>
#include<stdlib.h>

const char BLANCO = 32;
const char END_ST = '\0';

class ClasePila
{    int tamano;
     float * cima;
     float * stack;
   public:
     void Inicializate(int);
     int EstaVacia(void);
     int EstaLlena(void);
     void Push (float);
     void Pop (float &);
};

void ClasePila::Inicializate(int t)
{    tamano = t;
     stack = new float[t];
     cima =NULL; 
}

int ClasePila::EstaVacia(void)
{    return cima==NULL ? 1: 0; 
}

int ClasePila::EstaLlena(void)
{    return cima==(stack+tamano) ? 1: 0; 
}

void ClasePila::Push (float valor)
{    if (cima==NULL) cima = stack;
     else  cima++ ;
     *cima = valor;   
}

void ClasePila::Pop (float &valor)
{    valor = *cima;
     if (cima==stack) cima=NULL;
     else cima--;
}

/***********************************************/

class ClaseCadena
{    char exp[100];
     char *st;
   public:
     void Leete(void);
     char *DamePalabra(void);
     int EstasVacia(void);
};

void ClaseCadena::Leete(void)
{    cin.getline(exp,100);
     st=exp; 
}

char* ClaseCadena::DamePalabra(void)
{    char* p=st, *palabra;
     int i;
     for (i=0; *(st+i)==BLANCO; i++, p++);
     st=p;
     for (i=0; *(st+i)!=BLANCO && *(st+i)!=END_ST; i++, p++);
         palabra = new char[int(p-st) +1];
     for (i=0; st != p; *(palabra + i++)= *(st++) );
         *(palabra+i)=END_ST;
     return palabra;
}

int ClaseCadena::EstasVacia(void)
{    return *st == END_ST? 1 :0; 
}

/***********************************************/

int EsOperando(char *);
float opera(float, char *, float);

/***********************************************/

void main (void)
{    ClaseCadena Expresion;
     ClasePila Pila;
     char *dato;
     float Resultado;

     Pila.Inicializate(10);    //mensaje de inicialización de la pila (*)
     cout << "Ingrese expresión : ";
     Expresion.Leete();
     while (!Expresion.EstasVacia())
     {    dato= (Expresion.DamePalabra());
          if (EsOperando(dato) ) Pila.Push(atof(dato));
          else
          {    float Dato1, Dato2;
               Pila.Pop(Dato1);  Pila.Pop(Dato2);
               Pila.Push(opera(Dato2,dato,Dato1));
          }
     }
     Pila.Pop(Resultado);
     cout << "Resultado = " << Resultado << endl;
}

int EsOperando(char *op)
{    switch (*op)
     {    case '+': case '-': case '*': case '/': return 0;
          default : return 1;
     }
}

float opera(float d1, char *op, float d2)
{    switch (*op)
     {    case '+': return d1+d2;
          case '-': return d1-d2;
          case '*': return d1*d2;
          case '/': return d1/d2;
          default : return 0;
     }
}