#INCLUDE <IOSTREAM>

INT MAIN()
{
STD::COUT << "Hola Mundo\n";
STD::COUT << "ADIOS";
RETURN 0;
}

SI PONEMOS AL INICIO USING STD::COUT NO TENDREMOS QUE INCLUIRLO CADA VEZ QUE
DECLAREMOS UN COUT.

TAMBIEN TENEMOS LA FORMA MAS GENERAL DE DECIRLE QUE UTILICE TODO EN LA LIBRERIA
STANDAR CON
USING NAMESPACE STD;

unsigned short int podemos convertirlo en un alias con typedef unsigned short int
USHORT;

// ejemplo uso palabra clave typedef

#include <iostream>

typedef unsigned short int USHORT; //definimos typedef

int main()
{

using std::cout;
using std::endl;

USHORT Ancho = 5;
USHORT Largo;
Largo = 10;
USHORT Area = Ancho * Largo;
cout << "Ancho:" << Ancho << "\n";
cout << "Largo: " << Largo << endl;
cout << "Area: " << Area <<endl;
return 0;
}

PERO DE ESTA MANERA SOLO PODREMOS UTILIZAR LA LIBRERIA STANDAR EN TODO EL PROGRAMA.

CONSTANTE LITERAL : ESTUDIANTES = CLASES * 15 (15 ES LA CONSTANTE LITERAL).

CONSTANTE SIMBOLICA : ESTUDIANTES = CLASES * ESTUDIANTESPOR CLASE

(ESTUDIANTESPOR CLASE ES LA CONSTANTE SIMBOLICA).

LAS CONSTANTES SIMBOLICAS SE DECLARAN AL INICIAR EL PROGRAMA Y SE DECLARAN DE DOS

FORMAS.

1 FORMA #DEFIN

#DEFINE ESTUDIANTESPORCLASE 15

2 FORMA CONST

CONST UNSIGNED SHORT INT ESTUDIANTESPORCLASE = 15;

LA MEJOR FORMA ES CON CONST, YA QUE ES LA FORMA ACTUAL DE DECLARAR LAS CONSTANTES
SIMBOLICAS SEGUN EL ESTANDAR ANSI.

CONSTANTES ENUMERADAS

NOS PERMITEN CREAR NUEVOS TIPOS

ENUM COLOR {ROJO,AZUL,VERSE,BLANCO,NEGRO};

ENUM COLOR {ROJO,AZUL,VERSE,BLANCO,NEGRO};

CONVIERTE COLOR CONVIERTE ROJO EN UNA CONSTANTE

EN UNA ENUMERACION: SIMBOLICA CON VALOR DE 0, AZUL UNA
UN NUEVO TIPO. CONSTANTE SIMBOLICA CON VALOR DE 1

CADA PODEMOS
CONSTANTE INICIALIZAR UNA
ENUMERADA CONSTANTE CON
TIENE UN VALOR CUALQUIER
INTEGER. VALOR.

EL VALOR DE LA CONSTANTE SIEMPRE EMPEZARA DESDE CERO SI NO LE INDICAMOS LO

CONTRARIO.

ENUM COLOR {ROJO=100,AZUL,VERDE=500,BLANCO,NEGRO=700};

ROJO = 100
AZUL = 101
VERDE = 500
BLANCO = 501
NEGRO = 700

VARIABLES CONSTANTES

NUMERICAS CARACTER LITERALES SIMBOLICAS

ENUMERADAS

INTEGER FLOATING CHAR

POINT

INT FLOAT
SHORT INT DOUBLE
LONG INT LONG DOUBLE

MIEDAD = MIEDAD + 2;

MIEDAD +=2;

ES LO MISMO.

CONTADOR = CONTADOR + 1;

CONTADOR ++;

ES LO MISMO.

CONTADOR = CONTADOR - 1;

CONTADOR --;
ES LO MISMO.

++ CONTADOR;

-- CONTADOR;

INT X = 5;
INT A = ++X; // A = 6; X = 6;

INT X = 5;
INT B = X++; // B = 5; X = 6;

USAMOS EL OPERADOR PREFIJO ++VARIABLE PARA INCREMENTAR O DECREMENTAR LA VARIABLE

ANTES DE USARLA EN LA EXPRESION.

