MANUAL DE C++

1. TUTORIAL DE VISUAL
C++

2. PRESENTACIÓN
• Desde Visual Studio 2012 han complicado un poco las cosas para crear un
Windows Form con Visual C++ CLR, cada versión cambian detalles que en el fondo
está bien por dentro, lo que es más difícil acceder a él.
• Se presenta un tutorial pequeño paso a paso para saber como crear un Windows
Form.

3. PRESENTACIÓN
• Observando las opiniones que he visto por Internet, si vas a usar Visual C++ CLR
que opta por la plataforma .net, mejor te centras en Visual C#.
• MFC, Win32 y ATL a parte de ser más complicado, se suele usar para tener mejor
rendimiento, kernel, driver y un largo etc, requiere más tiempo haciendo códigos.
• Si optas por hacer una interfaz sencilla para controlar dispositivos externos en el
puerto serie como microcontroladores PIC, placas de Arduino, Raspberry Pi o
cualquier otro con el protocolo RS232, mejor usar Visual C++ CLR, C# o Visual Basic
.net por su facilidad y comodidad.
• Este tipo de interfaz es bueno saber como se hace porque lo piden en algunos
centros de enseñanzas como universidades, ciclo formativos y vale incluso para
autodidactas.

4. • • Dependiendo de sus necesidades.
• El uso de CLR le proveerá a usted con la más expresiva conjunto de bibliotecas (el todo
.NET Framework), en el costo de la restricción de su archivo ejecutable para exigir el .NET
Framework para ser instalado en tiempo de ejecución, así como la limitación a la plataforma
de Windows (sin embargo, todos los 4 de los enumerados tecnologías son solo para
Windows, por lo que la limitación de la plataforma es, probablemente, el menos
problemático). Hablando de CLR, MFC, Win32 y ATL.
• Sin embargo, CLR requiere el uso de C++/CLI extensiones para el lenguaje C++, así que,
en esencia, la necesidad de aprender algo más de las características de lenguaje con el fin
de utilizar este. Al hacerlo, obtendrá muchos "extras" tales como el acceso a la .red de
bibliotecas, lleno de recolección de basura, etc.
• ATL Y MFC son un poco más complicado de decidir. Le indico a la página de MSDN para
elegir, para decidir entre ellos. Sobre ATL y MFC es que usted no necesita .NET Framework,
sólo el VC/MFC tiempos de ejecución para ser instalado para su implementación.
• El uso de Win32 directamente proporciona a los más pequeños ejecutables, con el menor
número de dependencias, pero es más trabajo para escribir código y tiempo.

5. • En esta versión he trabajado con el Sistema Operativo Windows 10 de 64 bits y
Visual Studio Community 2017.
• Enlace para descargar Visual Studio Community 2017 (Gratuito y en español).

6. HERRAMIENTAS COMUNES

7. • Puedes descargar Visual Studio Community 2017 con un ejecutable atra vez de
Internet o descargarte todo el contenido en modo local.
• Directamente la versión 2017 no cabe en un DVD.

8. • En este caso se me ha descargado el ejecutable llamado
vs_community__1822203968.1489235477. exe.
• Lo puedo instalar desde vía Web. No se puede bajar la versión en ISO ya que no
cabe en el DVD. 13/03/2017Electrónica PIC - http://electronica-pic.blogspot.com.es
11
• Aquí en adelante seguimos su procedimiento para descargarlo en local.
• En mi caso lo descargaré en la carpeta llamada VS2017_Local en la raíz, en C.
• C:VS2017_Local

9. • En este caso, en la consola CMD o símbolo de sistema de Windows ejecutamos
estos comandos.
• Accedemos donde descargamos el pequeño ejecutable y no olvidar que elegimos el
lenguaje español España en este caso –lang es-Es.
• Más información en este enlace.

10. • Vemos cuando se descarga todo en el disco duro donde le indicamos.
• Tarda un buen tiempo así que paciencia.

11. • Vamos al directorio C:VS2017_Local y ejecutamos el ejecutable.

12. • Pulsas modificar en Visual Studio Community 2017 y pasa la página siguiente para
elegir lo que queremos instalar.

