Programa jugador

Programa Jugador

Fecha : 15/02/2016


Programa que imprimir los datos de objetos diferentes

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

typedef struct{
 char nom[20];
 char ap[20];
 int edad;
 long int cedula;
 char sexo[20];
 char estado[20];
 char nacionalidad[20];
 } estructura1;
 main()
 {
 char nom[20], sexo[20], ap[20], estado[20], nacionalidad[20];
 int edad;
 long int cedula;
 fflush(stdin);
 printf("Ingrese el nombre:\n");
 gets(nom);
 fflush(stdin);
 printf("Ingrese el apellido:\n");
 gets(ap);
 fflush(stdin);

printf("Ingrese la edad:\n");
 scanf("%i",&edad);

fflush(stdin);
 printf("Ingrese el sexo:\n");
 gets(sexo);

fflush(stdin);
 printf("Ingrese el estado:\n");
 gets(estado);

fflush(stdin);
 printf("Ingrese la nacionalidad:\n");
 gets(nacionalidad);

printf("Ingrese la cedula:\n");
 scanf("%ld",&cedula);

printf("El nombre es: %s \n",nom);
 printf("El apellido es: %s \n",ap);
 printf("La edad es: %i \n",edad);
 printf("El sexo es: %s \n",sexo);
 printf("El estado civil es: %s \n",estado);
 printf("La nacionalidad es: %s \n",nacionalidad);
 printf("La cedula a es: %ld \n",cedula);
 getch();
 }

Corrida de escritorio

Contructores y Destructores en C++

Contructores y Destructores en C++

Constructor

^

Los constructores son funciones miembro especiales que sirven para inicializar un objeto de una determinada clase al mismo tiempo que se declara.

Características

• Tienen el mismo nombre que la clase a la que pertenecen.
• No tienen tipo de retorno, y por lo tanto no retornan ningún valor.
• No pueden ser heredados.
• Por último, deben ser públicos, no tendría ningún sentido declarar un constructor como privado, ya que siempre se usan desde el exterior de la clase, ni tampoco como protegido, ya que no puede ser heredado.

Ejemplo

class <identificador de clase> {
    public:
        <identificador de clase>(<lista de parámetros>) [: <lista de constructores>] {
            <código del constructor>
        }
        ...
}

Añadamos un constructor a nuestra clase pareja:

#include <iostream> 
using namespace std;
 
class pareja {
   public:
      // Constructor
      pareja(int a2, int b2);
      // Funciones miembro de la clase "pareja"
      void Lee(int &a2, int &b2);
      void Guarda(int a2, int b2);
   private:
      // Datos miembro de la clase "pareja"
      int a, b; 
};

pareja::pareja(int a2, int b2) {
   a = a2;
   b = b2;
}

void pareja::Lee(int &a2, int &b2) {
   a2 = a;
   b2 = b;
}

void pareja::Guarda(int a2, int b2) {
   a = a2;
   b = b2;
}

int main() {
   pareja par1(12, 32);
   int x, y;
   
   par1.Lee(x, y);
   cout << "Valor de par1.a: " << x << endl;
   cout << "Valor de par1.b: " << y << endl;
   
   return 0;
}

Destructores

Los destructores son funciones miembro especiales que sirven para eliminar un objeto de una determinada clase. El destructor realizará procesos necesarios cuando un objeto termine su ámbito temporal, por ejemplo liberando la memoria dinámica utilizada por dicho objeto o liberando recursos usados, como ficheros, dispositivos, etc.

Características

• También tienen el mismo nombre que la clase a la que pertenecen, pero tienen el símbolo ˜ delante.
• No tienen tipo de retorno, y por lo tanto no retornan ningún valor.
• No tienen parámetros.
• No pueden ser heredados.
• Deben ser públicos, no tendría ningún sentido declarar un destructor como privado, ya que siempre se usan desde el exterior de la clase, ni tampoco como protegido, ya que no puede ser heredado.
• No pueden ser sobrecargados, lo cual es lógico, puesto que no tienen valor de retorno ni parámetros, no hay posibilidad de sobrecarga.

Ejemplo

#include <iostream>
#include <cstring>
using namespace std;
 
class cadena {
  public:
   cadena();        // Constructor por defecto
   cadena(const char *c); // Constructor desde cadena c
   cadena(int n);   // Constructor de cadena de n caracteres
   cadena(const cadena &);   // Constructor copia
   ~cadena();       // Destructor

   void Asignar(const char *dest);
   char *Leer(char *c);
  private:
   char *cad;       // Puntero a char: cadena de caracteres
};
 
cadena::cadena() : cad(NULL) {}
 
cadena::cadena(const char *c) {
   cad = new char[strlen(c)+1];// Reserva memoria para cadena
   strcpy(cad, c);             // Almacena la cadena
}
 
cadena::cadena(int n) {
   cad = new char[n+1]; // Reserva memoria para n caracteres
   cad[0] = 0;          // Cadena vacía   
}
 
cadena::cadena(const cadena &Cad) {
   // Reservamos memoria para la nueva y la almacenamos
   cad = new char[strlen(Cad.cad)+1];
   // Reserva memoria para cadena
   strcpy(cad, Cad.cad);             // Almacena la cadena
} 
 
cadena::~cadena() {
   delete[] cad;        // Libera la memoria reservada a cad
}
 