USAMOS EL OPERADOR POSTFIJO VARIABLE++ PARA INCREMENTAR O DECREMENTAR LA VARIABLE

DESPUES DE USARLA EN LA EXPRESION.

EN C++ FALSO ES SIEMPRE IGUAL A 0.

IF(X) // SI X ES VERDADERO (NO CERO). --- SI ES 1 SE EJECUTA.

X = 0;

IF(X!=0) // SI X NO ES CERO. --------------- SI ES 1 SE EJECUTA.

X = 0;

IF(!X) // SI X ES FALSO (CERO). ----------- SI ES 0 SE EJECUTA.

IF(X==0);

NO USE IF(X) COMO UN SINONIMO DE IF(X!=0); ESTE ULTIMO ES MAS CLARO.

NO USES IF(!X) COMO UN SINONIMO DE IF(X==0); ESTE ULTIMO ES MAS CLARO.

RECUERDA UTILIZAR PARENTESIS PARA OPERACIONES LOGICAS AND OR XOR EXOR NOT ETC... DE
ESTA FORMA ESTARA MAS CLARO EL CODIGO.

OPERADOR TERNARIO:

Z = (X > Y ) ? X : Y;

SI X ES MAYOR QUE Y Z SERA X SINO ENTONCES SERA Y.

SERIA LO MISMO QUE:

IF (X > Y)
Z = X;
ELSE
Z = Y;

FUNCIONES:

LAS FUNCIONES PUEDEN LLAMAR A OTRAS FUNCIONES.

LAS FUNCIONES SE PUEDEN LLAMAR A SI MISMO LO QUE SE DENOMINA RECURSIVIDAD.

LA FUNCIONES TIENEN QUE SER DECLARADAS CON UN VALOR DE RETORNO.

INT MIFUNCION();

EN ESTE CASO SU VALOR DE RETORNO TIENE QUE SER UN ENTERO.

LAS FUNCIONES PUEDN RECIBIR VALORES.

INT MIFUNCION(INT UNENTERO, FLOAT UNDECIMAL);

EL VALOR DE RETORNO TIENE QUE SER UN INTEGER.

TOMA UN PARAMETRO DE TIPO INTEGER.

TOMA UN PARAMETRO DE TIPO FLOAT.

LLAMADA A UNA FUNCION:

INT RETORNO = MIFUNCION(3, 5.2);

CUANDO SE PASAN ARGUMENTOS A UNA FUNCION TIENEN QUE COINCIDIR EN TIPO Y NUMERO

INT RETORNO = MIFUNCION(3, 5.2);

INT MIFUNCION(INT UNENTERO, FLOAT UNDECIMAL);

PODEMOS ESCRIBIR UNA FUNCION DENTRO DE UN ARCHIVO Y USAR UN #INCLUDE PARA LLAMARLA.

PODEMOS ESCRIBIR UNA FUNCION DENTRO DEL MISMO ARCHIVO EN EL QUE SE USA LA FUNCION.

PODEMOS ESCRIBIR UNA FUNCION ANTES DE QUE SEA LLAMADA POR CUALQUIER OTRA FUNCION.

ESTA ULTIMA FORMA ES UNA MALA PRACTICA.

POR QUE NO DEFINIR LA FUNCION ANTES DE USARLA?

AL HACER QUE LA FUNCION APAREZCA EN UN ORDEN CONCRETO DENTRO DEL PROGRAMA DIFICULTA
EL MANTENIMIENTO POSTERIOR DEL CODIGO.

SI DOS FUNCIONES NECESITAN LLAMARSE MUTUAMENTE, NO PODEMOS DEFINIR LAS DOS ANTES DE
SU USO, ASI QUE UNA DE ELLAS AL MENOS TIENE QUE SER DECLARADA.

EL PROTOTIPADO DE LAS FUNCIONES ES UNA BUENA TECNICA DE DEPURACION AL PERMITIR AL

COMPILADOR COMPROBAR EL TIPO DE PARAMETROS O RETORNO ANTES DE LA EJECUCION DE LA
FUNCION.

AL PROTOTIPAR UNA FUNCION SE TIENEN QUE PONER LOS SIGUIENTES DATOS.

 TIPOS DE PARAMETRO Y NOMBRE DE PARAMETROS

