Universidad CentroamericanaCarlos Eduardo DíazIng. Elsner B .González O.

Manual C/C++2016

ContenidoIntroducción.......................................................................................................................................3

Librerías del lenguaje c.......................................................................................................................4

¿Qué son exactamente las librerías?..............................................................................................5

Sintaxis para declarar Librerías en C++...........................................................................................6

Librerías Estándar de C++ (Standar Template Library o STL)..............................................7

Palabras reservadas.........................................................................................................................10

Operadores en c...............................................................................................................................11

Tipos de datos..................................................................................................................................12

Casting..............................................................................................................................................13

Ejemplo Struct Tarea1 familia.........................................................................................................14

.........................................................................................................................................................14

Como crear una variable..................................................................................................................15

Mostrar Salida de datos en C++.......................................................................................................16

Mostrar salida de datos en c............................................................................................................17

Entrada de datos en C......................................................................................................................18

Entrada de datos en C++..................................................................................................................19

Función Size of.................................................................................................................................20

Función if Else..................................................................................................................................21

Switch...............................................................................................................................................22

FOR...............................................................................................................................................23

While................................................................................................................................................24

Guia sentencias de control...............................................................................................................26

Ejercicio 1:....................................................................................................................................26

Ejercicio 2:....................................................................................................................................27

Ejercicio 3.....................................................................................................................................30

Arreglos unidimensionales...............................................................................................................31

Arreglos bidimensionales.................................................................................................................32

Struct................................................................................................................................................33

Guia estructuras...............................................................................................................................34

Struct estudiante ejem ¨PrintF¨...................................................................................................34

Struct docente ejm ¨Printf¨..........................................................................................................35

Struct empleado ejem Printf........................................................................................................36

Crear ficheros...................................................................................................................................37

Ingresar datos en un fichero............................................................................................................38

Leer datos de un fichero..................................................................................................................39

Buscar datos en un fichero...............................................................................................................40

Modificar datos en un fichero..........................................................................................................41

Funciones.........................................................................................................................................45

Tipos de variables.............................................................................................................................46

Variables globales........................................................................................................................46

Variables locales...........................................................................................................................47

Guia de ejercicios final.....................................................................................................................48

Ejercicio 1.....................................................................................................................................48

Ejercicio 2.....................................................................................................................................49

Ejercicio 3.....................................................................................................................................52

Anexos..............................................................................................................................................54

Introducción

C++ es un lenguaje de programación diseñado a mediados de los años 1980 por Bjarne Stroustrup. La intención de su creación fue el extender al lenguaje de programación C mecanismos que permiten la manipulación de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados a objetos, el C++ es un lenguaje híbrido.

Posteriormente se añadieron facilidades de programación genérica, que se sumaron a los paradigmas de programación estructurada y programación orientada a objetos. Por esto se suele decir que el C++ es un lenguaje de programación multiparadigma.

Actualmente existe un estándar, denominado ISO C++, al que se han adherido la mayoría de los fabricantes de compiladores más modernos. Existen también algunos intérpretes, tales como ROOT.

Una particularidad del C++ es la posibilidad de redefinir los operadores, y de poder crear nuevos tipos que se comporten como tipos fundamentales.

El nombre C++ fue propuesto por Rick Mascitti en el año 1983, cuando el lenguaje fue utilizado por primera vez fuera de un laboratorio científico. Antes se había usado el nombre "C con clases". En C++, la expresión "C++" significa "incremento de C" y se refiere a que C++ es una extensión de C.

Librerías del lenguaje c

Junto con los compiladores de C y C++, se incluyen ciertos archivos llamados bibliotecas mas comúnmente librerías. Las bibliotecas contienen el código objeto de muchos programas que permiten hacer cosas comunes, como leer el teclado, escribir en la pantalla, manejar números, realizar funciones matemáticas, etc.

Las bibliotecas están clasificadas por el tipo de trabajos que hacen, hay bibliotecas de entrada y salida, matemáticas, de manejo de memoria, de manejo de textos y como imaginarás existen muchísimas librerías disponibles y todas con una función especifica.

