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");

}

}

CEDULA

CEDULA

programa que ingrese su cedula y se separe en susu respectivos espacios de memoria luego que los numeros pares se sumen y los imperes se multipliquen por dos y si sobrepasan de 9 restarle 9 luego sumar los dos resultados de los pares e impares y subir al inmediato superior y restarles.

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>

char ced[10];
char *ptrced;
char z1='s';
int imp[10];

int numced[10];
int *ptrnumced;


int pares,impares,num1;
int *ptrpares;
int *ptrimpares;
int *ptrnum1;
int *ptrb;
int *ptro1;
int *ptrd10;

int s;
int o1;
int a,b;

main()
{

while(z1=='s')
{
system("color B6");
clrscr();
system("color B6");
printf("Ingrese:\n");
scanf("%s",&ced);

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;
                       }
                     printf("%i\n",numced[i]);

}
printf("\n");


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

ptrnumced=&numced[i];
printf("%i) %i\n",s,*ptrnumced);

s++;
}
s=0;


for(int i=0;i<5;i++)
{
imp[i]=numced[s]*2;
if(imp[i]>=9)
{
imp[i]=imp[i]-9;
}
s=s+2;
}


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

impares=imp[0]+imp[1]+imp[2]+imp[3]+imp[4];
num1=impares+pares;
a=num1%10;
a=10-a;
b=num1 /10;

if(a>=6)
{
b=b*10;
}
if(a<6)
{
b=b+1;
b=b*10;
}

ptrpares=&pares;
ptrimpares=&impares;
ptrnum1=&num1;
ptrb=&b;
ptro1=&o1;
ptrd10=&numced[9];




o1=b-num1;
printf("\n");
printf("\n");
printf("\n");
printf("Suma de pares =%i\n",*ptrpares);
printf("Suma de impares =%i\n",*ptrimpares);
printf("Suma total =%i\n",*ptrnum1);
printf("Cifra superior =%i\n",*ptrb);
printf("Ultimo dijito de la suma es =%i\n",*ptro1);
printf("Ultimo dijito de la cedula ingresada es =%i\n",*ptrd10);

if(o1==numced[9])
{
printf("Su Cedula es correcta\n");
}

if(o1!=numced[9])
{
printf("Su cedula es incorrecta\n");
}

printf("\n");
printf("\n");
printf("Desea repetir un programa:\n");
scanf("%s",&z1);


}
}

ESTRUCTURAS DINÁMICAS Y ESTATICAS

ESTRUCTURAS DINÁMICAS Y ESTATICAS

DINÁMICAS

Las estructuras dinámicas de datos son estructuras que cuya dimensión puede crecer o disminuir durante la ejecución del programa. Una estructura dinámica de datos es una colección de elementos llamados nodos. 

Las estructuras dinámicas nos permiten crear estructuras de datos que se adapten a las necesidades reales a las que suelen enfrentarse nuestros programas. Pero no sólo eso, como veremos, también nos permitirán crear estructuras de datos muy flexibles, ya sea en cuanto al orden, la estructura interna o las relaciones entre los elementos que las componen. Las estructuras de datos están compuestas de otras pequeñas estructuras a las que llamaremos nodos o elementos, que agrupan los datos con los que trabajará nuestro programa y además uno o más punteros auto referencia les, es decir, punteros a objetos del mismo tipo tipo.

Dentro de los datos de este tipo de datos podemos hablar de: 

• Listas. 
• Pilas. 
• Colas. 
• Árboles. 
• Grafos 

ESTÁTICAS

Son aquellas en las que el tamaño ocupado en memoria se define antes de que el programa se ejecute y no puede modificarse dicho tamaño durante la ejecución del programa.

Estas estructuras están implementadas en casi todos los lenguajes.
Su principal característica es que ocupan solo una casilla de memoria, por lo tanto una variable simple  hace referencia a un único valor a la vez, dentro de este grupo  de datos se encuentra:

• Enteros
• Reales
• Caracteres
• Boléanos
• Enumerados
• Subrangos