INT AREA (INT LARGO, INT ANCHO) ;

TIPO DE RETORNO NOMBRE PARAMETROS PUNTO Y COMA

EN EL PROTOTIPO EL PUNTO Y COMA ES OBLIGATORIO YA QUE ESTAMOS DECLARANDO UNA

FUNCION.

EN EL PROTOTIPO TODOS LOS DATOS TIENEN QUE COINCIDIR CON LO QUE DESPUES INDIQUEMOS
CUANDO DEFINAMOS LA FUNCION EN SU CABEZERA.

EN EL PROTOTIPO TIENE QUE COINCIDIR EL TIPO DE PARAMETRO (INT ETC...) PERO NO ES

OBLIGATORIO EL PONER NOMBRE.

LONG AREA(INT, INT); LONG AREA (INT LARGO, INT ANCHO);

ESTAS DOS DECLARACIONES DE PROTOTIPOS SERIAN CORRECTOS.

CUANDO DEFINAMOS LA FUNCION EN LA CABEZERA PODREMOS UTILIZAR OTROS NOMRES Y

FUNCIONARA CORECTAMENTE.

TODAS LAS FUNCIONES TANTO EN SU PROTOTIPO COMO EN SU DEFINICION EN SU CABEZERA

TIENEN QUE INDICAR UN TIPO DE RETORNO SI NO SE INDICA POR DEFECTO EL COMPILADOR
CONSIDERADA QUE ES UN INTEGER (INT).

SI NO QUEREMOS QUE TENGA UN RETORNO TENEMOS QUE DECLARAR SU TIPO COMO VOID.

VOID VER (INT VALOR);

CREAR FUNCION:

DEFINICON FUNCION = CABEZERA + CUERPO

LA CABEZERA ES IGUAL A PROTOTIPO EXCEPTO:

1 - LOS PARARAMETROS DEBEN TNER NOMBRE.

2 - NO LLEVA PUNTO Y COMA FINAL

EN EL CUERPO EL CONJUNTO DE DECLARACIONES TIENEN QUE ESTAR ENCERRADAS ENTRE LLAVES.

Y A DIFERENCIA DEL PROTOTIPO ES OBLIGATORIO EL NOMBRE DE LOS PARAMETROS Y NO
TERMINA CON UN PUNTO Y COMA.

AL CREAR UNA FUNCION SE TIENEN QUE PONER LOS SIGUIENTES DATOS.

TIPOS DE PARAMETRO Y NOMBRE DE PARAMETROS

INT AREA (INT LARGO, INT ANCHO)

TIPO DE RETORNO NOMBRE PARAMETROS

{ - LLAVE DE APERURA.
 // DECLARACIONES.

RETURN (LARGO*ANCHO);

VALOR DE RETORNO

} - LLAVE DE CIERRE

NO SE PUEDE DEFINIR UNA FUNCION DENTRO DE OTRA FUNCION.

SI SE PUEDEN LLAMAR A OTRAS FUNCIONES DESDE UNA FUNCION O INCLUSO A ELLAS MISMAS.
(RECURSION).

ALCANCE DE LAS VARIABLES

CADA VARIABLE TIENE UN ALCANCE:

DETERMINA CUANDO ESTA DISPONIBLE.

Y DESDE DONDE PUEDE SER ACCEDIDA.

VARIABLES DECLARADAS DENTRO DE UN BLOQUE:

PUEDE ACCEDERSE A ELLAS SOLO DENTRO DE LAS LLAVES DE ESE BLOQUE.

DEJAN DE EXISTIR CUANDO ESE BLOQUE FINALIZA.

VARIABLES GLOBALES:

TIENEN UN ALCANCE GLOBAL.

ESTAN DISPONIBLES EN CUALQUIER SITIO DENTRO DEL PROGRAMA.

SI UNA VARIABLE LOCAL TIENE EL MISMO NOMBRE QUE UNA VARIABLE GLOBAL PREVALECERA LA
VARIABLE LOCAL. Y EL VALOR DE LA GLOBAL NO CABIARA EN NINGUN MOMENTO. PERO SI
CAMBIARA EL VALOR DE LA LOCAL.

LAS VARIABLE GLOBALES SE DECLARAN FUERA DE MAIN().