13. • Elegimos las opciones indicadas.

14. • Elegimos las opciones indicadas.

15. • Cuando acabes, le das el botón Iniciar.
• Aún así, el acceso directo lo puedes encontrar en el menú de inicio de Windows.

17. VISUAL C++ 2017 CLR
• Cuando tengas Visual Studio Community 2017 ya ejecutado, creamos un proyecto nuevo.
• Archivo – Nuevo - Proyecto…
• Mirar imagen grande en la página siguiente.

18. VISUAL C++ 2017 CLR
• Le ventana Nuevo proyecto está abierta y seguimos en orden lo que indica la
imagen.
• 1) Visual C++ en Plantillas.
• 2) CLR.
• 3) Proyecto vacío de CLR.
• 4) Ponemos el nombre que queramos, en este caso lo he llamado Proyectazo.
• 5) Pulsamos Aceptar.

19. • En el “Explorador de soluciones” seleccionamos el nombre de nuestro proyecto, en
este caso Proyectazo como el primer paso.
• En la barra de herramientas Proyecto, luegoAgregar un nuevo elemento tal como
indica en la imagen de abajo.

20. • Como muestra la imagen de abajo. Cloqueamos en Visual C++ - UI y Señalamos
Windows Forms, le he añadido como nombre en el tercer paso Forma_Principal,
puedes poner cualquier nombre, al final, pulsa Aceptar.

21. • Haz clic con el botón derecho del ratón, si no aparece “Ver diseñador”, guarde el
proyecto y cierre Visual Studio Community 2017 al completo, luego vuelva a abrir.
• Ya debería verse el formulario y no solo el código fuente.
• La versión Visual Studio Community 2015 también daba otro tipo de problemas en
el cual puedes ver su propio tutorial desde la página 18 de 60.

23. • Indicamos en el “Explorador de soluciones”, hacemos clic en el botón derecho del
ratón y luego pulsamos “Propiedades”.

24. • Sigue el procedimiento indicado abajo, en Subsistema tiene que ser Windows
(/SUBSYSTEM:WINDOWS), luego pulsas aplicar.

25. • Vete a la pestaña “Avanzadas”, Punto de entrada escribes main.
• Finalmente el botón Aceptar.

26. • Escribe los códigos necesarios como muestra en la imagen, pero antes, mira la
página siguiente que se ve más grande y mejor.

28. VISUAL C++ 2017 CLR
• En la página siguiente muestra el proyecto del formulario.
• Puedes añadirle un label, cambiar de título al formulario como prueba.
• Luego pulsas F5 para compilar.

31. Operador ==
Operador +
Operador -
Operador *
Operador /
Operador %
Operador <<
Operador >>
Operador &

32. Dado que estos operadores son definidos para un tipo de datos definido por el
usuario, este es libre de asignarles cualquiera semántica que desee. Sin embargo,
se considera de primera importancia que las semánticas sean tan parecidas al
comportamiento natural de los operadores como para que el uso de los operadores
sobrecargados sea intuitivo. Por ejemplo, el uso del operador unario - debiera
cambiar el "signo" de un "valor".
Los operadores sobrecargados no dejan de ser funciones, por lo que pueden
devolver un valor, si este valor es del tipo de datos con el que trabaja el
operador, permite el encadenamiento de sentencias. Por ejemplo, si tenemos 3
variables A, B y C de un tipo T y sobrecargamos el operador = para que trabaje
con el tipo de datos T, hay dos opciones: si el operador no devuelve nada una
sentencia como "A=B=C;" (sin las comillas) daría error, pero si se devuelve un tipo
de datos T al implementar el operador, permitiría concatenar cuantos elementos
se quisieran, permitiendo algo como "A=B=C=D=...;"

33. STANDART TEMPLATE LIBRARY
(STL)
• Los lenguajes de programación suelen tener una serie de bibliotecas de
funciones integradas para la manipulación de datos a nivel más básico. En
C++, además de poder usar las bibliotecas de C, se puede usar la nativa
STL (Standard Template Library), propia del lenguaje. Proporciona una
serie plantillas (templates) que permiten efectuar operaciones sobre el
almacenado de datos, procesado de entrada/salida.

