PROGRAMACIÓN ORIENTADA A OBJETOS USANDO C++

INDICE

 Qué es Programación orientada a objetos (POO)

 Introducción al C++.

 Librerías, tipos, usos.

 Objetos de un programa.

 Uso de operadores y tipos de datos. Constantes y variables.

 Operadores aritméticos y lógicos, usos.

 Directivas.

 Prototipos de funciones.

 Función principal, características.

Programación orientada a objetos

La Programación Orientada a Objetos (POO), es un estilo de programar, donde el programador

conceptualiza el problema buscando patrones y comportamientos (atributos y métodos) y en
base a estos se crea un modelo ideal (clase), y a partir de él se crearan instancias del modelo
(objetos).

Así que básicamente consiste en crear clases, una clase es un tipo, por ejemplo string, es la
clase más usada, cuando se declara un objeto de esa clase (variable), solamente se pueden
almacenar strings, no se pueden guardar enteros o reales.

Ejemplo
string a, b, c;
string es la clase y a, b, c son objetos (instancia de la clase string).

La Programación Orientada a Objetos se enfoca en los datos, sin descuidar los algoritmos, esto
hace de C++ la evolución del lenguaje C, pues incorpora a la Programación estructurada la POO.

Programación orientada a objetos

Elementos

Clase: Descripción abstracta de un grupo de objetos (Patrón).

Objeto: Elemento con identidad propia.

Atributo: Variables definidas en la clase.

Método: Funciones definida en la clase.

Mensaje: Acción incorporada en el objeto

Ejemplo Clase: estudiantes.

Objeto obj.

Atributo: nombre, apellido, código.

Métodos: ingresar, eliminar, mostrar, buscar.

#include<iostream>

using namespace std;

class estudiantes{

string nombre,apellido;

int codigo;

public:

void ingresar();

void eliminar();

void mostrar();

void buscar();}obj;

Programación orientada a objetos

CLASES (CLASS)

Antes de poder definir un objeto debemos definir la clase a la que pertenece (igual que en el
ejemplo anterior debemos definir antes la estructura punto para luego poder definir las
variables a y b). La forma general de describir una clase sería más o menos:

class <nombre de la clase>{

private:
Todos los atributos;
Métodos internos que manejan memoria

public:
Métodos que manipulan lo declarado en la parte private;};

Para usarlos desde el main:

main(){

<nombre de la clase> <nombre del objeto>;

<nombre del objeto>.<nombre del método en la parte public>(<atributos>);}

EJEMPLO
Vamos a crear la clase CRONOMETRO:

class CRONOMETRO{

struct time tm; // Variable que coge la hora del sistema

int andando;

void dif_tm(time tr, time ts, time *dif);

public:

void Arranca(void);

void Muestra(void);

void Para(void);

};

CRONOMETRO p; (p será un objeto de la clase cronometro);

La función dif_tm es privada porque al resto del programa no le interesa acceder a ella, en
cambio las funciones Arranca, Muestra y Para si pueden acceder a ella porque necesitan saber
la diferencia entre dos tiempos (sobre todo la función Muestra, que es la que muestra dicha
diferencia). Para llamar a una función de la clase desde una parte del programa que no
pertenece a dicha clase, se utiliza:

nombre_objeto.funcion;

Introduccíon a c++

C++ es una mejoría sobre muchas de las características de C, y proporciona capacidades de

P.O.O. que promete mucho para incrementar la productividad, calidad y reutilización del
software.

En C, la unidad de programación es la función, con lo cual, se trata de una programación

orientada a la acción.

En C++, la unidad de programación es la clase a partir de la cual, los objetos son producidos.
Se trata, pues, de una programación orientada al objeto.

Las bibliotecas estándar de C++ proporcionan un conjunto extenso de capacidades de

entrada/salida. C++ usa entradas/salidas de tipo seguro; no podrán introducirse datos
equivocados dentro del sistema.
Se pueden especificar entradas/salidas de tipos definidos por el usuario, así como de tipos
estándar. Esta extensibilidad es una de las características más valiosas de este lenguaje de
programación.

C++ permite un tratamiento común de entradas/salidas de tipos definidos por usuario. Este
tipo de estado común facilita el desarrollo de software en general y de la reutilización de
software en particular. La salida de flujo puede ser ejecutada mediante el operador de
inserción de flujo : <<. Se hace la homonimia del operador << para extraer elementos de
datos de tipos incorporados, para extraer cadenas y para extraer valores de apuntadores.

TIPOS DE FICHEROS EN C++

• Fuente (.c): Uno o más ficheros escritos en ASCII con las instrucciones del programa.

• Objeto (.o o .obj): Son ficheros intermedios creados a partir de la compilación,

entendibles por el montador y transparentes al programador.

• Librería (.a o .lib): Reune varios ficheros objeto en uno solo. Suelen agrupar
funciones estándar.

