CONSTRUCTORES

Un constructor es un método que pertenece a una clase y el cual debe tener el mismo nombre de la clase a la que pertenece.

 A diferencia de los otros métodos de la clase, un constructor deberá ser del tipo void, es decir, el mismo no regresará valor alguno.

Como característica especial a la hora de implementar un constructor, justo después de la declaración de los parámetros, se encuentra lo que se llama "lista de inicializadores". Su objetivo es llamar a los constructores de los atributos que conforman el objeto a construir.

El objetivo principal del constructor es establecer las condiciones necesarias dentro de la memoria y crear una copia del objeto mismo dentro de la memoria.

Los constructores suelen usarse para la inicialización de los atributos de los objetos instanciados. Por ejemplo, con las instrucciones:

    Suma s

    s.setA(80);

    s.setB(100);

Existen varios tipos de constructores en C++:

• Constructor predeterminado.Es el constructor que no recibe ningún parámetro en la función. Si no se definiera ningún constructor, el sistema proporcionaría uno predeterminado. Es necesario para la construcción de estructuras y contenedores de la STL.

• Constructor de copia. Es un constructor que recibe un objeto de la misma clase, y realiza una copia de los atributos del mismo. Al igual que el predeterminado, si no se define, el sistema proporciona uno.

•  Constructor de conversión.Este constructor, recibe como único parámetro, un objeto o variable de otro tipo distinto al suyo propio. Es decir, convierte un objeto de un tipo determinado a otro objeto del tipo que estamos generando.

DESTRUCTORES

Un destructor es un método que pertenece a una clase y el cual debe tener el mismo nombre de la clase a la que pertenece.

A diferencia de los otros métodos de la clase, un destructor deberá ser del tipo void, es decir, el mismo no regresará valor alguno.

Para diferenciar a un método destructor de un método constructor, al nombre del destructor se le debe anteponer el caracter ~

El objetivo principal del destructor es el de retirar de la memoria al objeto, o sea, el destructor hace todo lo contrario que el constructor.

Los destructores suelen usarse para liberar memoria que haya sido solicitada por el objeto a través de las ordenes malloc(), new, etc.

En tales casos se deberá incluir dentro del método destructor la orden free, delete, etc., según sea el caso.

Los destructores son funciones miembro especiales llamadas automáticamente en la ejecución del programa, y por tanto no tienen por qué ser llamadas explícitamente por el programador. Sus principales cometidos son:

·         Liberar los recursos computacionales que el objeto de dicha clase haya adquirido en tiempo de ejecución al expirar éste.

·         Quitar los vínculos que pudiesen tener otros recursos u objetos con éste.

Los destructores son invocados automáticamente al alcanzar el flujo del programa el fin del ámbito en el que está declarado el objeto. El único caso en el que se debe invocar explícitamente al destructor de un objeto, es cuando éste fue creado mediante el operador new, es decir, que éste vive en memoria heap, y no en la pila de ejecución del programa. La invocación del destructor de un objeto que vive en heap se realiza a través del operador delete o delete [] para arrays.

Existen dos tipos de destructores pueden ser públicos o privados, según si se declaran:

• Si es público se llama desde cualquier parte del programa para destruir el objeto.
• Si es privado no se permite la destrucción del objeto por el usuario.

El uso de destructores es clave en el concepto de Adquirir Recursos es Inicializar.

HERENCIA

HERENCIA

SOBRECARGA DE OPERADORES

SOBRECARGA DE OPERADORES

En programación orientada a objetos la sobrecarga se refiere a la posibilidad de tener dos o más funciones con el mismo nombre pero funcionalidad diferente. Es decir, dos o más funciones con el mismo nombre realizan acciones diferentes.

La sobrecarga de operadores es uno de los mecanismos que nos permite ampliar las capacidades de los lenguajes de programación orientados a objetos.

La sobrecarga de operadores es uno de los mecanismos que nos permite ampliar las capacidades de los lenguajes de programación orientados a objetos. En C++, la declaración y definición de una sobrecarga de operador es muy similar a la declaración y definición de una función cualquiera.

La sintaxis general para sobrecargar uno operador cualquiera es:

Tipo  operador + (lista de parámetros);

En donde,

1. Tipo se refiere al tipo regresado por el operador

1.  Operador es una palabra reservada y debe aparecer en toda declaración de sobrecarga de operadores

1.  El símbolo + está en representación de cualquier operador

1. Lista de parámetros indica los argumentos sobre los que operara la función de sobrecarga.

Nota: en el caso de que el operador sobrecargado se hace para una clase específica la sintaxis se extiende de la siguiente manera:

Tipo  nombre clase :: operador + (lista de parámetros);

SOBRECARGA DE MÉTODOS

Algunos métodos en una clase pueden tener el mismo nombre. Estos métodos deben contar con diferentes argumentos. El compilador decide qué método invocar comparando los argumentos. Se generara un error si los métodos tienen definidos los mismos parámetros.

OPERADORES AMIGOS

Un operador amigo, al igual que una función amiga, es aquel que aún cuando no es miembro de una clase tiene todos los privilegios de acceso a los miembros de dicha clase.