ALCANCE DE VARIABLES LOCALES:

PODEMOS DEFINIR VARIABLES EN CUALQUIER SITIO DENTO DE LA FUNCION.

EL ALCANCE DE LA VARIABLE ES EL BLOQUE EN EL CUAL ESTA DEFINIDA.

PODEMOS DEFINIR UNA VARIABLE DENTRO DE UN BLOQUE DENTRO DE UNA FUNCION PERO ESTA
VARIABLE SERA SOLAMENTE DISPONIBLE DENTRO DE ESTE BLOQUE.

LOS VALORES QUE SON PASADOS A LAS FUNCIONES SON LOCALES A LA FUNCION.

LOS CAMBIOS HECHOS NO AFECTAN A LOS VALORES EN LA FUNCION DE LLAMADA.

ESTO ES CONOCIDO COMO PASAR POR VALOR.

LOS ARGUMENTOS QUE LE PODEMOS PASAR A UNA FUNCION PUEDEN SER:

CONSTANTES.

EXPRESIONES MATEMATICAS.

EXPRESIONES LOGICAS.

OTRAS FUNCIONES.

UN EJEMPLO SERIA EL SIGUIENTE.

RESPUESTA = (MIDOBLE(TRIPLE(CUADRADO(CUBO(MIVALOR))))));

MI DOBLE TOMA LA FUNCION TRIPLE.

TRIPLE TOMA LA FUNCION CUADRADO.
CUBO TOMA LA VARIABLE MIVALOR.
CUADRADRO TOMA LA FUNCION CUBO.
CUADRADRO TOMA LA FUNCION CUBO.

TODO LO ANTERIOR FUNCIONARIA SIN PROBLEMA PERO ES POCO CLARO.

SERIA MEJOR REALIZAR LO SIGUIENTE.

UNSIGNED LONG MIVALOR = 2;

UNSIGNED LONG CUBO = CUBO(MIVALOR); // CUBO = 8
UNSIGNED LONG CUADRADO = CUADRADO(CUBO); // CUADRADO = 64
UNSIGNED LONG TRIPLE = TRIPLE(CUADRADO); // TRIPLE = 192
UNSIGNED LONG RESPUESTA = MIDOBLE(TRIPLE); // RESPUESTA = 384

Y DE ESTA FORMA ES MAS CLARO EL CODIGO.

LAS FUNCIONEN PUEDEN DEVOLVER VALORES:

VALOR DE RETORNO.

VOID.

RETURN 5;
RETURN (X>5); DEVUELVE VERDADERO (TRUE) SI X ES MAYOR QUE 5.
RETURN (MIFUCION()); SIEMPRE SI MIFUNCION() DEVUELVE ALGUN VALOR.
ETC.....

CUANDO SE EJECUTA UN RETURN DEVUELVE EL CONTROL A LA FUNCION DE LLAMADA Y CUALQUIER

OTRA
DECLARACION DESPUES DE RETURN NO SE EJECUTARA.

SE PUEDE TENER MAS DE UNA DECLARACION RETURN EN UNA FUNCION.

PARAMETROS POR DEFECTO AL LLAMAR A UNA FUNCION:

POR CADA PARAMETRO DECLARADO EN EL PROTOTIPO DE UNA FUNCION. CUANDO DEFINAMOS LA

FUNCION EL PARAMETRO DEBE SER DEL MISMO TIPO Y CUANDO LLAMEMOS A LA FUNCION TENEMOS
QUE PASARLE UN VALOR DEL MISMO TIPO.

LONG MIFUNCION(INT);
SI EL TIPO DE PARAMETRO SI EL ARGUMENTO EN
EN DEFINICION NO ES INT. LLAMADA NO ES INT.

TODO ESTO DARIA ERROR.

LA UNICA EXCEPCION ES QUE LA FUNCION PROTOTIPO UTILICE UN VALOR POR DEFECTO PARA EL
PARAMETRO.

UN VALOR POR DEFECTO ES UN VALOR QUE SE USARA SI NO SE INDICA OTRO.

LONG MIFUNCION(INT=0);

DE ESTA FORMA YA NO ES OBLIGATORIO CUANDO LLAMEMOS A LA FUNCION QUE LE PASEMOS UN

