EJEMPLO:
class Nombre_de_la_Clase
{
Definición_de_Datos;
Prototipos_y_métodos;
};
EJEMPLO:
Nombre de la Clase Nombre del Objeto;
Punto p1,p2; // Creación de dos objetos
// de la clase Punto
EJEMPLO:
Ejemplo de la definición de una clase con métodos definidos dentro de la clase
{
char Caracter, Atributo; //Miembros privados
public:
void FijaCeldilla(char C, char A)
{
Caracter=C; Atributo=A;
}
void ObtenCeldilla(char &C, char &A)
{
C=Caracter; A=Atributo;
}
//&C es una referencia a la variable C
};
Ejemplo de la definición de una clase con métodos no Inline.
class Celdilla
{
char Caracter, Atributo;
public:
void FijaCeldilla(char C, char A);
void ObtenCeldilla(char &C, char &A);
};
void Celdilla::FijaCeldilla(char C, char A)
{
Caracter=C;Atributo=A;
}
void Celdilla::ObtenCeldilla(char &C, char &A)
{
C=Caracter;A=Atributo;
}
EJEMPLO:
Ejemplo de sobrecarga de métodos de una clase.class Celdilla
{ char Caracter, Atributo;
public:
void FijaCeldilla(char C, char A)
{
Caracter=C;
Atributo=A;
}
void FijaCeldilla(unsigned CA)
{
Caracter=CA & 0xff;
Atributo=CA >> 8;
}
void ObtenCeldilla(char &C, char &A)
{
C=Caracter;
A=Atributo;
}
unsigned ObtenCeldilla()
{
return Atributo<<8 | Caracter;
}
};
void main()
{ Celdilla X, Y;
unsigned Casilla;
char C, A;
X.FijaCeldilla('A',112); // Fija los valores del objeto X
Casilla = X.ObtenCeldilla(); //Obtiene el valor de X en forma
// de un entero
Y.FijaCeldilla(Casilla); //Toma Y en dos caracteres
cout << "Caracter= " << C << ", Atributo= " << (int) A;
}
EJEMPLO:
Ejemplo de una clase con constructor y destructor.
#include <string.h>
class Cadena
{ char *pc;
unsigned longitud;
public:
Cadena( char * Str);
~ Cadena() { delete pc; }
Cadena Operator+(Cadena c);
int Operator==(Cadena c)
{
return ! strcmp(pc, c.pc);
}
unsigned strlen()
{
return longitud;
}
};
Cadena::Cadena(char * Str)
{ longitud= ::strlen( Str);
pc=new char[ longitud+1] ;
strcpy(pc, Str);
}
Cadena Cadena::operator+(Cadena c)
{ char Resultado[ 1024 ] ;
strcpy(Resultado, pc);
strcat(Resultado, c.pc);
Cadena Temp(Resultado);
return Temp;
}
void main()
{ Cadena C1("Pis Pas"), C2("Pas Pis"); }
EJEMPLO: Ejemplo de una clase con constructores de copia y asignación, y con destructor.
include <string.h>
class Cadena
{ char *pc;
unsigned longitud;
public:
Cadena (){ longitud=0; pc=0;}
Cadena (char * Str);
Cadena (Cadena &c);
~ Cadena (){ if (longitud) delete pc;}
Cadena operator+ (Cadena c);
void operator= (Cadena c);
int operator==(Cadena c)
{
return ! strcmp(pc, c.pc);
}
unsigned strlen()
{
return longitud;
}
};
Cadena::Cadena(char * Str)
{
longitud= ::strlen( Str);
pc=new char
[ longitud+1] ;strcpy(pc, Str);
}
Cadena Cadena::operator+(Cadena c)
{
char Resultado
[ 1024 ] ;
strcpy(Resultado, pc);
strcat(Resultado, c.pc);
Cadena Temp(Resultado);
return Temp;
}
Cadena Cadena::operator=(Cadena &c)
{
longitud=c.longitud;
pc=new char
[ longitud+1] ;strcpy(pc,c.pc);
}
void main()
{
Cadena C1("Pis Pas"), C2("Pas Pis");
Cadena C3(C1), C4= C1+C2;
C3=C2;
}
Tenemos una definición del siguiente tipo: Cadena C1;
C1="Hola, mundo",
EJEMPLO:
Cadena *C=new Cadena;
EJEMPLO:
void
ControlErroresdeMemoria(){
cout<<"Error en asignación dinámica \n";
exit(-1);
}
void main()
{
set_new_handler(ControlErroresdeMemoria);
Cadena *Q=new Cadena[32000] ;
}
EJEMPLO:
class Ventanagrafica: public Ventana{
.
.
.
.
};
Distintos tipos de herencia que se pueden realizar en C++.
BASE DERIVADA DERIVADA
public private
private private rivate
Miembro protected Pasa a protected Pasa a private
public public private
EJEMPLO:
Ejemplo de clase derivada de una clase base.#include <iostream>
class Base
{
int Entero; // Miembro privado por defecto
protected:
void FijaEntero( int N)
{
Entero=N;
}
public:
void ObtenEntero(void)
{
return Entero;
}
};
class Derivada : public Base
{
public:
void ImprimeEntero(void)
{
cout<<Entero; // Error: Entero no está // accesible aquí
}
void ActivaBase(int N)
{
FijaEntero(N); // Correcto: acceso a // miembro protegido
}
void MuestraEntero(void)
{
cout << ObtenEntero(); // Correcto: acceso a miembro público
}
};
void main(void)
{
Derivada A;
A.ActivaBase(5); // Se accede a un miembro público
cout << A.ObtenEntero(); // Correcto, al ser un miembro // público
A.FijaEntero(10); //Error, FijaEntero está protegido, } //y por tanto, no accesible desde //fuera
EJEMPLO:
Ejemplo de la complejidad de la accesibilidad.#include <iostream.h>
int Entero; // Variable global
class Base
{
protected:
int Entero; // Miembro protegido
};
class Derivada : public Base
{
int Entero;
public:
void ImprimeValores(void);
};
void Derivada::ImprimeValores(void)
{
cout << Entero; // Imprime el Entero de la clase derivada
cout << Base::Entero; // Imprime el Entero de la clase Base
cout << ::Entero; // Imprime el Entero varible global
}
EJEMPLO:
Ejemplo de problemas que pueden surgir con la conversión de una clase derivada a base.
class Base
{
int Entero1;
};
class Derivada : public Base
{
int Entero2; // Se hereda Entero1
};
void main(void)
{
Base A;
Derivada B;
A = B; // Ningún problema, Entero1 se asigna de B a A
B = A; // Error, en A existe Entero1 para asignar a B, pero // no Entero2
}
Ejemplo de herencia en constructores.
#include <iostream.h>
class Base
{
int Entero1;
public:
Base()
{
Entero1=0;
cout <<("Constructor Base \n");
}
Base(int N)
{
Entero1=N;
}
};
class Derivada : public Base
{
// Se hereda Entero1
int Entero2;
public:
Derivada()
{
Entero2=0;
cout <<("Constructor Derivado\n");
}
Derivada(int N1, int N2) : Base (N1)
{
Entero2=N2;
}
};
void main(void)
{
Base A(5);
Derivada B(3,6);
}
EJEMPLO: Ejemplo de herencia en destructores.
#include <iostream>
class Base
{
protected:
int Entero1;
public:
Base()
{
Entero1=0;
cout <<("Constructor Base\n");
}
Base(int N)
{
Entero1=N;
}
~ Base()
{
cout <<("Destructor Base\n");
}
};
class Derivada : public Base
{
int Entero2; // Se hereda Entero1
public:
Derivada()
{
Entero2=0;
cout <<("Constructor Derivado\n");
}
Derivada(int N1, int N2) : Base(N1)
{
Entero2=N2;
}
~ Derivada()
{
cout << "Destructor Derivado\n";
}
}
void main(void)
{
Base A(5);
Derivada B(3,6);
}
EJEMPLO:
Ejemplo de Función Amiga.class Clase
{
int EnteroPrivado;
public:
void FijaEntero(int N);
friend void FuncionAmiga(Clase &X,int N);
};
void FuncionAmiga(Clase &X,int N)
{
X.EnteroPrivado=N;//Acceso al miembro privado
}
// Si no fuese friend EnteroPrivado no estaría accesible desde
// fuera de la clase
EJEMPLO:
class
ClaseAmiga;class Clase
{
int EnteroPrivado;
friend ClaseAmiga;
};
EJEMPLO:
class Clase
{
static int Dato;
.....
};
int Clase::Dato=ValorInicial; //Inicialización de la
// variable estática
EJEMPLO:
Ejemplo del modificador const.
#include <iostream.h>
class Clase
{ const int Objeto; // Un miembro const privado
public:
Clase(int N=0) : Objeto(N){ }// Inicializa el // objeto
// El método Imprime es capaz de manejar objeto const
void Imprime(void)
const { const cout << Objeto;}
};
void main(void)
{ const Clase X(15); // Un objeto const de valor inicial 15
X.Imprime();
}
this->Imprime()
.
EJEMPLO:
Ejemplo de clase con problemaas de ámbito.{ enum Enumeracion1 {Negro, Blanco};
public:
enum Enumeracion2 {Abierto, Cerrado};
struct {
char Caracter;
int Numero;
} Datos;
};
void main(void)
{ int N;
Clase Objeto;
N=Clase::Abierto; // Dos formas de acceder a lo mismo
N=Objeto.Abierto;
N=Objeto.Datos.Caracter;
}
EJEMPLO:
Ejemplo de una macro.
#define Une(x,y)
// Macro para crear clase de manejo de matrices
#define ClaseMatriz(tipo)
class Une(Matriz, tipo)
{ tipo *Dato;
public:
Une(Matriz, tipo)(int Nelementos)
{
Dato=new tipo[NElementos] ;
}
Une(~ Matriz, tipo)()
{
delete Dato;
}
tipo & operator[](int Elemento)
{
return Dato[Elemento] ;
}
};
ClaseMatriz(int); // Se crea una clase para manejar matrices int
ClaseMatriz(double); // Se crea una clase para manejar matrices // double
#include <iostream.h>
void main(void)
{ Matrizint Objetoint(10);
Matrizdouble Objetodouble(10);
Objetoint[0] =10;
Objetodouble[5] =24.5;
cout << Objetoint[0] << '\n' << Objetodouble[5] ;
}
EJEMPLO:
extern "c" void Represent(void);
extern"c"{
#include "cabecera.h"
}
EJEMPLO: Ejemplo de datos en distintas bases de numeración.
#include <iostream.h>
#include <iomanip.h>
void main(void)
{
unsigned long Dato;
cout << "Dame la dirección hexadecimal : ";
cin >> hex >> Dato;
cout << hex << Dato << "," << dec << Dato << "," << oct << Dato << '\n';
cout << setbase(10);
cin >> setbase(10);
}
Ejemplo del uso de Streams.
#include <iostream.h>
#include <iomanip.h>
void main(void)
{
char Cadena[20] ;
int N;
cout << "Introduzca una cadena :";
cin.getline(Cadena,20); // Se toma una cadena de 20 // caracteres como máximo.
cout << endl << endl; // Dos líneas en blanco
cout.write(Cadena,20); // Se da salida a los 20 caracteres
cout.flush(); // Vuelca el stream al correspondiente // dispositivo.
cout << endl << "Introduzca un número :";
cin >> N;
cout << endl << "Su representación es :";
cout.write(char *) &N, sizeof(N); // Escribe su // representación en memoria
cout.flush();
}
&
Bibliografía[ 1] Programación Orientada a Objetos con Borland C++
Francisco Charte Ojeda
Anaya Multimedia, 1993
[2
Bjarne Strouptrup
Addison-Wesley, 1993