34. BIBLIOTECA DE ENTRADA Y
SALIDA
• Las clases basic_ostream y basic_stream, y los objetos cout y cin,
proporcionan la entrada y salida estándar de datos (teclado/pantalla).
También está disponible cerr, similar a cout, usado para la salida
estándar de errores. Estas clases tienen sobrecargados los operadores <<
y >>, respectivamente, con el objeto de ser útiles en la
inserción/extracción de datos a dichos flujos. Son operadores
inteligentes, ya que son capaces de adaptarse al tipo de datos que
reciben, aunque tendremos que definir el comportamiento de dicha
entrada/salida para clases/tipos de datos definidos por el usuario

35. Por ejemplo:
ostream& operator<<(ostream& fs, const Punto& punto)
{return fs << punto.x << "," << punto.y;}

36. De esta forma, para mostrar un punto, solo habría que realizar la siguiente
expresión:
//...
Punto p(4,5);
//...
cout << "Las coordenadas son: " << p << endl;
//...
Es posible formatear la entrada/salida, indicando el número de dígitos decimales
a mostrar, si los textos se pasarán a minúsculas o mayúsculas, si los números
recibidos están en formato octal o hexadecimal, etc.

37. FSTREAMS
Tipo de flujo para el manejo de ficheros. La definición previa
de ostreams/istreams es aplicable a este apartado. Existen tres clases
(ficheros de lectura, de escritura o de lectura/escritura)

38. IFSTREAM, OFSTREAM Y
FSTREAM
• (nombre_variable_fichero).open("nombre_fichero.dat/txt", ios::in); para
abrirlo en modo lectura.
(nombrevariablefichero).open("nombre_fichero.dat/txt", ios::out); para abrirlo
en modo escritura.

39. 1-Si es fichero de texto plano:
#include <fstream>
#include <string>
#include <iostream>
using namespace std;
int main() {
ifstream entrada;
entrada.open("textoPlano.txt");
string unString;
while(entrada >> unString)
cout << "Lei: " << unString << endl;
return 0;
}

40. 2-Si es un fichero binario(.dat);
nombre_variable_fichero.read((char*)&nombre_variable,
sizeof(tipo_variable));
Ejemplo:
f.read((char*)&e, sizeof(int));

41. ESCRIBIR UN FICHERO
1-Si es fichero de texto(.txt):
nombrevariable<<"texto"; donde "texto" puede ser también una variable
de cualquier tipo primitivo, o un string.
Ejemplo: f<<HOLA;

42. 2-Si es un fichero binario(.dat);
nombre_variable_fichero.write((char*)&nombre_variable,
sizeof(tipo_variable));
Ejemplo:
f.write((char*)&e, sizeof(int));
Pueden abrirse pasando al constructor los parámetros relativos a la
ubicación del fichero y el modo de apertura

43. SSTREAMS
Se destacan dos clases, ostringstream e istringstream. Todo lo anteriormente
dicho es aplicable a estas clases. Tratan a una cadena como si de un flujo de
datos se tratase. ostringstream permite elaborar una cadena de texto insertando
datos cual flujo, e istringstream puede extraer la información contenida en una
cadena (pasada como parámetro en su constructor) con el operador >>. Ejemplos:
ostringstream s;
s << nombre << "," << edad << "," << estatura << "," << punto(5,6) << endl;
cout << s.str();
istringstream s(cadena);
s >> nombre >> edad >> estatura >> p;

44. CONTENEDORES
Son clases plantillas especiales utilizadas para almacenar tipos de datos
genéricos, sean cuales sean. Todos los contenedores son homogéneos, es
decir, una vez que se declaran para contener un tipo de dato determinado,
en ese contenedor, solo se podrán meter elementos de ese tipo. Según la
naturaleza del almacenado, disponemos de varios tipos:
Vectores: Se definen por
vector<tipo_de_dato> nombre_del_vector;