VALOR PARA EL PARAMETRO.

LONG MIFUNCION(INT = 50); DECLARACION DEL PROTOTIPO.

LONG MIFUNCION(INT X) DEFINICION DE LA FUNCION.

LA DEFICION DE LA EL VALOR POR DEFECTO ES

FUNCION NO CAMBIA. ASIGNADO POR POSICION,
NO POR NOMBRE.

PODEMOS ASIGNAR VLORES POR DEFECTO AL NUMERO D PARAMETROS QUE QUERAMOS.

PERO SI UN PARAMETO NO TIENE UN VALOR POR DEFECTO NINGUN PARAMETRO PREVIO PUEDE
TENERLO.

LONG MIFUNCION(INT PARAM1, INT PARAM2, INT PARAM3);

PODEMOS ASIGNAR VALOR POR DEFECTO A PARAM2, SOLO SI TENEMOS ASIGNADO UN VALOR POR
DEFECTO A PARAM3.

PODEMOS ASIGNAR UN VALOR POR DEFECTO A PARAM1, SOLO SI TENEMOS ASIGNADO UN VALOR
POR DEFECTO A PARAM 2 Y PARAM3.

SOBRECARGA DE LAS FUNCIONES:

ES PODER CREAR MAS DE UNA FUNCION CON EL MISMO NOMBRE. (POLIMORFISMO FUNCIONAL)

INT MIFUNCION(INT, INT)

INT MIFUNCION(LONG, LONG)

INT MIFUNCION(LONG)

ESAS FUNCIONES QUE COMPARTAN EL MISMO NOMBRE TENDRAN QUE SER DISTINTAS EN SU LISTA
DE PARAMETRO. EL TIPO DE PARAMETROS, EL NUMERO DE PARAMETROS O AMBAS COSAS A LA
VEZ.

DOS FUNCIONES CON EL MISMO NOMBRE Y LISTA DE PARAMETROS PERO DIFERENTES TIPOS DE
RETORNO DA ERROR.

LA FUNCION CORRECTA SERA LLAMADA AL CONCORDAR CON LOS PARAMETROS.

SI QUISIERAMOS CREAR UNA
FUNCION QUE NOS DIESE EL
DOBLE DE UN NUMERO DADO
PODRIAMOS CREAR VARIAS
FUNCIONES.
PERO PODRIAMOS CREAR LAS
CUATRO FUNCIONES CON EL MISMO
NOMBRE PERO PASANDOLE DISTINTOS
PARAMETROS.

INT DOBLEINT (INT); INT DOBLE (INT);

LONG DOBLELONG (LONG); LONG DOBLE (LONG);
FLOAT DOBLEFLOAT (FLOAT); FLOAT DOBLE (FLOAT);
DOUBLE DOBLEDOUBLE (DOUBLE); DOUBLE DOBLE (DOUBLE);

SI OBSERVAMOS DIFIERE EL VALOR DE RETORNO, PERO SI FUESE SOLO EL VALOR DE RETORNO

PERO EL PARAMETRO FUESE IGUAL NOS DARIA ERROR.

EJEMPLO:

// Ejemplo de polimorfismo funcional

#include <iostream>

int Doble(int);
long Doble(long);
float Doble(float);
double Doble(double);

using namespace std;

int main()
{
int miInt = 6500;
long miLong = 65000;
float miFloat = 6.5F;
double miDouble = 6.5e20;

int dobladoInt;
long dobladoLong;
float dobladoFloat;
double dobladoDouble;

cout << "miInt: " << miInt << "\n";

cout << "miLong: " << miLong << "\n";
cout << "miFloat: " << miFloat << "\n";
cout << "miDouble: " << miDouble << "\n";

dobladoInt = Doble(miInt);
dobladoLong = Doble(miLong);
dobladoFloat = Doble(miFloat);
dobladoDouble = Doble(miDouble);

cout << "dobladoInt: " << dobladoInt << "\n";

cout << "dobladoLong: " << dobladoLong << "\n";
cout << "dobladoFloat: " << dobladoFloat << "\n";
cout << "dobladoDouble: " << dobladoDouble << "\n";

return 0;
}

int Doble(int original)

{
 cout << "En Doble(int)\n";
return 2 * original;
}

long Doble(long original)

