Trabajos y Deberes de programacion

Cedula en Excel

Programa de cédula

Este programa pide el numero de cédula y responde si la cédula que se ha ingresado es correcta o incorrecta
#include <conio.h>
#include <stdio.h>
char Cadena[10];
int Num[10];
int par;
int impar[10];
int ptrNum[10];
int resp;
int im[10];

main(){
int ptrNum=&Num[10];
printf("ingrese la cedula\t");
//Se realiza la transformacion de caracteres a numeros enteros
for(int i=0;i<=9;i++)
{
scanf("%c",&Cadena);
sscanf(Cadena, "%d", &ptrNum[i]);
}
for(int i=0;i<=9;i++)
{
printf("%d\n",ptrNum[i]);
}
for (int i=0;i<9;i++)
{
Num[i]=ptrNum[i];
}
//se realiza la suma de pocisiones pares
printf("La suma de los pares es:");
par=Num[1]+Num[3]+Num[5]+Num[7];
printf("%i",par);
//Se multiplica pocisiones impares x 2

printf("\nPrimera parte impares:");
for(int i=0;i<9;i++)
{

impar[i]=Num[i]2;
im[i]=impar[i];
printf("\n%i",im[i]);
i++;
}
//Funcion si para determinar si es mayor a 9 restar 9
printf("\n2da parte impares");
if(im[0]>9){

printf("\n%i",impar[0]-9);
im[0]=impar[0]-9;}
else{
printf("\n%i",im[0]);}

if(im[2]>9){
printf("\n%i",impar[2]-9);
im[2]=impar[2]-9;}
else{
printf("\n%i",im[2]);}

if(im[4]>9){
printf("\n%i",impar[4]-9);
im[4]=impar[4]-9;}
else{
printf("\n%i",im[4]);}

if(im[6]>9){
printf("\n%i",impar[6]-9);
im[6]=impar[6]-9;}
else{
printf("\n%i",im[6]);}

if(im[8]>9){
printf("\n%i",impar[8]-9);
im[8]=impar[8]-9;}
else{
printf("\n%i",im[8]);}
//Resultado de la suma de pares e impares
resp=(par)+(im[0]+im[2]+im[4]+im[6]+im[8]);
printf("\nSuma total:\t%i",resp);

//Funcion si para determinar si se resta a la decena superior
if(resp>10&resp<20)
{
resp=20-resp;
printf("\nResultado:%i\t",resp);
}
else
if(resp>20&resp<30)
{
resp=30-resp;
printf("\nResultado: %i\t",resp);
}
else
if(resp>30&resp<40)
{
resp=40-resp;
printf("\nResultado: %i\t",resp);
}
else
if(resp>40&resp<50)
{
resp=50-resp;
printf("\nResultado: %i\t",resp);
}
else
if(resp>50&resp<60)
{
resp=60-resp;
printf("\nResultado: %i\t",resp);
}
//Funcion si para determinar el resultado :D
if(resp==ptrNum[9])
{
printf("\nCedula Correcta :D");
}
else
{
printf("\nCedula Incorrecta :(");
}
getch();
}

Programas recuperación bloque 2

Programa saber si un número es par e impar

/ mpar.c: Permite probar la función par. /

#include<stdio.h>

#include<conio.h>

int par(int); // o int par(int numero);

main()

{

int numero, resultado; printf("Introduzca un número:\n"); scanf("%i",&numero);

resultado=par(numero); if (resultado==1)

printf("Es par.\n");

else

printf("Es impar.\n");

getch();

}

/ Función par: Devuelve un valor indicando si un número entero es par o no. /

int par(int numero)

{

if((numero%2)==0) return(1);

else

return(0);

}

Programa Medida de 2 numeros

/ mmedia2.c: Permite probar la función media2. /

#include<stdio.h>

float media2(float,float);

//o float media2(float n1, float n2);

int main()

{

float n1, n2, resultado;

printf("Introduzca un número real:\n");

scanf("%f",&n1);

printf("Introduzca otro número real:\n");

scanf("%f",&n2);

resultado=media2(n1,n2);

printf("La media es: %f.\n",resultado);

return(0);

}

// Función media2: Devuelve la media de 2 números.

float media2(float n1, float n2)

{

float resultado;

resultado=(n1+n2)/2;

return(resultado);

}

Programa calcula la media de 3 números

/ mmedia3.c: Permite probar la función media3. /

#include<stdio.h>

void media3(float,float,float);

//o void media3(float n1,float n2,float n3);

int main()