EJEMPLO

// Titulo..: programa sobrecarga01.cpp
// Objetivo: demostración de sobrecarga de operadores
// Autor...: Oscar E. Palacios
#include <iostream>
using namespace std;

class Pareja {
public:
    double a, b;

    // constructor parametrizado
    Pareja(const double a,const double b)
    {
        this->a = a;
        this->b = b;
    }
};

// Sobrecarga del operador +
Pareja& operator +(const Pareja &p1,const Pareja &p2)
{
  return *(new Pareja(p1.a + p2.a, p1.b + p2.b) );
}

int main()
{
    Pareja A(50, 75 );
    Pareja B(150, 175 );
    Pareja C = A + B;

    cout << "A = " << A.a << ',' << A.b << "\n";
    cout << "B = " << B.a << ',' << B.b << "\n";
    cout << "C = " << C.a << ',' << C.b << "\n";

    return 0;
}

PROGRAMACION ORIENTADA A OBJETOS

PROGRAMACION ORIENTADA A OBJETOS

La programación orientada a objetos es un paradigma de programación que usa objetos en sus interacciones, para diseñar aplicaciones y programas informáticos.

Está basada en varias técnicas, incluyendo herencia, cohesión, abstracción, polimorfismo, acoplamiento y encapsulamiento.

Utiliza objetos como elementos fundamentales en la construcción de la solución. Un objeto es una abstracción de algún hecho o ente del mundo real, con atributos que representan sus características o propiedades, y métodos que emulan su comportamiento o actividad. Todas las propiedades y métodos comunes a los objetos se encapsulan o agrupan en clases. Una clase es una plantilla, un prototipo para crear objetos; en general, se dice que cada objeto es una instancia o ejemplar de una clase.

Las características siguientes son las más importantes:

Abstracción

Denota las características esenciales de un objeto, donde se capturan sus comportamientos. Cada objeto en el sistema sirve como modelo de un "agente" abstracto que puede realizar trabajo, informar y cambiar su estado, y "comunicarse" con otros objetos en el sistema sin revelar "cómo" se implementan estas características. El proceso de abstracción permite seleccionar las características relevantes dentro de un conjunto e identificar comportamientos comunes para definir nuevos tipos de entidades en el mundo real

Encapsulamiento

Significa reunir todos los elementos que pueden considerarse pertenecientes a una misma entidad, al mismo nivel de abstracción. Esto permite aumentar la cohesión de los componentes del sistema.

Polimorfismo

Comportamientos diferentes, asociados a objetos distintos, pueden compartir el mismo nombre; al llamarlos por ese nombre se utilizará el comportamiento correspondiente al objeto que se esté usando. O, dicho de otro modo, las referencias y las colecciones de objetos pueden contener objetos de diferentes tipos, y la invocación de un comportamiento en una referencia producirá el comportamiento correcto para el tipo real del objeto referenciado.

Herencia

Las clases no se encuentran aisladas, sino que se relacionan entre sí, formando una jerarquía de clasificación. Los objetos heredan las propiedades y el comportamiento de todas las clases a las que pertenecen. La herencia organiza y facilita el polimorfismo y el encapsulamiento, permitiendo a los objetos ser definidos y creados como tipos especializados de objetos preexistentes.

Modularidad

Se denomina "modularidad" a la propiedad que permite subdividir una aplicación en partes más pequeñas (llamadas módulos), cada una de las cuales debe ser tan independiente como sea posible de la aplicación en sí y de las restantes partes.

Principio de ocultación

Cada objeto está aislado del exterior, es un módulo natural, y cada tipo de objeto expone una "interfaz" a otros objetos que específica cómo pueden interactuar con los objetos de la clase. El aislamiento protege a las propiedades de un objeto contra su modificación por quien no tenga derecho a acceder a ellas; solamente los propios métodos internos del objeto pueden acceder a su estado

Recolección de basura

La recolección de basura es la técnica por la cual el entorno de objetos se encarga de destruir automáticamente, y por tanto desvincular la memoria asociada, los objetos que hayan quedado sin ninguna referencia a ellos. Esto significa que el programador no debe preocuparse por la asignación o liberación de memoria, ya que el entorno la asignará al crear un nuevo objeto y la liberará cuando nadie lo esté usando.

 ¿QUE ES CLASE?

En informática, una clase es una plantilla para la creación de objetos de datos según un modelo predefinido. Las clases se utilizan para representar entidades o conceptos, como los sustantivos en el lenguaje.

¿QUE ES HERENCIA?

En programación orientada a objetos, la herencia es, después de la agregación o composición, el mecanismo más utilizado para alcanzar algunos de los objetivos más preciados en el desarrollo de software como lo son la reutilización y la expansibilidad.

¿QUE ES OBJETO?

En el paradigma de programación orientada a objetos un objeto es una unidad dentro de un programa de computadora que consta de un estado y de un comportamiento, que a su vez constan respectivamente de datos almacenados y de tareas realizables durante el tiempo de ejecución.

EJEMPLO

#include <conio.h>

#include <stdio.h>

#include <stdlib.h>

#include <iostream>

#include <string.h>

using namespace std;