45. Son arrays (o listas ordenadas) que se redimensionan automáticamente al
agregar nuevos elementos, por lo que se le pueden agregar "teóricamente",
infinitos elementos. Los vectores nos permiten acceder a cualquier
elemento que contenga, mediante el operador[]. Debe tenerse en cuenta
que si se intenta acceder a una posición que excede los límites del vector,
este no hará ningún chequeo, por lo que se debe ser cuidadoso al utilizar
este operador. Para asegurar un acceso seguro al vector, se puede utilizar
el método at(int), que lanza una excepción de tipo std::out_of_range en
caso de que esto ocurra.
Para añadir elementos al final del vector, se utiliza el método
push_back(const T&). Por otro lado, para eliminar un elemento del final del
vector, se debe usar el método pop_back().

46. #include <vector> //librería que contiene a la clase vector
#include <iostream>
using namespace std;
int main() {
vector<int> intVector; //crea un vector de enteros (sin elementos)
intVector.push_back(25); //agrega el entero 25 al vector
cout << "El primer elemento es: " << intVector.front() <<
" y mi vector tiene " << intVector.size() << " elementos." << endl; //imprime el primer
elemento, retornado por el método front()
intVector.push_back(32); //agrego el entero 32 al vector
cout << "El primer elemento es: " << intVector[0] << endl; //imprime 25
intVector.pop_back(); //elimina el último elemento del vector (i. e. 32)
cout << "Ahora tengo: " << intVector.size() << " elementos." << endl; //imprimirá 1
return 0;
}

47. Colas dobles: son parecidas a los vectores, pero tienen mejor eficiencia para agregar o eliminar
elementos en las "puntas".
deque<tipo_de_dato> nombre_de_la_cola;
Además de los métodos push_back(const T&) y pop_back(), se agregan los métodos
push_front(const T&) y pop_front(), que realizan lo mismo que los ya explicados, pero en el
comienzo de la cola.
#include <deque> //librería de deques
using namespace std;
int main() {
deque<int> intDeque;
intDeque.push_front(25);
intDeque.push_back(12);
while(intDeque.size())
intDeque.pop_back(); //borra todos los elementos
return 0;
}

48. Listas: Son eficientes a la hora de agregar elementos. La diferencia con las
colas dobles, es que son más eficientes para eliminar elementos que no
estén en alguna de las "puntas"
list<tipo_de_dato> nombre_de_la_lista;
Adaptadores de secuencia.
Contenedores asociativos: map y multimap, que permiten asociar una
"clave" con un "valor". map no permite valores repetidos, mientras que
multimap si.
map<tipo_de_llave, tipo_de_dato> nombre_del_map;
multimap<tipo_de_llave, tipo_de_dato> nombre_del_multimap

49. #include <map> //librería que contiene a map y multimap
#include <string> //librería de strings
#include <iostream> //librería de entrada/salida
using namespace std;
int main() {
map<int, string> intAString;
intAString[1] = "uno";
intAString[10] = "diez";
cout << "En intAString[1]: " << intAString[1] << endl;
cout << "En intAString[10]: " << intAString[10] << endl;
return 0;
}

50. ITERADORES
• Pueden considerarse como una generalización de la clase de "puntero". Un
iterador es un tipo de dato que permite el recorrido y la búsqueda de
elementos en los contenedores. Como las estructuras de datos
(contenedores) son clases genéricas, y los operadores (algoritmos) que
deben operar sobre ellas son también genéricos (funciones genéricas),
Stepanov y sus colaboradores tuvieron que desarrollar el concepto de
iterador como elemento o nexo de conexión entre ambos. El nuevo
concepto resulta ser una especie de punteros que señalan a los diversos
miembros del contenedor (punteros genéricos que como tales no existen
en el lenguaje).

51. ALGORITMOS
Combinando la utilización de templates y un estilo específico para denotar
tipos y variables, la STL ofrece una serie de funciones que representan
operaciones comunes, y cuyo objetivo es "parametrizar" las operaciones en
que estas funciones se ven involucradas de modo que su lectura,
comprensión y mantenimiento, sean más fáciles de realizar.
Un ejemplo es la función copy, la cual simplemente copia variables desde un
lugar a otro. Más estrictamente, copia los contenidos cuyas ubicaciones
están delimitadas por dos iteradores, al espacio indicado por un tercer
iterador.