{

float n1, n2, n3;

printf("Introduzca un número real:\n");

scanf("%f",&n1);

printf("Introduzca otro número real:\n");

scanf("%f",&n2);

printf("Introduzca otro número real:\n");

scanf("%f",&n3);

media3(n1,n2,n3);

return(0);

}

// Función media3: Informa de la media de 3 numeros.

void media3(float n1, float n2, float n3)

{

float resultado;

resultado=(n1+n2+n3)/3;

printf("La media es:%f \n",resultado);

}

Programa 4 Saludo

/ msaludo.c: Permite probar la función saludo. /

#include<stdio.h>

void saludo(void);

//o void saludo();

int main()

{

saludo();

return(0);

}

// Función saludo: Muestra “Hola”.

void saludo()

{

printf(“Hola”);

}

Programa 5Imprimir una cadena

/ msaludo2.c: Permite probar la función saludo2. /

#include<stdio.h>

void saludo2(char cadena[11]);

int main()

{

char mensaje[11]="Hola";

saludo2(mensaje);

return(1);

}

// Función saludo2: Muestra la

void saludo2(char cadena[11])

{

printf("%s",cadena);

}

Programa 6 saber si un número es negativo

// mnegativo.c: Permite probar la función negativo.

#include<stdio.h>

int negativo(int numero);

int main()

{

int n,resultado;

printf("Introduzca un número:\n");

scanf("%i",&n);

resultado=negativo(n);

if (resultado==1)

printf("Es un numero negativo.\n");

else

printf("No es negativo.\n");

return(0);

}

/ Función negativo: Devuelve 1 si es negativo el número

entero pasado como parámetro, o 0 si no lo es. /

int negativo(int numero)

{

int res;

if (numero<0)

res=1;

else

res=0;

return(res);

}

Programa 7 Imprimir el ultimo digito de un carácter

/ multima.c: Permite probar la función ultima. /

#include<stdio.h>

#include<string.h>

char ultima(char cadena[11]);

int main()

{

char cadena[11], ultimocaracter;

printf("Introduzca una cadena:\n");

gets(cadena);

ultimocaracter=ultima(cadena);

if (ultimocaracter=='\0')

printf("Error: cadena vacia.\n");

else

printf("El ultimo es: %c\n",ultimocaracter);

return(0);

}

/ Función ultima: Devuelve el último carácter de la cadena

recibida. /

char ultima(char cadena[11])

{

int longitud;

char caracter ;

longitud=strlen(cadena);

if (longitud==0)

caracter='\0';

else

caracter=cadena[longitud-1];

return(caracter);

}

Programa 8 número de caracteres de la cadena

/ mstrlen2.c: Permite probar la función strlen2. /

#include<stdio.h>

int strlen2(char cadena[1001]);

int main()

{

char cadena[1001];

int longitud;

printf("Introduzca una cadena:\n");

gets(cadena);

longitud=strlen2(cadena);

printf("La longitud es: %i\n",longitud);

return(0);

}

/ Función strlen2: Devuelve el número de caracteres de la

cadena recibida como parámetro. /

int strlen2(char cadena[1001])

