UNIVERSIDAD NACIONAL DE CHIMBORAZO

FACULTAD DE INGENIERIA

ESCUELA DE INGENIERA EN SISTEMS Y

COMPUTACIN
PROGRAMACION II
TEMA:
RELACIONES CON CLASES
SEMESTRE:
TERCER SEMESTRE
AUTOR:
SANTIAGO MORENO

Tabla de contenido
1. RESUMEN....................................................................................................................3
2. INTRODUCCION.........................................................................................................4
3. DESARROLLO TEMATICO........................................................................................5
3.1 PUNTOS DE ENTRADA.......................................................................................5
3.2 ARGUMENTOS Y PARAMETROS.......................................................................5
3.3 C++ 11.....................................................................................................................5
3.3.1 TIPOS FUNDAMENTLES..............................................................................6
3.3.2 ENUMERACIONES........................................................................................6
3.3.3 CLASES Y ESTRUCTURAS..........................................................................8
3.4 FUNCIONES Y CLASES.......................................................................................8
3.4.1 DECLARACIONES VS DEFINICIONES......................................................8
3.4.2 FUNCIONES....................................................................................................8
3.4.3 FUNCIONES MIEMBRO................................................................................9
3.4.4 NIVELES DE PROTECCIN Y ESPECIFICADORES DE ACCESO..........9
3.4.5 ARCHIVOS ENCABEZADOS PRECOMPILADOS...................................10
3.5 OVERWIDE (CONSTRUCTORES, DESTRUCTORES Y OPERADORES).....10
3.5.1 CONSTRUCTORES PARAMETRIZADOS.................................................11
3.5.2 CONSTRUCTORES DE CONVERSIN.....................................................11
3.6 PLANTILLAS.......................................................................................................11
3.6.1 FUNCIONES DE PLANTILLAS..................................................................11
4. CONCLUSIONES.......................................................................................................12
5. BIBLIOGRAFIA.........................................................................................................12

1. RESUMEN
El libro C++ SUCCINCTLY ayuda a aprender todas
las piezas fundamentales de C ++ para que pueda
entender los proyectos y muestras escritas en C ++
y comenzar a escribir sus propios programas en C +
+.
Adems ayudara en la comprensin de las distintas
funciones y cdigo del programa Visual Studio 12.

2. INTRODUCCION
Este ensayo est basado en el libro C++
SUCCINCTLY que fue escrito para ayudar a los
desarrolladores profesionales de c #, para
a
aprender lenguaje c ++ de programacin moderno.
El objetivo de este libro es el de aprovechar su
conocimiento en C# existente con el fin de ampliar
sus conocimientos.

