Sintaxis de declaracin

Clase

class nombre-clase { funciones y variables privadas de la clase public: funciones y variables publicas de la clase } lista de objetos Ejemplo:

class myclass { int a; public: void set_a (int num); int get_a (); };

Funcin Miembro

tipo nombre-clase::nombre-funcion (lista-parametros) { cuerpo de la funcion } Ejemplo:

void myclass::set_a (int num); { a=num; }

int myclass::get_a () { return a; }

main() { myclass ob1, ob2; ob1.set_a (10); ob2.set_a (99); cout << ob1.get_a() << "\n" << ob2.get_a() <<"\n" }

Funciones Constructoras

A un constructor de clase se le llama cada vez que se crea un objeto de esa clase. Una funcin constructora tiene el mismo nombre que la clase de la que es parte y no tiene tipo devuelto. Cualquier inicializacin que sea necesaria en un objeto la puede realizar automticamente la funcin constructora.

Ejemplo:

class myclass { int a; public: void set_a (int num); int get_a (); myclass(); };

myclass::myclass() { a=0; }

Funciones Destructoras

El complemento de un constructor es el destructor. A esta funcin se le llama cuando se destruye un objeto. Cuando se trabaja con objetos es muy comn tener que realizar algunas acciones cuando se destruye el objeto. Por ejemplo, un objeto que asigna memoria cuando se crea querr liberar la memoria cuando se destruya. El nombre de un destructor es el nombre de la clase a la que pertenece precedido por el carcter ~.

Ejemplo:

class myclass {

int a; public: void set_a (int num); int get_a (); myclass(); ~myclass(); };

myclass::~myclass() { cout << "Destruyendo...\n" }

Funciones Constructoras con Parametros

Es posible pasar argumentos a una funcin constructora. Para permitir esto, simplemente aada los parmetros adecuados a la declaracin y definicin de la funcin constructora. Despus, cuando declare un objeto, especifique los parmetros como argumentos.

Ejemplo:

class myclass { int a; public: myclass (int x);

void show(); }

myclass::myclass (int x) { a=x; }

myclass::show() { cout << a << "\n"; }

void main() { myclass ob(4); ob.show(); }

Funciones Insertadas

En C++ es posible definir funciones a las que no se llama realmente, pero se insertan en el cdigo en el momento de cada llamada. La ventaja de las funciones insertadas es que se pueden ejecutar mas rpidamente que las funciones normales. La desventaja es que si son demasiado largas y se las llama demasiado a menudo, el programa aumentara su longitud.

Para declarar una funcin insertada, simplemente hay que preceder la definicin de la funcin con el especificador inline.

Ejemplo:

inline int par (int x) { return !(x%2); }

Si la definicin de una funcin miembro es suficientemente corta, su definicin se puede incluir dentro de la declaracin de clase. Hacer esto provoca que la funcin se convierta automticamente en una funcin insertada, si es posible.

Cuando una funcin se define dentro de una declaracin de clase, la palabra clave inline no es necesaria.

Objetos como en Funciones

Cuando se manda un objeto como parmetro por valor, se hace una copia del objeto original y esa es la que se manda, la cual manda a llamar el destructor cuando la funcin termina. Para mandar un parmetro por referencia puro le antecedo al nombre del parmetro &, (en vez de el * como era en la simulacin de parmetros por referencia). En este caso no se crea la copia y no se manda a llamar el destructor. Cuando una funcin devuelve un objeto, se crea una copia temporal del objeto la cual es la que se devuelve, y automticamente despus se manda a llamar la destructora para destruir la copia.

Si le precedo un & al nombre de la funcin, entonces no se creara la copia, y no se mandara a llamar la funcin destructora. Solo utilizo la & cuando recibo el objeto como parmetro real por referencia, la modifico y a continuacin devuelvo el mismo objeto. De esta forma lo que antes hubiera provocado que se mande a llamar 2 veces el destructor, ahora no se manda a llamar ninguna vez.

Herencia

Sintaxis de declaracin de la clase derivada:

class nombre-clase-derivada : especificador-acceso nombre-clase-base { . . }; El especificador acceso es una de las tres palabras claves siguientes: public, private o protected.

public

Todos los elementos pblicos de la clase base sern elementos pblicos de la clase derivada. Sin embargo, todos los elementos privados de la clase base permanecen privados para ella y no son accesibles directamente por la clase derivada.

Ejemplo:

class base { int i;

public: void set_i (int n) { i=n; } int get_i (); { return i; } };

class derived : public base { int j; public: void set_j (int n); { j=n; } int mul(); { return j*get_i (); } };

main () { derived ob; ob.set_i (10); ob.set_j (4); cout << ob.mul (); }

private