{
cout << "En Doble(long)\n";
return 2 * original;
}

float Doble(float original)

{
cout << "En Doble(float)\n";
return 2 * original;
}

double Doble(double original)

{
cout << "En Doble(double)\n";
return 2 * original;
}

FUNCIONES INLINE:

CUANDO CREAMOS UNA FUNCION EL COMPILADOR CREA UN CONJUNTO DE INSTRUCCIONES EN LA

MEMORIA Y CUANDO LLAMAMOS A LA FUNCION LA EJECUCION DEL PROGAMA SALTA A ESE LUGAR
DE LA MEMORIA DONDE SE ENCUENTRAN LAS INSTRUCCIONES LAS EJECUTA Y CUANDO TERMINA
LA FUNCION RETORNA AL LUGAR DESDE DONDE FUE LLAMADA.

ASI PODEMOS TENER UN PROGRAMA QUE LLAME A LA FUNCION DIEZ VECES, EL PROGRAMA
SALTARA A ESA LOCALIZACION EN MEMORIA 10 VECES.

DE ESTA FORMA NO TENDREMOS QUE TENER ESCRITO EL CODIGO DIEZ VECES.

PERO CADA VEZ QUE LLAMAMOS A UNA FUNCION SE PRODUCE UNA PEQUEA SOBRECARGA SOBRE EL
PROCESADOR CON ESOS SALTOS DE IDA Y VUELTA DE LAS FUNCIONES AL LUGAR QUE OCUPAN EN
LA MEMORIA.

MUCHAS VECES PUEDE OCURRIR QUE UNA FUNCION SEA MUY PEQUEA Y QUE OCUPE SOLO UNA O
DOS LINEAS DE CODIGO Y PUEDE QUE EL PROGRAMA SEA MAS EFICIENTE SI EN LUGAR DE DAR
ESOS SALTOS SE INCLUYE DIRECTAMENTE LAS INSTRUCCIONES DE ESA FUNCION EN LUGAR DE
LLAMARLA Y TENER QUE IR EL COMPILADOR A SU LUGAR EN MEMORIA.

EN ALGUNOS CASOS PUEDE QUE EL PROGRAMA SE EJECUTE MAS RAPIDO SI EVITAMOS ESAS
FUNCIONES DE LLAMADA.

LA PALABRA CLAVE ES INLINE Y CUANDO EL COMPILADR LA ENCUENTRA NO CREA UNA FUNCION

REAL SINO LO QUE HACE ES COPIAR LA FUNCION EN LA LLAMADA NO SE HACE NINGUN SALTO ES
COMO SI ESCRIBIERAMOS EL CODIGO DE LA FUNCION CADA VEZ QUE ESTE CODIGO SEA LLAMADO
Y DE ESTE MODO NO NECESITAMOS ESTAR SALTANDO CONSTANTEMENTE PERO SI QUE AUMENTA LA
CANTIDAD DE CODIGO.

// Ejemplo de funciones inline

#include <iostream>

inline int Doble(int);

 int main()
{
int objetivo;
using std::cout;
using std::cin;
using std::endl;

cout << "Escribe un numero para utilizar: ";

cin >> objetivo;
cout << "\n";

objetivo = Doble(objetivo);
cout << "Objetivo: " << objetivo << endl;

objetivo = Doble(objetivo);
cout << "Objetivo: " << objetivo << endl;

objetivo = Doble(objetivo);
cout << "Objetivo: " << objetivo << endl;
return 0;
}

int Doble(int objetivo)

{
return 2*objetivo;
}

ES UNA HERRAMIENTA DE DOBLE FILO Y NO ES MUY RECOMENDABLE.

POO:

LOS OBJETOS TIENEN UNAS CARECTIRISTICAS Y PUEDEN LLEVAR A CABO ACCIONES.

CARACTERISTICAS DE UN COCHE: VARIABLES:

ACELERADOR, FAROS, FRENOS.

CACIONES DE UN COCHE: FUNCIONES:

ACELERAR, ENCENDER, FRENAR

LAS VARIABLES Y LAS FUNCIONES ESTAN INCLUIDAS DENTRO DEL PROPIO OBJETO
(ENCAPSULADAS).