void cadena::Asignar(const char *dest) {
   // Eliminamos la cadena actual:
   delete[] cad;
   // Reservamos memoria para la nueva y la almacenamos
   cad = new char[strlen(dest)+1]; 
   // Reserva memoria para la cadena
   strcpy(cad, dest);              // Almacena la cadena
}
 
char *cadena::Leer(char *c) {
   strcpy(c, cad);
   return c;
}

int main() {
   cadena Cadena1("Cadena de prueba");
   cadena Cadena2(Cadena1);   // Cadena2 es copia de Cadena1
   cadena *Cadena3;           // Cadena3 es un puntero
   char c[256];
   
   // Modificamos Cadena1:
   Cadena1.Asignar("Otra cadena diferente"); 
   // Creamos Cadena3:
   Cadena3 = new cadena("Cadena de prueba nº 3");
   
   // Ver resultados
   cout << "Cadena 1: " << Cadena1.Leer(c) << endl;
   cout << "Cadena 2: " << Cadena2.Leer(c) << endl;
   cout << "Cadena 3: " << Cadena3->Leer(c) << endl;
   
   delete Cadena3;  // Destruir Cadena3. 
   // Cadena1 y Cadena2 se destruyen automáticamente

   return 0;
}

Sobrecarga de Operadores

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.

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:

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.

Ejemplo

Tenemos un método que soporta varios tipos de parámetros, entonces cuando hacemos uso de este, lo que hace el compilador es buscar el que posee ese tipo de parámetros

Color (int r, int g, int b)
Color (float a, float b, float c)
//--------------------------------------------
//r,g,b (son valores enteros entre 0 y 255)
//a,b,c (son valores flotantes entre 0.0 y 1.0)

Programación orientada a los objetos

Programación orientada a los objetos

Programacion que usa objetos en sus interacciones, para diseñar aplicaciones y programas informaticos

Características

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

-Su uso se popularizó a principios de la decada de 1900

Conceptos

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.

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).

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.

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.

Para declarar una clase, todo lo que se necesita es escribir es la palabra reservada "class". Por ejemplo, una clase Persona con campos como el nombre, el departamento, la posición, el una función que nos imprima la información de este quedaría así:

class Persona {

char nombre;
char departamento;
char posicion;
long salario;
void Imprimir( Empleado infoEmpleado);

}
NOTA: Se acostumbra que los nombres de las clases se escriban en singular y con la primera letra en MAYÚSCULAS. Por ejemplo, los nombres de una clase de los objetos del aula seran:
- Alumno.
- Profesor.

- Silla.

- Pizarron.

Las variables de miembro son declaradas privadas para que funciones de miembro de otras funciones no tengan acceso a ellas sino a travez de la correspondiente funcion Get o Set. Las funciones de miembro si son declaradas públicas de tal modo que se pueda acceder a ellas desde otras funciones.

La definición de la función PrintInfo puede quedar así:

void Empleado::ImprimirInfo( )
{
   cout << "Nombre: " << m_nombre << '\n';
   cout << "Departamento: " << m_departamento << '\n';
   cout << "Puesto: " << m_posicion << '\n';
   cout << "Salario: " << m_salario << '\n';

}

Los dos dos puntos ( :: ) se denomina operador de resolución de ámbito. Nos indica que la función que estamos definiendo que en este caso es ImprimirInfo, pertenece a la clase Persona.

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.

Ejemplo:

Programa que imprimir el nombre y cédula ingresados 

#include <conio.h>

#include <stdio.h>

class Clase {

public:

char nombre [20];

char cedula[10];

public:

void impnom();

void impcedu();

} ;

class ClaseH : Clase{

public:

public:

};

void Clase::impnom() {

 printf("Ingrese su nombre\n");

 scanf("%s",&nombre);

 printf("%s\n",nombre);

 }

 void Clase::impcedu() {

 printf("Ingrese su numero de cedula\n");

 scanf("%s",&cedula);

 printf("%s\n",cedula);

 }

  void main() {

 Clase datos1;

 datos1.impnom();

 datos1.impcedu();

 getch() ;

 }

Corrida de escritorio

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.

Ejemplo:

Programa que realiza que muestra los datos de una persona

Codigo
#include <conio.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <iostream>

class Datos{

private:

char nombre[10];

int cedula;

public:

void Impnom()

{

 printf("Ingrese nom:\n");

 scanf("%s",nombre);

 }

void Impced()

{

printf("Ingrese ced:\n");

scanf("%i",&cedula);

cout << nombre;

 printf("\n");

cout << cedula;

}

 };

class DatosH: public Datos{

private:

public:

};

main()

{

 DatosH DatosH_1;

 DatosH_1.Impnom();

 DatosH_1.Impced();

 getch();

 }

Corrida de escritorio

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

Formas de encapsular

Estándar: (Predeterminado)

Abierto: Hace que el miembro de la clase pueda ser accedido desde el exterior de la Clase y cualquier parte del programa.

Protegido: Solo es accesible desde la Clase y las clases que heredan a cualquier nivel.

Semi cerrado: Solo es accesible desde la clase heredada.

Cerrado: Solo es accesible desde la Clase.

Existen tres niveles de acceso para el encapsulamiento, los cuales son:

Público (Public): Todos pueden acceder a los datos o métodos de una clase que se definen con este nivel, este es el nivel más bajo, esto es lo que tu quieres que la parte externa vea.

Protegido (Protected): Podemos decir que estás no son de acceso público, solamente son accesibles dentro de su clase y por subclases.

Privado (Private): En este nivel se puede declarar miembros accesibles sólo para la propia clase.