52. La sintaxis es:
copy (inicio_origen, fin_origen, inicio_destino);
De este modo, todos los datos que están entre inicio_origen y fin_origen,
excluyendo el dato ubicado en este último, son copiados a un lugar descrito
o apuntado por inicio_destino.
Un algoritmo muy importante que viene implementado en la biblioteca STL,
es el sort. El algoritmo sort, ordena cualquier tipo de contenedor, siempre
y cuando se le pasen como argumentos, desde donde y hasta donde se
quiere ordenarlo.

53. #include <vector>
#include <deque>
#include <algorithm>
int main() {
vector<int> intVector;
intVector.push_back(60);
intVector.push_back(12);
intVector.push_back(54); //para este momento, el vector tiene 60,12,54
sort(intVector.begin(), intVector.end()); //listo, array ordenado, ahora tiene 12,54,60
/*Notar que si en vez de un vector, fuese una deque, se ordenaría de la misma manera. */
}

54. Entre las funciones más conocidas están swap (variable1, variable2), que
simplemente intercambia los valores de variable1 y variable2; max
(variable1, variable2) y su símil min (variable1, variable2), que retornan el
máximo o mínimo entre dos valores; find (inicio, fin, valor) que busca valor
en el espacio de variables entre inicio y fin; etcétera.
Los algoritmos son muy variados, algunos incluso tienen versiones
específicas para operar con ciertos iteradores o contenedores, y proveen
un nivel de abstracción extra que permite obtener un código más "limpio",
que "describe" lo que se está haciendo, en vez de hacerlo paso a paso
explícitamente.

55. • El programa o aplicacion que recibe los datos de la forma es el siguiente:
•
• #using <mscorlib.dll>
•
• #using <System.dll>
•
• #using <lcnet.dll>
•
• using namespace System;
•
• void main(){
•
• //declarando variables
•
• int base1, altura;
•
• Double area;

56. REQUISITOS PROGRAMACIÓN
INTERNET (POI)
• Para poder construir programas o aplicaciones orientadas a internet en VISUAL CPP CGI, se ocupa lo
siguiente:
• 1.- Una pc con enlace directo a internet esta pc le llamaremos servidor fisico
• 2.- El mejor editor del mundo, para crear paginas html y programas de vcpp, el NOTEPAD o WORDPAD de
windows.
• 3.- El compilador de VISUAL CPP, que se puede obtener gratis, bajandolo de www.microsoft.com/net/,
aguas son mas de 100 mb, bajarlo e instalarlo con todos los default's o comprar el visual studio net o mejor
aun vc++ net
• 4.- Una libreria especializada en obtener los datos que manda una pagina html, llamada lcnet.dll que se
puede bajar aqui www.programacionfacil.com/visualc++/lcnet.dll bajarla y ponerla dentro de el folder
(TAREAS) o directorio donde crearan todos los programas que se pediran en este curso.

57. CONDICIONES SIMPLES
• Variables
• Operadores Relacionales
• Constante o Variables
• sexo
• =
• m
• sueldo
• >
• 300,000

58. CONDICIONES COMPUESTAS
• En muchas ocasiones es necesario presentar mas de una condición para su
evaluación al computador.
• Por ejemplo que el computador muestre la boleta de un alumno si este
estudia la carrera de medicina y su promedio de calificaciones es mayor de
70.
• En muchas ocasiones es necesario presentar mas de una condicion para su evaluacion al computador.
• Por ejemplo que el computador muestre la boleta de un alumno si este estudia la carrera de medicina y su promedio de calificaciones es mayor de 70.

59. BIBLIOGRAFIAS
• https://es.slideshare.net/Metaconta2/formulario-windows-con-visual-c-2017
• 

60. FIN DEL MANUAL
• Gaitán Velázquez Maryfer
• Mena Ramírez Roberto Michell
• 2Am Programación
• D-5