DECLARAR UNA CLASE ES CREAR UNA COLECCION DE VARIABLES Y DE FUNCIONES.

LAS VARIABLES Y LAS FUNCIONES DE UN OBJETO CLASE SE CONOCEN COMO VARIABLES MIEMBRO
Y FUNCIONES MIEMBRO.

UNA FUNCION MIEMBRO TAMBIEN ES CONOCIDA COMO METODO.

DECLARAR UNA CLASE:

CLASS CABALLO
{
 UNSIGNED INT SUEDAD;
UNSIGNED INT SUPESO;
VOID RELINCHAR();
};

LA CLASE ES LA IDEA Y EL OBJETO ES LA ENTIDAD. EXISTE LA IDEA (CLASE) DE PERRO PERO

UN PERRO DE VERDAD SERIA LA ENTIDAD (OBJETO).

DEFINIR UN OBJETO:

CABALLO JANTO

DEFINIMOS UN OBJETO LLAMADO JANTO DE LA CLASE CABALLO.

CUANDO HABLAMOS DE UN OBJETO HABLAMOS DE UNA INSTANCIA INDIVIDUAL DE UNA CLASE Y SE

LE LLAMA INSTANCIAR DE UN OBJETO.

ACCEDER A LOS MIEMBROS DE UNA CLASE:

SE USA EL OPERADOR PUNTO (.).

JANTO.SUPESO=50; ASIGNAR EL VALOR 50 A LA VARIABLE MIEMBRO SUPESO.

JANTO.RELINCHAR(); LLAMAR A LA FUNCION RELINCHAR.

SE ASIGNA SIEMPRE VALORES A LOS OBJETOS NUNCA A LAS CLASE.

MIEMBROS PUBLIC/PRIVATE:

TODOS LOS MIEMBROS SON PRIVADOS POR DEFECTO TANTO EN LAS VARIABLES MIEMBRO COMO EN
EN LAS FUNCIONES MIEMBRO.

INT MAIN()

{
CABALLO BALIO;
BALIO.SUEDAD = 5; ERROR YA QUE ES UNA VARIABLE MIEMBRO PRIVADA.
}

ESTO SE LLAMA ENCAPSULACION Y DE ESTA MANERA SE PROTEGE EL OBJETO.

PARA PODER ACCEDER SE TENDRIA QUE HACER LA VARIABLE MIEMBRO COMO PUBLICA.

AHORA TODO SERIA PUBLIC.

CLASS CABALLO
{

PUBLIC:
UNSIGNED INT SUEDAD;
UNSIGNED INT SUPESO;
VOID RELINCHAR();
};

PODEMOS TENER PARTES PUBLICAS COMO PRIVADAS.

CLASS CABALLO
{

PRIVATE:
UNSIGNED INT SUEDAD;
UNSIGNED INT SUPESO;
PUBLIC:
VOID RELINCHAR();
};

METODOS ACCESOR:

FUNCIONES MIEMBRO PUBLICAS.

OBTIENEN O MODIFICAN VARIABLES MIEMBRO PRIVADAS.

PERMITEN SEPARAR INFORMACION DE UTILIZACION.

IMPLEMENTAR:

PRIMERO TENEMOS QUE DECLARAR LOS OBJETOS Y DESPUES IMPLEMENTARLOS.

LA DECLARACION ES COMO PROTOTIPAR UNA FUNCION Y LA IMPLEMENTACION ES COMO LA

DECLARACION DE LA FUNCION.

TIPO NOMBRE DOS VECES NOMBRE DE

DE DE DOS PUNTOS LA FUNCION
RETORNO CLASE

INT CABALLO :: OBTENEREDAD()

{
RETURN SUEDAD;
}

DECLARACION DE UNA CLASE Y DEFINICION DE METODOS CLASE:

// Demostracin declaracin de una clase y definicin de mtodos de clase

#include <iostream> // para cout

class Caballo // empezar declaracin de la clase

{
public: // empezar seccin pblica
int ObtenerEdad(); // funcin accessor
void ConfigurarEdad (int edad); // accessor function
void Relinchar(); // funcin general
private: // empezar seccin privada
int suEdad; // variable miembro
};

// ObtenerEdad, funcin accessor pblica

// devuelve el valor del miembro suEdad
int Caballo::ObtenerEdad()
{
 return suEdad;
}