• Cabecera (.h): Contienen definiciones y declaraciones compartidas por varios

ficheros fuente, así como las correspondientes a las funciones estándar de las
librerías. Ejecutables (.exe): Se almacena en un único fichero todo el código máquina
de los ficheros objeto asociados al programa, ya en un formato ejecutable.

Introducción a c++

Dichos operadores se pueden concatenar.

Todas las palabras claves de C++ están en minúsculas. En C++, las mayúsculas y minúsculas
son diferentes
Librerías , tipos, funciones

* FILE *fopen(const char *filename, const char *mode)

* FILE *freopen(const char *filename, const char *mode, FILE *stream)
* int fflush(FILE *stream)
* int fclose(FILE *stream)
* int remove(const char *filename)
* int rename(const char *oldname, const char *newname)
* FILE *tmpfile(void)
* char *tmpnam(char s[L_tmpnam])
* int setvbuf(FILE *stream, char *buf, int mode, size_t size)
* void setbuf(FILE *stream, char *buf)
* int fprint(FILE *stream, const char *format, …)
* int sprintf(char *s, const char *format, …)
* vprintf(const char *format, va_list arg)
* vfprintf(FILE *stream, const char *format, va_list arg)

Librerías de c++

 * vsprintf(char *s, const char *format, va_list arg)

* int fscanf(FILE *stream, const char *format, …)
* int scanf(const char *format, …)
* int sscanf(char *s, const char *format, …)
* int fgetc(FILE *stream)
* char *fgets(char *s, int n, FILE *stream)
* int fputc(int c, FILE *stream)
* int fputs(const char *s, FILE *stream)
* int getc(FILE *stream)
* int getchar(void)
* char *gets(char *s)
* int putc(int c, FILE *stream)
* int putchar(int c)
* int ungetc(int c, FILE *stream)

Tests: <ctype.h>

 * isalnum(c)
* isalpha(c)
* iscntrl(c)
* isdigit(c)
* isgraph(c)
* islower(c)
* isprint(c)
* ispunct(c)
* isspace(c)
* isupper(c)
* isxdigit(c)

<string.h>
  * char *strcpy(s , ct)
* char *strncpy(s , ct , n)
* char *strcat(s , ct)
* char *strncat(s , ct , n)
* int strcmp(cs , ct)
* int strncmp(cs , ct ,n)
* char *strchr(cs , c)
* char *strrchr(cs , c)
* size_t strspn(cs , ct)
* size_t strcspn(cs , ct)
* char *strstr(cs , ct)
* size_t strlen(cs)
* char *strerror(n)
* char *strtok(s , ct)

Mathematical Functions: <math.h>

 * sin(x)

 * cos(x)

 * tan(x)

 * asin(x)

 * acos(x)

 * atan(x)

 * atan2(x)

 * sinh(x)

 * cosh(x)

 * tanh(x)

Utility Functions: <stdlib.h>

 * double atof(const char *s)