class datos{

      public:

             int edad;

             char nombre[10];

      public:

             void ingrdatos();

             void imprdatos();

             };

void datos::ingrdatos(){

    cout<<"ingrese el nombre"<<endl;

    cin>>nombre;

    cout<<"ingrese la edad"<<endl;

    cin>>edad;

} 

void datos::imprdatos (){

     cout<<endl<<"su nombre es "<<nombre<<endl;

     cout<<"y tienes "<<edad<<" años"<<endl;

    

     }

main(){

datos pernal;

pernal.ingrdatos();

pernal.imprdatos();

getch();

}

PROGRAMA CEDULA CON FUNCIONES

PROGRAMA CEDULA CON FUNCIONES

#include <conio.h>

#include <stdio.h>

#include <string.h>

#include <windows.h>

void ingresar();

void transformar(char ced[]);

void numimppa(int numced[9]);

void cifram(int dec10, int numced[9],int pares, int impares,int imp[4]);

void validar(int sum,int numced[9],int pares, int impares,int dec10, int b,int imp[4]);

void imprimir(int numced[9],int pares, int impares,int dec10, int b,int sum,int validar,int imp[4]);

main()

{

ingresar();

getch();}

void ingresar()

{

char ced[9];

printf("Ingrese:\n");

scanf("%s",&ced);

transformar(ced);

}

void transformar(char ced[9])

{

char *ptrced;

int numced[9];

for(int i=0;i<10;i++){

             ptrced=&ced[i];

                      if(*ptrced==48)

                       {

                       numced[i]=0;

                       }

                      if(*ptrced==49)

                       {

                       numced[i]=1;

                       }

                      if(*ptrced==50)

                       {

                       numced[i]=2;

                       }

                      if(*ptrced==51)

                       {

                       numced[i]=3;

                       }

                      if(*ptrced==52)

                       {

                       numced[i]=4;

                       }

                      if(*ptrced==53)

                       {

                       numced[i]=5;

                       }

                      if(*ptrced==54)

                       {

                       numced[i]=6;

                       }

                      if(*ptrced==55)

                       {

                       numced[i]=7;

                       }

                      if(*ptrced==56)

                       {

                       numced[i]=8;

                       }

                      if(*ptrced==57)

                       {

                       numced[i]=9;

                       }

}

numimppa(numced);

}

void numimppa(int numced[9])

{

int *ptrnumced;

int imp[4];

int impares;

int s;

int pares;

int dec10;

s=0;

for(int i=0;i<5;i++)

{

ptrnumced=&numced[s];

imp[i]=*ptrnumced*2;

if(imp[i]>=9)

{

imp[i]=imp[i]-9;

}

s=s+2;

}

impares=imp[0]+imp[1]+imp[2]+imp[3]+imp[4];

pares=numced[1]+numced[3]+numced[5]+numced[7];

dec10=pares+impares;

cifram(dec10,numced,pares,impares,imp);

}

void cifram(int dec10, int numced[9],int pares, int impares,int imp[4])

{

int a;

int *ptra;

int *ptrb;

int b;

int sum;

a=dec10%10;

a=10-a;

b=dec10 /10;

ptra=&a;

ptrb=&b;

if(*ptra>=6)

{

*ptrb=*ptrb*10;

}

if(*ptra<6)

{

*ptrb=*ptrb+1;

*ptrb=*ptrb*10;

}

b=*ptrb;

sum=b-dec10;

validar(sum,numced,pares,impares,dec10,b,imp);

}

void validar(int sum,int numced[9],int pares, int impares,int dec10, int b,int imp[4])

{

int *ptrsum;

int *ptrnumced;

int validar;

ptrnumced=&numced[9];

ptrsum=&sum;

if(*ptrsum==*ptrnumced)

{

validar=1;

}

if(*ptrsum!=*ptrnumced)

{

validar=0;

}

imprimir(numced,pares,impares,dec10,b,sum,validar,imp);

}

void imprimir(int numced[9],int pares, int impares,int dec10, int b,int sum,int validar,int imp[4])

{

int s;

int *ptrnumced;

int *ptrvalidar;

ptrvalidar=&validar;

printf("\n");

s=1;

for(int i=0;i<10;i++)

{

ptrnumced=&numced[i];

printf("%i) %i\n",s,*ptrnumced);

s++;

}

printf("\n");

printf(" Pares               Impares\n");

printf("%i                   %i\n",numced[1],imp[0]);

printf("%i                   %i\n",numced[3],imp[1]);

printf("%i                   %i\n",numced[5],imp[2]);

printf("%i                   %i\n",numced[7],imp[3]);

printf("                    %i\n",imp[4]);

printf("\n");

printf("Suma de pares: %i\nSuma de impares: %i\n",pares,impares);

printf("Suma total es: %i\nMaxima superior: %i\n",dec10,b);

printf("Decimo dijito resta: %i\n",sum);

printf("Decimo dijito ingresado: %i\n",numced[9]);

if(*ptrvalidar==1)

{

printf("Resultado: Cedula valida\n");

}

if(*ptrvalidar!=1)

{

printf("Resultado: Cedula invalida\n");

}

}