Nota: Existe una discusión sobre el nombre de estos archivos. Muchos personas consideran que el nombre adecuado es archivos de biblioteca, y estan en lo correcto. Sin embargo, la mayoría llamamos a estos archivos librerías, y también me incluyo entre estos. El error proviene del nombre en inglés, que es library. Este término se traduce como biblioteca, y no como librería. De este modo a lo largo de esta sección las llamaré de cualquiera de las dos formas, para estár mas claros.

Hay un conjunto de bibliotecas (o librerías) muy especiales, que se incluyen con todos los compiladores de C y de C++. Son las librerías (o bibliotecas) ANSI o estándar. También hay librerías que no son parte del estándar pero en esta sección sólo usaremos algunas bibliotecas (o librerías) ANSI.

Nota 2: Sé que esto pinta aburrido, pero es muy útil y realmente las libreróas nos facilitan enormemente el trabajo de programar. Recuerda que antes de hablar librerías y demás es necesario dominar algunos conceptos de fundamentación en general y otros temas importantes (ciclos, condicionales y demás) Ahora veamos algunas librerías y como es su sintaxis.

¿Qué son exactamente las librerías?

En C++, se conoce como librerías (o bibliotecas) a cierto tipo de archivos que podemos importar o incluir en nuestro programa. Estos archivos contienen las especificaciones de diferentes funcionalidades ya construidas y utilizables que podremos agregar a nuestro programa, como por ejemplo leer del teclado o mostrar algo por pantalla entre muchas otras más.

Al poder incluir estas librerías con definiciones de diferentes funcionalidades podremos ahorrarnos gran cantidad de cosas, imaginemos por ejemplo que cada vez que necesitemos leer por teclado, debamos entonces crear una función que lo haga (algo realmente complejo), al poder contar con las librerías en C++, podremos hacer uso de una gran variedad de funciones que nos facilitaran la vida y aumentarán la modularidad de nuestros códigos.

Las librerías no son únicamente archivos externos creados por otros, también es posible crear nuestras propias librerías y utilizarlas en nuestros programas. Las librerías pueden tener varias extensiones diferentes, las más comunes son: .lib, .bpl, .a, .dll, .h y algunas más ya no tan comunes.

En conclusión: Las librearías son archivos (no siempre externos) que nos permiten llevar a cabo diferentes tareas sin necesidad de preocuparnos por cómo se hacen sino simplemente entender cómo usarlas. Las librearías en C++ permiten hacer nuestros programas más modulares y reutilizables, facilitando además crear programas con funcionalidades bastante complejas en unas pocas líneas de código.

Sintaxis para declarar Librerías en C++

La declaración de librerías, tanto en C como en C++, se debe hacer al principio de todo nuestro código, antes de la declaración de cualquier función o línea de código, debemos indicarle al compilador que librerías usar, para el saber que términos estaran correctos en la escritura de nuestro código y cuáles no. La sintaxis es la siguiente: #include <nombre de la librería> o alternativamente #include "nombre

de la librería". Cualquiera de las 2 formas es válida en C++ (no estoy seguro si en C sea válido), ten en cuenta que siempre el nombre de la librería debe ir entre " y " o entre < y >. En tu código puedes declarar todas las librerías que quieras aunque en realidad no tienen sentido declarar una librería que no vas a usar en tu programa, sin embargo no existe límite para esto.

Librerías Estándar de C++ (Standar Template Library o STL)

A continuación pondré algunas de las librerías de uso más común de C++ y que forman parte de las librerías estandar de este lenguaje.

fstream:

Flujos hacia/desde ficheros. Permite la manipulación de archivos desde el programar, tanto leer como escribir en ellos.

iosfwd:

Contiene declaraciones adelantadas de todas las plantillas de flujos y sus typedefs estándar. Por ejemplo ostream.

iostream:

Parte del a STL que contiene los algoritmos estándar, es quizá la más usada e importante (aunque no indispensable).

La biblioteca list:

Parte de la STL relativa a contenedores tipo list; listas doblemente enlazadas

math:

Contiene los prototipos de las funciones y otras definiciones para el uso y manipulación de funciones matemáticas.

memory:

Utilidades relativas a la gestión de memoria, incluyendo asignadores y punteros inteligentes (auto_ptr).

"auto_ptr" es una clase que conforma la librería memory y permite un fácil manejo de punteros y su destrucción automaticamente.

Biblioteca new:

Manejo de memoria dinámica

numeric:

Parte de la librería numérica de la STL relativa a operaciones numéricas.

ostream:

Algoritmos estándar para los flujos de salida.

queue:

Parte de la STL relativa a contenedores tipo queue (colas de objetos).

Librería stdio:

Contiene los prototipos de las funciones, macros, y tipos para manipular datos de entrada y salida.

Librería stdlib:

Contiene los prototipos de las funciones, macros, y tipos para utilidades de uso general.

string:

Parte de la STL relativa a contenedores tipo string; una generalización de las cadenas alfanuméricas para albergar cadenas de objetos. Muy útil para el fácil uso de las cadenas de caracteres, pues elimina muchas d elas dificultades que generan los char

typeinfo:

Mecanismo de identificación de tipos en tiempo de ejecución

vector:

Parte de la STL relativa a los contenedores tipo vector; una generalización de las matrices unidimensionales C/C++

forward_list

Esta librería es útil para implementar con gran facilidad listas enlazadas simples.

list

Permite implementar listas doblemente enlzadas (listas enlazadas dobles) facilmente.

iterator

Proporciona un conjunto de clases para iterar elementos.

regex

Proporciona fácil acceso al uso de expresiones regulares para la comparación de patrones.

thread

Útil para trabajar programación multihilos y crear múltiples hilos en nuestra aplicación.

Palabras reservadas

Operadores en c

Tipos de datos

Casting

Ejemplo Struct Tarea1 familia Ejm:

Como crear una variable

1. Se le da el tipo de valor a la variable ya sea (decimal, entero etc.)2. se escribe el identificador de la variable ejm ManualCarlos3. se le asigna un valor entero ejm=4204. se escribe punto y coma para terminar la línea de código

Ejm:

Mostrar Salida de datos en C++1. Se escribe cout para comenzar una salida 2. Se agrega << 3. Entre comilla se escribe el mensaje a mostrar en pantalla ejm: “Hola”4. Se agrega nuevamente <<5. Escribimos endl y un punto y coma para terminar el código de salida

Ejm

Mostrar salida de datos en c1. Se agrega la librería stdio.h ejm: #include <stdio.h>.2. Se escribe Printf y se abre paréntesis ejm: Printf ().3. Dentro de los paréntesis se escribe comilla y se escribe el mensaje que quiere mostrar a

continuación ejm: Printf (“Hola”)4. Por último se escribe punto y coma al final para terminar la línea de código y se ejecuta.

Entrada de datos en C

1. Se prepara una variable donde se almacenara el dato a guardar ejm: float numero;2. Se hace la pregunta del dato a ingresar en c o c++ (Printf, Cout)3. Se escribe scanf y se abre paréntesis.4. Entre comillas se escribe el tipo de dato de entrada con un porcentaje y el tipo de dato

ejm: scanf (“ %f ”). en este caso es f porque la variable es tipo float Tipos de datos con scanf pag 16. se escribe una coma y la variable donde se almacenara el dato ejm: scanf (“ %f ”, numero)

5. Se termina la línea con un punto y coma y listo ejm: scanf (“ %f ”, numero);

Entrada de datos en C++ 1. Escribimos un mensaje con la función de cout y le solicitamos al usuario la información

solicitada2. Escribimos en una nueva línea de código cin y escribimos >>3. Escribimos la variable donde vamos almacenar los datos y la cerramos con un punto y

comaEjm:

Función Size of 1. al final de un mensaje de salida escribimos sizeof 2. escribimos entre paréntesis el tamaño deseado ejm (char)3. escribimos <<endl; para terminar la línea de código

Ejm