* int atoi(const char *s
* long atol(const char *s)
* double strrod(const char *s, char **endp)
* long strtol(const char *s, char **endp, int base)
* unsigned long strtoul(const char *s, char **endp, int base)
* int rand(void)
* void srand(unsigned int sedé)
* void *calloc(size_t nobj, size_t size)
* void *malloc(size_t size)
* void *realloc(void *p, size_t size)
COMENTARIOS Y DECLARACIONES EN C++

C++ permite empezar un comentario con // y usar el resto de la línea para texto del
comentario; el fin de la línea da de manera automática por terminado el comentario. También
es aceptable la forma de C : /* */.

En C++, a diferencia de C, las declaraciones pueden ser colocadas en cualquier parte de un

enunciado ejecutable, siempre y cuando las declaraciones antecedan el uso de lo que se está
declarando. También, las variables pueden ser declaradas en la sección de inicialización de una
estructura for; dichas variables se mantienen en alcance hasta el final del bloque en el cual la
estructura for está definida.

El alcance de una variable local C++ empieza en su declaración y se extiende hasta la llave
derecha de cierre. Las declaraciones de variables no pueden ser colocadas en la condición de
una estructura while, do/while

FLUJO DE ENTRADA/SALIDA DE C++

C++ ofrece una alternativa a las llamadas de función printf y scanf para manejar la
entrada/salida de los tipos y cadenas de datos estándar. Así, en lugar de printf usamos el flujo
estándar de salida cout y el operador << (''colocar en''); y en lugar de scanf usamos el flujo de
entrada estándar cin y el operador >> (''obtener de''). Estos operadores de inserción y
extracción de flujo, a diferencia de printf y scanf, no requieren de cadenas de formato y de
especificadores de conversión para indicar los tipos de datos que son extraídos o introducidos.

Para utilizar entradas/salidas de flujo, se debe incluir el archivo de cabecera iostream.h.

Como crear nuevo tipo de datos

C++ proporciona la capacidad de crear tipos definidos por el usuario mediante el uso de las
palabras reservadas enum, struct, union y la nueva palabra reservada class. A diferencia de C,
una enumeración ( enum ) en C++, cuando se declara, se convierte en un tipo nuevo. Para
declarar la variable del nuevo tipo, la palabra reservada enum no es requerida. Lo mismo para
struct, union y class. Los nombres de etiqueta pueden ser utilizados para declarar variables. Las
enumeraciones por omisión son evaluadas iniciándose en cero.

PROTOTIPOS DE FUNCION Y VERIFICACION DE TIPOs

C++ requiere que se declaren todos los parámetros de función en los paréntesis de la definición
de función y del prototipo. Una lista vacía de parámetros se especifica escribiendo void o
absolutamente nada en los paréntesis.

Funciones en línea

Existen funciones en línea que ayudan a reducir la sobrecarga por llamadas de función especial
para pequeñas funciones. El compilador puede ignorar el calificador inline y típicamente así lo
hará para todo, a excepción de las funciones más pequeñas. El calificador inline deberá ser
utilizado sólo tratándose de funciones pequeñas, de uso frecuente. Usa funciones inline puede
reducir el tiempo de ejecución, pero puede aumentar el tamaño del programa.
Parámetros de referencia

C++ ofrece parámetros por referencia. Un parámetro de referencia es un seudónimo (''alias'')

de su argumento correspondiente. Para indicar que un parámetro de función es pasado por
referencia, sólo hay que colocar un ampersand (&) después del tipo del parámetro en el
prototipo de función.

Debemos usar apuntadores para pasar argumentos que pudieran ser modificados por la
función llamada, y usar referencias a constantes para pasar argumentos extensos, que no serán
modificados.

Las variables de referencia deben ser inicializadas en sus declaraciones, y no pueden ser
reasignadas como seudónimos a otras variables.

Cuando se regresa un apuntador o una referencia a una variable declarada en la función

llamada, la variable deberá ser declarada static dentro de dicha función.

Las referencias pueden ser usadas como argumentos de funciones y regresar valores.

Parámetros de referencia
EL CALIFICADOR CONST

El calificador const se usa en la lista de parámetros de una función para especificar que un
argumento pasado a la función no es modificable en dicha función. También puede ser
utilizado para declarar las llamadas ''variables constantes''. Estas pueden ser colocadas en
cualquier parte en que se espere una expresión constante. También en archivos de cabecera.

La variable constante debe ser inicializada al declararse.

Otro uso común para el calificador const es para poder declarar un apuntador constante.

Tabla con expresiones de declaración de constantes:

FORMATO CIN AND COUT

En C++ se empieza a utilizar el concepto de flujos de E/S y no son mas que una clase (son dos
clases: CIN y COUT). Las salidas con formatos de COUT:

cout <<formato<<variable; // equivale a printf(“formato”,variable);

dec = %d (enteros)

hex = hexadecimal

oct = octal

endl = “\n” (en CIN y COUT se puede seguir poniendo “\n”)

ends = ‘\0’ (inserta el fin de cadena, un NULL, no el carácter cero)

setw (num) fija la anchura de un campo en n bytes;

cout<<setw(6)<<variable

setprecision(n) = fija el numero de decimales que queremos (n).

todas estas cosas están en la librería <iomanip.h>

FORMATO CIN AND COUT

EJEMPLO:
*Sacar un numero en tres formatos: hexadecimal, octal y decimal:

#include <iostream.h>

#include <iomanip.h>

int num;

cin<<num;

cout<<” el numero decimal es: “<<dec<<num<<endl; (endl=”\n”)

cout<<“el numero octal es: “<<dec<<oct<<endl; (endl=”\n”)

cout<<” el numero decimal es: “<<dec<<hex<<endl; (endl=”\n”)

CONSTRUCTOR Y DESTRUCTOR

Lo mas normal es que un objeto tenga que reinicializarse, para hacerlo usamos el constructor
(tiene el mismo nombre de la clase); no es necesario que se creen (en este caso el compilador
utiliza el constructor explicito que inicializa los dato en cero o NULL, según sea el tipo de
dato); cuando se encuentra una declaración de un objeto, el compilador llama al constructor.
No se debe llamar explícitamente al constructor. El formato de la función constructora es:

nombre_clase (parámetros);

Podemos definir la función constructora para que inicialice ciertas variables, pedir memoria
dinámica, etc. El destructor no se debe llamar explícitamente, el compilador lo llama antes
de terminar el programa (cuando llega a la última llave del main). Si no existe el destructor,
el compilador llama a uno por defecto. Su formato es:

~nombre_clase (parámetros);

Si hemos reservado memoria dinámica en la función constructora, podemos aprovechar y

liberarla en la destructora.