3. DESARROLLO TEMATICO
3.1 PUNTOS DE ENTRADA
En C #, el punto de entrada de un programa es un mtodo esttico
llamado MAIN. A menudo no se ve desde distintos marcos (por
ejemplo, Silverlight), pero est ah, en alguna parte, ya que sin ella el
sistema operativo no sabra por dnde empezar la ejecucin de su
programa.
El punto de entrada de un programa en C ++ es la funcin MAIN. Una
versin simple se ve as:
int main(int argc, char* argv[])
{
// Your program starts here.

// Returning 0 signifies success.

return 0;

3.2 ARGUMENTOS Y PARAMETROS

Un argumento es un valor que se pasa a una funcin cuando se le
llama en un programa, mientras que un parmetro es parte de la
especificacin de una funcin que le dice al programador la funcin
espera para recibir un valor de un tipo determinado. Tambin le indica
al programador cmo podra tratar ese valor.
Un parmetro normalmente proporciona un nombre por el que ese
valor se puede hacer referencia, aunque C ++ nos permite ofrecer
slo un tipo se est obligado a tener un parmetro en particular.

3.3 C++ 11
En 2011, una nueva versin principal estndar del lenguaje C ++ fue
adoptada por el grupo de trabajo de ISO / IEC responsable del diseo
y desarrollo de C ++ como lenguaje. En comparacin con C ++ 98 y
C ++ 03, C ++ 11 se siente como un idioma diferente. Debido a que
C ++ 11 es tan nuevo, no existen compiladores que apoyan todas las
caractersticas individuales, y hay algunos que apoyan menos que
otros. Visual C ++ y las caractersticas que implementa en su versin
ms actual, aunque se a mencionado algunas caractersticas que
Visual C ++ no soporta actualmente y lo han sealado.

3.3.1 TIPOS FUNDAMENTLES

C ++ contiene las mismas palabras que C# por ejemplo int. Esto no
es sorprendente dado que ambos son lenguajes de programacin
como C. Mientras que C # define los tamaos de los tipos
fundamentales (un corto es un entero de 16 bits, un int es un entero
de 32 bits, una larga es un entero de 64 bits, un doble es una de 64
bits de doble precisin IEEE 754 flotante nmero de punto, etc.), C +
+ no hace tales garantas.
La unidad fundamental ms pequea de C ++ es char, que slo
necesita estar en implementaciones menos lo suficientemente grande
para contener los 96 caracteres bsicos que el C ++ estndar,
adems de los otros personajes de idiomas con caracteres bsicos de
la ejecucin. En teora, alguna aplicacin de C ++ se podra definir
como un char de 7 bits o mltiples C ++ de 16 bits.
3.3.2 ENUMERACIONES
Las enumeraciones son bastante similares entre s en C ++ y C #. C
++ tiene dos tipos de enumeraciones: con mbito y un-con mbito.
Una enumeracin de mbito se define como una clase enum o un
struct enum. No hay ninguna diferencia entre los dos. Una
enumeracin de las Naciones Unidas con mbito se define como una
enumeracin llanura. Un ejemplo:
#include <iostream>
#include <ostream>
#include <string>
#include "../pchar.h"
enum class Color
{
Red,
Orange,
Yellow,
Blue,
Indigo,
Violet
};
// You can specify any underlying integral type you want, provided it fits. enum
Flavor : unsigned short int
{
Vanilla,
Chocolate,
Strawberry,
Mint,

};
int _pmain(int /*argc*/, _pchar* /*argv*/[])
{
Flavor f = Vanilla;
f = Mint; // This is legal since the Flavor enum is
an un-scoped enum.
Color c = Color::Orange;
//c = Orange; // This is illegal since the Color enum is a scoped enum.
std::wstring flavor;
std::wstring color;
switch (c)
{
case Color::Red:
color = L"Red";
break;
case Color::Orange:
color = L"Orange";
break;
case Color::Yellow:
color = L"Yellow";
break;
case Color::Blue:
color = L"Blue";
break;
case Color::Indigo:
color = L"Indigo";
break;
case
Color::Violet:
color = L"Violet";
break;
default:
color = L"Unknown";
break;
}
switch (f)
{
case Vanilla:
flavor = L"Vanilla";
break;

case Chocolate:
flavor = L"Chocolate";
break; case Strawberry:
flavor = L"Strawberry";
break; case Mint:
flavor = L"Mint";
break; default:
break;
}
std::wcout << L"Flavor is " << flavor.c_str() << L" (" << f <<
L").
Color is " << color.c_str() << L" (" <<
static_cast<int>(c) << L")."
<< std::endl <<
L"The size of Flavor is " << sizeof(Flavor) <<
L"." << std::endl <<
L"The size of Color is " << sizeof(Color) <<
L"." << std::endl;

return 0;

3.3.3 CLASES Y ESTRUCTURAS

La diferencia entre una clase y una estructura en C ++ es
simplemente que de una estructura miembros defecto pblica
mientras que un defecto miembros de la clase a la privada. Eso es
todo. Ellos son por lo dems la misma. No hay de tipo valor versus
tipo de referencia distincin existe en C #.
Normalmente se vern programadores que utilizan clases de tipos
complejos (combinaciones de datos y funciones) y estructuras de
simples datos de slo tipos. Normalmente, se trata de una eleccin
estilstica que representa los orgenes no orientados a objetos de
estructura en C, por lo que es fcil de diferenciar rpidamente entre
un contenedor de datos simple frente a un objeto en toda regla
mirando para ver si se trata de una estructura o una clase.

3.4 FUNCIONES Y CLASES

3.4.1 DECLARACIONES VS DEFINICIONES

En C #, clases y otros tipos se declaran y se definen al mismo tiempo.

Incluso con la palabra clave parcial, la definicin de clase es
simplemente permitir que se extienda a travs de mltiples archivos;
no cambia la combinacin de la declaracin y definicin. La nica
excepcin a esta regla es cuando haciendo de inter operabilidad . En
ese caso, la definicin no est en C #.
3.4.2 FUNCIONES
Hay dos tipos de funciones en C ++: independientes funciones y las
funciones miembro. La principal diferencia entre ellos es que una
funcin miembro pertenece a una clase, estructura o unin, mientras
que una funcin independiente no lo hace.
Funciones autnomas son los tipos ms bsicos de funciones. Ellos
pueden ser declarados en los espacios de nombres, que pueden ser
sobrecargados, y pueden ser en lnea. Ejemplo:
#pragma once
namespace Utility
{
inline bool IsEven(int value)
{
return (value % 2) == 0;
}
inline bool IsEven(long long value)
{
return (value % 2) == 0;
}
void PrintIsEvenResult(int value);
PrintIsEvenResult(long long value);

void

void PrintBool(bool value);

}

3.4.3 FUNCIONES MIEMBRO

Las funciones miembro son parte de una clase, estructura o unin.
Funciones miembro estticas pueden llamar a otras funciones
miembro de clase esttico, independientemente del nivel de
proteccin.
Funciones miembro estticas tambin pueden tener acceso a datos
de los miembros de clase estticos ya sea explcitamente (es decir
SomeClass :: SomeFloat = 20.0f;) o implcitamente (es decir
SomeFloat = 20.0f;), independientemente del nivel de proteccin.

3.4.4 NIVELES DE PROTECCIN Y ESPECIFICADORES DE ACCESO

Las funciones miembro y datos de los miembros tienen tres posibles
especificadores de acceso:

public
protected
private

Estos especificadores de acceso denotan el nivel de accesibilidad que

el miembro tiene.
#include <string>
class SomeClass
{ publi
c:
SomeClass(void);
virtual
~SomeClass(void);
int
AddTwoInts(int, int);
void
StoreAString(const
wchar_t*);
private:
bool
CheckForIntAdditionOverflow(int,
int); public:
int
SomePublicInteger;
protected:
std::wstring
m_storedString;
};
3.4.5 ARCHIVOS ENCABEZADOS PRECOMPILADOS
Un archivo de encabezado pre compilado es un tipo especial de
archivo de cabecera. Al igual que un archivo de cabecera normal, que
puede pegar ambos incluyen declaraciones y definiciones de cdigos
en el mismo. Lo que hace diferente es ayuda para acelerar los
tiempos de compilacin.
El encabezado pre compilado se compilar la primera vez que
construye su programa. A partir de entonces, siempre y cuando no
haga cambios en el encabezado pre compilado, o para cualquier cosa
incluidos directa o indirectamente en el encabezado pre compilado.

3.5
OVERWIDE
OPERADORES)

(CONSTRUCTORES,

DESTRUCTORES

En C ++ los constructores son ms complicados que en C #. Ya que

hay cinco tipos de constructores. Se necesita saber lo que son, lo que
hacen, y lo que parecen. Si no, usted podra encontrarse frente a
algunos errores muy confusas o errores del compilador.
Aqu un ejemplo:
Vehicle someVehicle = vehicle;
Un constructor por defecto se puede llamar sin argumentos. Una
clase no puede tener ms de un constructor por defecto si se define
una clase e incluir ningn constructor. Sin embargo, si se tiene una
variable miembro de la clase que es una clase,
Si define un constructor sin parmetros, es un constructor
predeterminado explcito. Tambin es posible definir un constructor
que toma parmetros y todava lo hacen un constructor por defecto
usando argumentos por defecto, lo que vamos a discutir en un
momento.
Si define un constructor que tiene al menos un parmetro requerido,
el compilador no generar un constructor. Debe definir un constructor
predeterminado explcito si quieres uno.
Los constructores pueden tener argumentos predeterminados para
algunos o todos sus parmetros como parte de su declaracin. En
funciones de C ++, todos los parmetros con los argumentos por
defecto deben ocurrir a la derecha de cualquier parmetro sin un
argumento por defecto en la declaracin de la funcin. C ++ no
soporta C # -estilo argumentos con nombre, pero se puede lograr
algo similar utilizando el parmetro de idioma llamado.
3.5.1 CONSTRUCTORES PARAMETRIZADOS
Un constructor parametrizado tiene uno o ms parmetros. Un
constructor parametrizado donde todos los parmetros tienen
argumentos por defecto es tambin el constructor por defecto para
una clase. No hay nada especial acerca de constructores
parametrizados en C ++.
3.5.2 CONSTRUCTORES DE CONVERSIN

Un constructor de conversin tiene al menos un parmetro. Si hay

ms de uno, entonces esos parmetros adicionales deben tener
argumentos por defecto.

3.6 PLANTILLAS
Las plantillas tienen un propsito en C ++ asi como tambin en C #.
Ellos le permiten reutilizar el cdigo sin necesidad de escribir una
funcin o clase para cada variante que desee.
En ltima instancia, las plantillas pueden llegar a ser muy complejo.
La biblioteca estndar C ++ demuestra el poder y la complejidad de
las plantillas avanzadas. A pesar de ello, no es necesario un
conocimiento avanzado de plantillas para usar de manera efectiva. La
comprensin de los fundamentos de las plantillas de C ++ le ayudar
a desbloquear una cantidad significativa de funcionalidad y poder.
3.6.1 FUNCIONES DE PLANTILLAS
Una plantilla de funcin es una funcin independiente que toma por lo
menos un parmetro de plantilla. El hecho de que toma un argumento
hace que sea incompleta hasta que se llama con un argumento
concreto, provocando de esta manera la plantilla para convertirse en
una funcin totalmente definido. Aqu est una funcin de plantilla
que tiene en dos argumentos.
#pragma once
template<class
T,
class U>
U PeekLastItem(T& collection)
{
return *collection.rbegin();
}

4. CONCLUSIONES
El presente trabajo realizado dio conocer sobre la importancia de la
programacin en C++.Adems que ayudo en la comprensin de
Visual Studio 12 y fortalecer nuestros conocimientos en nuestra
carrera.

5. BIBLIOGRAFIA
LIBRO C++ SUCCINCTLY
AUTOR MICHAEL B. MCLAUGHLIN
EDITORIAL SYNCFUSION