// definicin de ConfigurarEdad, funcin accessor pblica

// configura miembro suEdad
void Caballo::ConfigurarEdad(int edad)
{
// configura la variable miembro suEdad al
// valor pasado por el parmetro edad
suEdad = edad;
}

// definicin del mtodo Relinchar

// returns: void
// parmetros: No
// accin: Imprime "hiiii hiiiiii" en la pantalla
void Caballo::Relinchar()
{
std::cout << "jiiii jiiii.\n";
}

// crea un Caballo, configura su edad, hazle

// Relinchar, dino su edad, luego hazlo Relinchar de nuevo.
int main()
{
Caballo Janto;
Janto.ConfigurarEdad(5);
Janto.Relinchar();
std::cout << "Janto es un Caballo que tiene " ;
std::cout << Janto.ObtenerEdad() << " a\xa4os de edad.\n";
Janto.Relinchar();
return 0;
}

CONSTRUCTORES Y DESTRUCTORES:

SIRVEN PARA INICIALIZAR UNA VARIABLE.

LOS CONSTRUCTORES SON FUNCIONES MIEMBRO ESPECIALES.

PUEDEN TOMAR PARAMETROS PERO NO PUEDEN TENER VALOR DE RETORNO.

TIENEN QUE TENER EL MISMO NOMBRE QUE LA CLASE A LA QUE PERTENECE.

NO VALOR NOMBRE METODO PUEDE TOMAR

DE RETORNO CONSTRUCTOR IGUAL PARAMETROS
AL DE LA CLASE

CABALLO :: CABALLO (INT EDADINICIAL)

{
SUEDAD = EDADINICIAL;
}

CUANDO SE CREA UN DESTRUCTOR SE TIENE TAMBIEN QUE CREAR UN DESTRUCTOR.

LIMPIAN OBJETO Y LIBERAN RECURSOS DE LA MEMORIA

SIEMPRE NOMBRE DE LA CLASE PRECEDIDA DE UAN TILD (~).

NO TOMAN ARGUMENTOS NI TIENEN VALOR DE RETORNO.

NI VALOR MISMO NOMBRE INCLUYE LLAVES

DE RETORNO DE LA CLASE PERO NO ACCIONES
NI PARAMETROS APRECDIDO DE ~

CABALLO :: ~CABALLO()
{
}

// Demuestra la declaracin de constructores y

// destructores para la clase Caballo

#include <iostream> // para cout

class Caballo // inicia declaracin de la clase

{
public: // inicia seccin pblica
Caballo(int edadInicial); // constructor
~Caballo(); // destructor
int ObtenerEdad(); // funcin accessor
void ConfigurarEdad(int edad); // funcin accessor
void Relinchar();
private: // inicia seccin privada
int suEdad; // variable miembro
};

// constructor de Caballo
Caballo::Caballo(int edadInicial)
{
suEdad = edadInicial;
}

Caballo::~Caballo() // destructor, no incluye accin

{
}

// ObtenerEdad, Funcin pblica accessor

// devuelve el valor del miembro suEdad
int Caballo::ObtenerEdad()
{
return suEdad;
}

// Definicin de ConfigurarEdad, Funcin pblica accessor

void Caballo::ConfigurarEdad(int edad)

{
// configura la variable miembro suEdad al
// valor pasado por el parmetro edad
suEdad = edad;
}

// definicin del mtodo Relinchar

// devuelve: void
// parmetros: No
// accin: imprime "jiiiiiiii jiiiiiiiii" en pantalla
void Caballo::Relinchar()
{
std::cout << "jiiiiiiii jiiiiiii.\n";
}

// crea un caballo, configura su edad

// Relincha, dinos su edad, relincha de nuevo,
// Configura de nuevo su edad, dinos de nuevo su edad.
int main()
{
Caballo Janto(5);
Janto.Relinchar();
std::cout << "Janto es un Caballo que tiene " ;
std::cout << Janto.ObtenerEdad() << " a\xa4os de edad.\n";
Janto.Relinchar();
Janto.ConfigurarEdad(7);
std::cout << "Ahora Janto tiene " ;
std::cout << Janto.ObtenerEdad() << " a\xa4os de edad.\n";
return 0;
}