Función if Else 1. Escribimos la pregunta o la condición y la respuesta se la asignamos a una variable2. Para comenzar el if else escribimos if entre paréntesis la condición y abajo entre

llaves la salida 3. Escribimos en una nueva línea else y abrimos llaves y escribimos la salida de datos

si la condición es falsa Ejm:

Switch

1. Se declara una variable que guarde la opción a elegir ejm: int opc;2. Se pregunta al usuario la opción con un cout o printf3. Se escribe switch y entre paréntesis la variable ejm: switch (opc)4. Se escribe llaves y se escribe case y al lado de case la opción por ejemplo si fuera uno la

opc del case entraría al case 1: y se escribe asi hasta tener todos los case de las opciones planteadas

5. Se llenan los cases con lo que va a hacer cada opción o llamar a funciones 6. Y se agrega un default por si el usuario selecciona una opción incorrecta

FOREs una estructura de control en programación en la que se puede indicar de antemano el número mínimo de iteraciones que la instrucción realizará

Sintaxis

for(inicialización del bucle; condición; incremento);

While Tiene cierta semejanza con el bucle for, así es en el uso de una inicialización, una condición y un incremento. Otra de sus similitudes es el momento en el que analizan la condición que en ambos es antes de ejecutar el bucle.

Sintaxis

While ( condición )

{

Sentencias;

Incremento;

}

Guia sentencias de control

Ejercicio 1:

Ejercicio 2:

Ejercicio 3

Arreglos unidimensionales

1. Al momento de declarar una variable se le da un valor de tamaño entre Corchetes que eso representara el tamaño dado en memoria

2. Declaramos la variable por ejm en int (entero) 3. Le damos un identificador a la variable ejm: X4. Y abrimos los corchetes y le damos el tamaño ejm [5]

Arreglos bidimensionales

1. Se declara una variable de cualquier tipo por ejemplo int y se le da un identificador por ejemplo hello

2. Se le da el tamaño de elementos por ejmplo [5] 3. Este identificador será = a {1,2,3,4,5} que conformarían todos los elementos llamados

índice 4. Y a los índices se les da cualquier valor por ejemplo={32,27,64,18,95};

Ejm:

Struct 1. Se escribe struct ósea el nombre de la función es recomendable hacer esta función antes

del main2. Se da enter y se abre llave{}3. Ahora escribimos variables dentro de struct de todo tipo y cualquier identificador4. Afuera de la ultima llave le damos un identificador a toda esa estructura } Estructura;5. Ahora solo la llamamos a imprimir como el nombre de la estructura. y el identificador

Ejm:

Guia estructuras

Struct estudiante ejem ¨PrintF¨

Struct docente ejm ¨Printf¨

Struct empleado ejem Printf

Crear ficheros 1. Se escribe FILE * fichero (osea el nombre del fichero)2. Se asigna una variable donde se va a guardar el fichero ejm: fichero=3. Se escribe el nombre del fichero y se asigna el nombre y el tipo ejm: (“violento”, “a”)4. Con un if else se valora si el fichero se creo 5. Cerramos el fichero con un fclose y el nombre del fichero ejm fclose(fichero);

Ingresar datos en un fichero

1. Se abre el fichero en modo lectura y escritura: fichero = fopen("violento", "a+");2. Se solicita el dato a guardar ejm: printf("\n Ingrese el codEmpleado: ");3. Se usa un fflush con stdin ejm: fflush(stdin);4. Se usa un scanf o un cout para ingresar los datos5. En mi caso se usa un scanf con el nombre de la estructura donde vas a guardar los datos

ejm: scanf (" %f ", &registro.sueldo);6. Se usa un fwrite para escribir los datos con su respectivo paréntesis nombre de la

estructura original ejm: &registro 7. Luego una coma y se ejecuta un sizeof de la estructura declarada se cierran los paréntesis

y se escribe una coma y un uno para que vaya con paso de uno y el nombre del fichero, ejm: fwrite(&registro, sizeof(struct sRegistro), 1, fichero);

8. Se cierra el fichero con un fclose ejm: fclose (fichero);

Leer datos de un fichero