{

int x=0;

while(cadena[x]!='\0')

{

x++;

}

return(x);

Programa 9 triple de un numero

/ m2funciones.c: Permite probar las funciones pedir y triple

juntas. /

#include<stdio.h>

int pedir();

int triple(int);

int main()

{

int numero, total;

numero=pedir();

total =triple(numero);

printf("El triple de %i es: %i\n",numero, total);

return(0);

}

// Función pedir: Pide y devuelve un numero entero.

int pedir()

{

int n;

printf("Introduzca un numero entero:\n");

scanf("%i",&n);

return(n);

}

// Función triple: devuelve el triple del parámetro.

int triple(int num)

{

int n;

n=3num;

return(n);

}

Programa 10 Imprimir los valores de una matriz 4x4(valor 0)

/* mmatriz.c: Permite probar las funciones ceros y mostrar juntas.

*/

#include<stdio.h>

void ceros(int matriz[3][4]);

void mostrar(int matriz[3][4]);

int main()

{

int matriz[3][4];

ceros(matriz);

mostrar(matriz);

return(1);

}

// Función ceros: Pone las celdas a cero.

void ceros(int matriz[3][4])

{

int fila, columna;

for(fila=0;fila<=2;fila++)

for(columna=0;columna<=3;columna++)

matriz[fila][columna]=0;

}

// Función mostrar: Muestra la matriz.

void mostrar(int matriz[3][4])

{

int fila, columna;

for(fila=0;fila<=2;fila++)

{

for(columna=0;columna<=3;columna++)

{

printf("%i ", matriz[fila][columna]);

}

printf("\n");

}

}

Programación orientada a objetos

Programación que usa objetos en sus interacciones, para diseñar aplicaciones y programas informáticos.

Características

-Puede corresponder a objetos reales del mundo que nos rodea, o con objetos internos del sistema (del programa).

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

-Su uso se popularizó a principios de la década de 1990

Propiedad o atributo

Contenedor de un tipo de datos asociados a un objeto (o a una clase de objetos), que hace los datos visibles desde fuera del objeto y esto se define como sus características predeterminadas, y cuyo valor puede ser alterado por la ejecución de algún método.

La identidad

Es una propiedad de un objeto que lo diferencia del resto; dicho con otras palabras, es su identificador (concepto análogo al de identificador de una variable o una constante).

Clase

Definiciones de las propiedades y comportamiento de un tipo de objeto concreto. La instanciación es la lectura de estas definiciones y la creación de un objeto a partir de ella.

Objeto

Entidad provista de un conjunto de propiedades o atributos (datos) y de comportamiento o funcionalidad (métodos), los objetos son entidades que tienen un determinado "estado", "comportamiento (método)" e "identidad":

El estado está compuesto de datos o informaciones; serán uno o varios atributos a los que se habrán asignado unos valores concretos (datos).

El comportamiento está definido por los métodos o mensajes a los que sabe responder dicho objeto, es decir, qué operaciones se pueden realizar con él.

Herencia

Por ejemplo, herencia de la clase C a la clase D, es la facilidad mediante la cual la clase D hereda en ella cada uno de los atributos y operaciones de C, como si esos atributos y operaciones hubiesen sido definidos por la misma D. Por lo tanto, puede usar los mismos métodos y variables públicas declaradas en C. Los componentes registrados como "privados" (private) también se heredan, pero como no pertenecen a la clase, se mantienen escondidos al programador y sólo pueden ser accedidos a través de otros métodos públicos. Esto es así para mantener hegemónico el ideal de POO.

Encapsulamiento:

Significa reunir a 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

En programación seria la capacidad que tiene una clase en convertirse en un nuevo objeto sin cambiar su esencia y luego volver al objeto origina de donde salió.

Polimorfismo por Herencia:

Este tipo de polimorfismo es el más común que existe, y tiene la facultad de heredar de una clase padre y reemplazarla.

Polimorfismo por Abstracción:

Este tipo de polimorfismo se da con el uso de las clases abstractas. Pero que es una clase abstracta es aquella que además de lo normal que contiene una clase tiene comportamientos que si están definidos pero no implementados.

Polimorfismo por Interface:

Está basado por contratos, que son los encargados de decirme que puedo hacer o no y como debo de hacerlo.

Conclusión

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

Fuente de consulta

https://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos

https://codigofuentenet.wordpress.com/2012/07/17/polimorfismo-en-c/
https://es.wikipedia.org/wiki/Polimorfismo_(inform%C3%A1tica)

Sobrecarga de operadores

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. El ejemplo más sencillo de una sobrecarga de operadores nos lo da el lenguaje mismo, es decir, en una operación aritmética (por ejemplo, una suma) el compilador determina el tipo de operación requerida de acuerdo con el tipo de datos involucrados. Vamos a suponer que se tienen las variables: int A, B; double X, Y; int R; y las siguientes instrucciones:

R = A + B - C;

R = A + X;

R = X + Y;

Ahora bien:

· en el primer caso el compilador determina que el tipo de operación requerida es una suma de enteros debido a que los dos miembros (A y B) de la suma son del tipo entero.

· en el segundo caso parece ser que las cosas no son tan claras, ya que en este los miembros involucrados en la suma son de tipos diferentes, sin embargo el compilador determinará el tipo de operación requerida y depositará en el resultado (R)el valor resultante redondeado.

· en el tercero y último de los casos el compilador determina que el tipo de operación requerida es una suma de reales debido a que los dos miembros (X e Y) de la suma son del tipo double. También en este caso el resultado de la suma se redondea antes de ponerlo en R.

Mi primer sobrecarga

Para poner un ejemplo práctico de sobrecarga del operador de suma (+) vamos a considerar el caso de la clase pareja mostrada en seguida:

Si usted trata de compilar el programa anterior descubrirá que el compilador se queja, es decir, el compilador no sabe qué hacer en el caso de la instrucción Pareja C = A + B; aunque es evidente que se trata de la declaración del objeto C y que el mismo se espera que sea igual a la suma de los objetos A y B. El error se debe al hecho de que el tipoPareja es en realidad una clase y no un tipo primitivo y, en consecuencia, se debe de adiestrar al mismo compilador para que éste sepa de qué manera hará la suma de dos objetos del tipo Pareja. Así, para solucionar el error vamos a sobrecargar el operador + para trabajar la suma de dos de dichos objetos.

Sintaxis general

Tal y como usted lo habrá notado, la declaración de sobrecarga en el programa anterior es lo más parecido a una función, es decir, la sintaxis general para sobrecargar uno operador cualquiera es:

tipo  operator + (lista de parámetros);

En donde,

1. tipo se refiere al tipo regresado por el operador

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

3. el símbolo + está en representación de cualquier operador

4. lista de parámetros indica los argumentos sobre los que operarará 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::operator + (lista de parámetros);

Regresando al caso de la clase Pareja, específicamente al operador + de sobrecarga para dicha clase, nos damos cuenta que dicho operador opera sobre dos objetos de dicha clase y también devuelve un resultado de la misma clase. Esto es lo más recomendable ya que si usted recuerda el compilador regresa un resultado entero si es que (por ejemplo) se le da una instrucción como: R = 100 + 23;. En todo caso, el resultado devuelto por los operadores sobrecargados es responsabilidad del que esta programando

Sobrecarga permitida de operadores

En C++ no es posible sobrecargar todos los operadores, pero al menos la mayoría de ellos sí. Los operadores que no se pueden sobrecargar son: operadores de directivas de procesador #, ## ; Selector directo de componente . ; Operador para valores por defecto de funciones de clase : ; Operador de acceso a ámbito :: ; Operador de indirección de puntero-a-miembro .* ; Condicional ternario ?; sizeof y typeid.

Sobrecarga del operador << (iostream)

Normalmente cuando se escribe una clase y se desea que el stream estándar de salida (cout) pueda mostrar una representación de su valor se debe de sobrecargar el operador <<. Para mostrar un ejemplo retomemos el programa sobrecarga01.cpp (visto arriba), en el mismo se imprimen por medio de cout los miembros (a y b) de los objetos A, B y C.

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

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

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

Usted puede ver cómo para cada uno de los miembros de los objetos se debe de usar el operador de dirección ( . ), pues bien, nuestro objetivo es lograr que dado un objeto de la clase Pareja éste pueda ser desplegado por cout y para ello haremos la sobrecarga de operador << con el fin de que pueda operar con objetos de la clase mencionada. Veamos:

Operadores amigos (friend)

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

En la sobrecarga de los operadores +, << y >> para la clase Pareja de los programas anteriores, se puede notar que dichos operadores no son parte de la clase Pareja, sino que más bien éstos operan sobre objetos de dicha clase y es a través de dichos objetos que pueden manipular a los miembros de la clase. Ahora bien, no hemos tenido ningún problema debido a que todos los miembros de Pareja han sido declarados como públicos (public:), pero ¿qué sucede si un operador o una función que no sea parte de la clase trata de acceder a los miembros privados o protegidos de ésta? En estos casos, el compilador reportaría el error indicando que tal o cual miembro es privado dentro de cierto contexto.

Si queremos que un operador o función que no es miembro de una clase pueda acceder a los miembros públicos, privados o protegidos deberemos declarar a dicho operador o función como amigo (friend) dentro de la clase específica. Para mostrar un ejemplo modificaremos la clase Pareja, donde sus atributos serán privados.

Sobrecarga de operadores dentro de una clase

Tal y como hemos dicho antes, los operadores que hemos sobrecargado para la clase Pareja ( de los ejemplos anteriores ) no son parte de la clase, pero en la mayoría de las veces se verá que los operadores para una clase específica se deben sobrecargar dentro de la misma clase, es decir, dichos operadores serán miembros de la clase. Antes de sobrecargar cualquier operador para una clase se deben tener en cuenta los siguientes factores:

1. Los operadores binarios se declaran con un solo parámetro, ya que el primer parámetro es pasado por el programa como this, es decir, un puntero al mismo objeto.

2. Los operadores unarios se declaran sin paramétros, ya que el único parámetro es pasado por el programa como this.

Nota:

Los operadores binarios son aquellos que poseen dos partes ( izquierda y derecha),

por ejemplo, una operación de suma requiere dos operandos ( o1 + o2 ).

Los operadores unarios son aquellos que poseen solo una parte, por ejemplo, una operación

de incremento ( o1 ++ ).

Con el propósito de ver un ejemplo práctico vamos a retomar una vez más la tan famosa clase Pareja, salvo que en esta ocasión vamos a sobrecargar dentro de la misma a los operadores binarios: + (suma), - (resta), * (multiplicación) y / (división); el operador de asignación (=); el operador de incremento (++) y el operador de comparación (==).