Todos los atributos publicos de la clase base pasan a ser atributos privados de la clase derivada. Sea cual sea el caso, cualquier atributo privado de la base sigue siendo privado para ella y es inaccesible para la clase derivada.

Ejemplo:

class base { int x; public: void setx(int n) { x=n; } void showx() { cout << x << '\n'; } };

class derived : private base { int y; public: void setxy(int n, int m) { setx(n); y=m; } void showxy () { showx(); cout << y << '\n'; } };

protected: pendiente.

Funciones Amigas

Una funcin amiga no es un miembro de una clase, pero todava tiene acceso a sus elementos privados. Una funcin amiga se define como una funcin no miembro normal. Sin embargo, dentro de la declaracin de clase para la que ser una funcin amiga, esta tambin incluido su prototipo, precedido por la palabra clave friend.

Ejemplo 1:

class myclass { int n, d; public: myclass (int i, int j) { n = i; d= j; } friend int isfactor (myclass ob); };

int is factor (myclass ob) { return !(ob.n%ob.d); }

main() { myclass ob1(10,2); if (isfactor(ob1)) cout << "2 es factor de 10\n"; } Ejemplo 2:

class vehicle { public: int speed; };

class truck; //declaracion forward de la clase

class car: private vehicle { int passengers; public: car (int p, int s) { passengers=p; speed=s; } friend int sp_greater (car c, truck t); };

class truck: private vehicle { int weight; public: truck (int w, int s) { weight = w; speed=s; } friend int sp_greater (car c, truck t); };

int sp_greater (car c, truck t) { return c.speed-t.speed; };

main() { car c(6, 55); truck t(10000, 55); int sp=sp_greater (c, t);

if (t<0) cout << "El camion es mas rapido."; else if (!t) cout << "La velocidad del carro y el camion es la misma"; else cout << "El carro es mas rapido"; cout << "\n"; } Ejemplo 3:

class vehicle { public: int speed; };

class truck;

class car: private vehicle { int passengers; public: car (int p, int s) { passengers=p; speed=s; } int sp_greater (truck t); };

class truck: private vehicle { int weight; public: truck (int w, int s) { weight = w; speed=s; } friend int car::sp_greater (truck t);

};

int car::sp_greater (truck t) { return speed-t.speed; };

main() { car c(6, 55); truck t(10000, 55); int sp=c.sp_greater (t); if (t<0) cout << "El camion es mas rapido."; else if (!t) cout << "La velocidad del carro y el camion es la misma"; else cout << "El carro es mas rapido"; cout << "\n"; }

Vectores de Objetos

Ejemplo 1:

class samp { int a; public: void set_a(int n) { a=n; }

int get_a() { return a; } };

main() { samp ob[4]; int i; for (i=0; i<4; i++) ob[i].set_a(i); for (i=0; i<4; i++) cout << ob[i].get_a(); } Ejemplo 2:

class samp { int a; public: void set_a(int n) { a=n; } samp(int n) { set_a(n); } int get_a() { return a; } };

main() { samp ob[4]={1,3,2,5}; int i; for (i=0; i<4; i++) cout << ob[i].get_a(); }

Ejemplo 3:

class samp { int a, b; public: samp (int n, int m) { a=n; b=m; } int get_a() { return a; } int get_b() { return b; } };

main() { samp ob[4]={ samp(2,1), samp(3,5), samp(2,4), samp (3,1) }; int i; for (i=0; i<4; i++) cout << ob[i].get_a() << ob[i].get_b(); }

Uso de Punteros a Objetos

main() { samp ob[4]={ samp(2,1), samp(3,5), samp(2,4), samp (3,1) }; int i; samp *p; p=ob;

for (i=0; i<4; i++) { cout << p->get_a() << p->get_b(); p++; } }

Homonoma de Operadores

#include <iostream.h>

class num { int a; friend ostream &operator<< (ostream &output, const num &a); public: num() { a=0; } num(int n) { a=n; } int get_a() { return a; } num operator+=(num n); // operador binario como funcion miembro num operator++(); // operador unario de preincremento friend num operator+ (num a, num b); // operador binario como funcion amiga friend int operator> (num a, num b); // operador binario como funcion amiga };

num num::operator++()

{ ++a; return *this; }

num num::operator+=(num n) { a+=n.get_a(); num b(get_a()); return b; }

num operator+ (num a, num b) { num c(a.a+b.a); return c; }

int operator> (num a, num b) { return (a.a > b.a); }

ostream &operator<< (ostream &output, const num &a) { output << a.a << '\n';

return output; }

main() { num ob1(10), ob2(15), ob3; ob3=ob1+ob2; if (ob3>ob1) ob2=(ob3+=ob1); ob2=ob3++; cout << ob2; }