1. Se abre el fichero en modo lectura ejm: fichero = fopen("violento", "r");2. Opcional: se usa un if else para verificar si el fichero existe ejm: if(fichero==NULL)

{ printf("\n archivo violento no existe!!!"); return;3. se usa un fread y se abren paréntesis se manda a llamar la estructura original y coma ejm:

&registro,4. se agrega un sizeof de la estructura declarada se cierran los paréntesis del sizeof y se pone

un uno y el nombre del fichero ejm : fread(&registro, sizeof(struct sRegistro), 1, fichero);5. se agrega un printf o un cout con el identificador de la salida de datos con tabuladores y

saltos de línea ejm: printf("\n \t Numero \t Nombre \t\t Edad \t\t Sueldo \n");6. se escribe un while con un ¡feof y el nombre del fichero ejm: while(!feof(fichero))7. se escribe un printf con cada tipo de dato y tabuladores y la estructura con la variable

donde se guardaron los datos ejm : printf("\n \t %d \t\t %s \t\t %d \t%.2f \n", registro.codigo, registro.nombre, registro.edad, registro.sueldo);

8. se usa un fread con el nombre de la estructura, un sizeof de la estructura declarada con un paso de uno y el nombre del fichero ejm: fread(&registro, sizeof(struct sRegistro), 1, fichero);

9. se cierra el fichero con un fclose ejm: fclose(fichero);10. se usa un system (“Pause”) para que espere pantalla

Buscar datos en un fichero

1. Se abre el fichero en modo lectura y se valida si existe ejm: fichero = fopen ("violento", "r"); if(fichero==NULL) { Printf ("\n archivo violento no existe!!!"); return; }

2. Se abre la estructura original y se le declara un temporal por ejemplo: struct sRegistro reg1;

3. Se declara una variable de código temporal ejm: int codTemp =0;4. Se le pregunta al usuario el código del dato que quiere buscar y un scanf con el código

temporal ejm: printf("Digite el código del empleado que desea buscar: "); scanf("%d", &codTemp);

5. Se usa un rewind del fichero con un while tipo ¡feof del nombre del fichero ejm: rewind(fichero); while (!feof(fichero))

6. Se usa un fread del código temporal con la estructura original con un paso de uno en el registro y se usa un if para comparar el código temporal con el original del fichero y así mostrar los datos y se cierra con un fclose ejm: fread (&reg1, sizeof (sRegistro),1,fichero); if(reg1.codigo==codTemp) { printf("CodEmpleado: %d \n", reg1.codigo); Printf ("Empleado: %s \n",reg1.nombre); Printf ("Edad: %d \n",reg1.edad); Printf ("Sueldo: %.2f \n",reg1.sueldo); break;

Modificar datos en un fichero

1. Se declara un bool de una variable por ejm encontrado a falso ejm: bool encontrado = false;

2. Se declara un cod en int ejm: int codEmp =0; y se crea un archivo temporal y se declara la estructura de datos con un temporal ejm: int codEmp =0; FILE *archivoTemp; struct sRegistro reg;

3. Se abre el fichero con del archivo temporal en modo a+ y se abre el archivo de los datos en modo lectura ejm: archivoTemp = fopen("temporal.txt", "a+"); fichero = fopen("violento", "r");

4. Se hace una validación si los archivos se abrieron correctamente con un if : if(archivoTemp==NULL && fichero==NULL) { printf("Error al abrir los archivos!!!"); }

5. Se usa un fflush y se pregunta el codigo o identificador del dato que desea modificar y un fread para que pueda guardar ese codigo en la estructura declarada a inicios

Ejm: fflush(stdin); printf("Archivos abiertos con exito!!! \n"); system("PAUSE"); system("cls"); printf("Ingrese el codigo del Empleado que desea modificar: "); scanf("%d", &codEmp); rewind(fichero); fread(&reg,sizeof(sRegistro),1,fichero);

6. se usa un while con un feof del fichero y se manda a mostrar los datos encontrados con una validación de un if while (!feof(fichero)) { if(codEmp==reg.codigo) { encontrado = true; fflush(stdout); printf("--------------------------------- \n"); printf("CodEmpleado: %d \n", reg.codigo); printf("Empleado: %s \n",reg.nombre); printf("Edad: %d \n",reg.edad); printf("Sueldo: %.2f \n",reg.sueldo); printf("--------------------------------- \n");

7. se manda a preguntar con una salida de datos que se quiere modificar y un switch para seleccionar el dato adecuado a modificar ejm: int opc=0; fflush(stdin); printf("Ingresa una opcion segun el campo que desea modificar. \n"); printf("1: Para modificar el nombre. \n"); printf("2: Para modificar la edad. \n"); printf("3: Para modificar el sueldo. \n"); printf("opcion: "); scanf("%d", &opc);

switch(opc)

{ case 1: { fflush(stdout); printf("Digite el nuevo nombre: \n"); fflush(stdin); gets(reg.nombre); break; } case 2: { fflush(stdout); printf("Digite la nueva edad: \n"); fflush(stdin); scanf("%d", &reg.edad); break; } case 3: { fflush(stdout); printf("Digite el nuevo sueldo: \n"); fflush(stdin); scanf("%f", &reg.sueldo); break; } default: printf("Digite una opcion valida!!!"); break;

8. se usa un fwrite de la estructura declarada al inicio con un size of de la estructura original con un paso de uno en el fichero del archivo temp : fwrite(&reg, sizeof(struct sRegistro), 1, archivoTemp); printf("Registro Modificado!!! \n");

9. y se usa una validación si el registro no existe ejm:

else { fwrite(&reg, sizeof(struct sRegistro), 1, archivoTemp); } fread(&reg,sizeof(sRegistro),1,fichero); }

if(encontrado == false)

{ printf("Registro no encontrado!!! \n"); } }

10. se cierran los archivos ejm:

fclose(archivoTemp); fclose(fichero);

remove("violento"); rename("temporal.txt", "violento");

Funciones 1. se escribe el tipo de función que vaya a ser por ejm Void y el nombre de la función ejm:

Void Menu y se abren paréntesis

2. las paréntesis son para los argumentos o variables que va a exportar 3. se escribe lo que va hacer la función entre llaves 4. luego puedes invocar la función es switch o en el int main depende para que lo vayas a

usar

Tipos de variables

Variables globalesEstas variables son las que se invocan afuera del main normalmente crean líneas después del std namespace estas variables sirven para todo el programa y se pueden usar en cualquier función etc

Ejm:

Variables localesEstas variables solo son declaradas en un mismo menú o función ya que estas variables solo se pueden utilizar donde se declararon por ejemplo: int cantidad dentro del main.

Estas variables no pueden ser utilizadas en otras funciones a menos que se declare igual

Guia de ejercicios final

Ejercicio 1Dado como dato el sueldo de un trabajador, considere un aumento del 15% si su sueldo es inferior a 1000 y de un 12% en caso contrario. Imprima el sueldo con el aumento incorporado.

Ejercicio 2Dado como datos la matrícula de un alumno, el semestre en el que está inscrito, y promedio, determine si el mismo es apto para pertenecer alguna de las profesiones que tiene la universidad. Si el alumno es aceptado teniendo en cuenta las especificaciones que se listan abajo se debe imprimir su matrícula, carrera y la palabra “Aceptado”

Ingeniería Semestre >  6  y Promedio >= 8.8Medicina Semestre >=6  y Promedio >  8.5Licenciatura Semestre >  5  y Promedio >=8.3Técnico Semestre >=3  y Promedio >=7.8

Ejercicio 3

En una tienda efectúan un descuento a los clientes dependiendo del monto de la compra. El descuento se efectúa con base en el siguiente criterio.

Si el monto es menor que 500 no hay descuentoSi el monto está comprendido entre 500 y 1000 inclusive, el desc es de 5%Si el monto está comprendido entre 1000 y 7000 inclusive, el desc es del 11%Si el monto está comprendido entre 7000 y 15000 inclusive, el desc es del 18%Si el monto es mayor de 15000 el desc es del 25%