Manual de Programacion 1, realizado por Allan Gabriel Fuentes Vanegas.

1. UNIVERSIDAD CENTROAMERICANA
Manual de C/C++
Allan Gabriel Fuentes Vanegas
Lic. Elsner González
25/08/2016

2. Contenido
I. Introducción:..............................................................................................................................3
II. Lenguajes de programación: ........................................................................................................4
1. Lenguaje C..............................................................................................................................4
2. Lenguaje C++...........................................................................................................................4
III. Tipo de datos:.........................................................................................................................5
1. Tipo entero:............................................................................................................................5
2. Tipo real:.................................................................................................................................5
3. Tipo caracter:..........................................................................................................................5
4. Tipo cadena:............................................................................................................................5
IV. Palabras reservadas:................................................................................................................6
1. Palabras compartidas por ambos lenguajes...............................................................................6
2. Palabras pertenecientes a C++..................................................................................................6
3. Palabras alternativas................................................................................................................7
V. Declaración de variables:.............................................................................................................8
VI. Sintaxis:..................................................................................................................................9
I. El punto y coma:......................................................................................................................9
II. Espacios y tabulaciones:...........................................................................................................9
VII. Sentencias de control:............................................................................................................10
1. If-else:...................................................................................................................................10
2. While:...................................................................................................................................10
3. Do-while:..............................................................................................................................10
4. For:.......................................................................................................................................10
5. Switch:..................................................................................................................................10
VIII. Arreglos:...............................................................................................................................11
1. Arreglos Unidimensionales:....................................................................................................11
2. Arreglos Bidimensionales:......................................................................................................11
IX. Estructuras:...........................................................................................................................12
X. Ficheros:...................................................................................................................................13
XI. Printf/Scanf:..........................................................................................................................14
XII. Bibliotecas:...........................................................................................................................15
XIII. Ficheros:...............................................................................................................................16

3. XIV. CodeBlocks:...........................................................................................................................17
 Ejemplos:..............................................................................................................................17
a) Arreglos unidimensionales…...............................................................................................17
b) Arreglos bidimensionales….................................................................................................18
c) Estructuras…......................................................................................................................19
d) Printf/Scanf:......................................................................................................................22

4. 3
I. Introducción:
Las computadoras modernas son uno de los productos más importantes del siglo XXI, ya
que se han transformado en un dispositivo esencial para la vida diaria de los seres humanos,
como un electrodoméstico más de la casa o la oficina que ha cambiado el modo de vivir de
la sociedad.
El papel de los programas en la computadora es fundamental. Ya que sin una lista de
instrucciones que seguir, la computadora es virtualmente inútil. Estos lenguajes nos
permiten escribir esos programas y así comunicarnos con las computadoras. De esta
manera, la computadora puede ser utilizada como una herramienta más del ser humano
que lo puede ayudar a resolver todo tipo de problemas.
Dado que las aplicaciones que tienen estos dispositivos son más cada día: Como hacer
investigaciones, cálculos matemáticos, enviar y recibir mensajes de texto y multimedia,
hacer y recibir llamadas con individuos que se encuentran a largar distancias, redactar
documentos, entre otras cosas.
En la clase de Laboratorio de Programación I, empezaremos a aprender acerca de los
lenguajes de programación que usaremos de que en adelante como estudiantes y futuros
programadores.
Dado que para poder entender el funcionamiento de una computadora, primero tenemos
que entender los lenguajes con los que opera…

5. 4
II. Lenguajes de programación:
Existen varios tipos de lenguajes de programación que se han creado a lo largo de la historia
de la computación, pero nosotros solo estudiaremos los más recientes y los más utilizados
en la actualidad: El lenguaje C, y el C++.
1. Lenguaje C
Es un lenguaje de programación originalmente desarrollado por Dennis M. Ritchie entre
1969 y 1972, bajo el propósito de ser el sucesor del ya menos popular lenguaje B. Pero
que está orientado bajo la misma función: La implementación de Sistemas Operativos.
C es un lenguaje de tipos de datos estáticos, débilmente tipificado, de medio nivel pero
con muchas características de bajo nivel.
Dispone de las estructuras típicas de los lenguajes de alto nivel pero, a su vez, dispone
de construcciones del lenguaje que permiten un control a muy bajo nivel.
2. Lenguaje 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 multi-paradigma.
Una particularidad del C++ es la posibilidad de redefinir los operadores, y de poder crear
nuevos tipos que se comporten como tipos fundamentales.

6. 5
III. Tipo de datos:
Existen varias categorías respecto a la información que se ingresa en el programa…
1. Tipo entero:
Son todos aquellos números enteros, estos pueden ser de signo positivo, o bien, de
signo negativo. Como el 23, o el -32. Siempre y cuando, claro, que los números no
tengan decimales.
Dado que esos se encuentran en la siguiente categoría…
2. Tipo real:
Aquí se encuentran los números que si son decimales, que también son conocidos
como Números Reales.
Números como el 0.5, o el -0.6, entre otros similares.
3. Tipo caracter:
Utilizados para representar un código que es comúnmente usado por el ordenador.
Unos buenos ejemplos seria: a, b, c… entre otros similares a esos.
4. Tipo cadena:
Aquí yacen los datos que ya pueden ser considerados palabras consecutivos, que se
encuentran encerrados, comúnmente, entre casillas dobles.
Los ejemplos abundan, podrían ser cualquier palabra, como: “Hola” o “Adiós”.

7. 6
IV. Palabras reservadas:
Las palabras reservadas son identificadores predefinidos que tienen significados
especiales y no pueden usarse como identificadores creados por el usuario en los
programas.
Las palabras reservadas de los lenguajes anteriormente mencionados pueden dividirse
en tres grupos…
1. Palabras compartidas por ambos lenguajes
Aquí se ubican las palabras de C y que C++ como evolución de C también contiene…
 auto  short  else
 const  struct  for
 double  unsigned  long
 float  break  signed
 int  continue  switch
 void  sizeof  return
 case  typedef  static
 default  volatile  union
 enum  char  while
 goto  do  extern
 register
2. Palabras pertenecientes a C++
Aquí se ubican las palabras que son única y completamente exclusivas del lenguaje
de programación C++ y que, por ende, no se encuentran en el lenguaje C…
 asm  typeid  this
 dynamic_cast  catch  using
 namespace  false  const_cast
 reinterpret_cast  operator  inline
 try  template  public
 bool  typename  throw
 explicit  class  virtual
 new  friend  delete
 static_cast  private  mutable
 protected  true  wchar_t

8. 7
3. Palabras alternativas
Aquí se ubican las palabras reservadas se han añadido como alternativas para
algunos operadores de C++ y hacen los programas más legibles y fáciles de escribir…
 and  not_eq  and_eq
 bitand  or_eq  bitor
 compl  xor_eq  not

9. 8
V. Declaración de variables:
En programación, una variable es un espacio de memoria reservado para almacenar un
valor correspondiente a un dato presente en el lenguaje de programación. Una variable
es representada y usada a partir de una etiqueta que le asigne un programador o
también puede presentarse el caso en que esta ya venga predefinida.
Siempre se recomienda que una variable no este separada por espacios o alguna
especie de caracter especial. De preferencia, todo tipo de variable debe de empezar con
una letra.
Las variables están divididas en diferentes tipos, y se declaran de la siguiente manera:
 Para variables numéricas sin decimales, se usa: int (Ejemplo: int num=23).
 Para variables numéricas con decimales, se usa: float (Ejemplo: float num=3.2).
 Para variables de tipo caracter o tipo cadena, se usa: char (Ejemplo: char
nombre=Barry).
 Para variables de tipo booleana, se usa: bool (Ejemplo: bool terminado=False).

10. 9
VI. Sintaxis:
Se define como sintaxis a la forma en correcta en que se deben escribir las instrucciones
para que el computador pueda ejecutar correctamente la orden planteada.
La mayoría de los lenguajes modernos (C y C++), se rigen por las siguientes sintaxis:
I. El punto y coma:
Este es uno de los símbolos más utilizaos en ambos lenguajes, y se usa con el
propósito de indicar en donde se termina la línea de una instrucción.
Cabe destacar, que el uso del punto y coma en ambos programas, es obligatorio.
II. Espacios y tabulaciones:
Usar caracteres extras de espaciado o tabuladores, es un mecanismo que nos
permite ordenar de manera más clara el código del programa en el que estamos
trabajado.
Sin embargo, el uso de estos es opcional, por el hecho de que el mismo programa
ignora su presencia.

11. 10
VII. Sentencias de control:
Las sentencias de control son todos aquellos comandos que nos permiten separar
ciertas variables y ciertas órdenes del programa a un sector en específico, si
previamente cumplió con todas las especificaciones requeridas.
Existen múltiples sentencias de control, pero las más usadas hasta ahora, son las
siguientes:
1. If-else:
La instrucción if-else permite controlar qué procesos tienen lugar, típicamente en
función del valor de una o varias variables, de un valor de cálculo o booleano, o de
las decisiones del usuario.
2. While:
La condición es cualquier expresión simple que al evaluarse devuelve el valor
verdadero o falso. El bucle se repite mientras la condición sea verdadera. Cuando es
falsa, el programa pasa a la instrucción siguiente, después del cuerpo de la
estructura.
3. Do-while:
Los ciclos do-while son una estructura de control cíclica, los cuales nos permiten
ejecutar una o varias líneas de código de forma repetitiva sin necesidad de tener un
valor inicial e incluso a veces sin siquiera conocer cuándo se va a dar el valor final,
hasta aquí son similares a los ciclos while, sin embargo el ciclo do-while nos permite
añadir cierta ventaja adicional y esta consiste que nos da la posibilidad de ejecutar
primero el bloque de instrucciones antes de evaluar la condición necesaria.
4. For:
Es 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á.
5. Switch:
La sentenciaswitchevalúalaexpresiónydependiendodel valorde laexpresión,asíse
llevaráa caboun "caso" u otro.

12. 11
VIII. Arreglos:
Ahora bien, a partir de todo lo ya anteriormente mencionado, uno ya puede empezar a
programar.
Y uno de las lecciones más fáciles con las que empezaremos, será con los arreglos. Bases
de información que brinda el usuario y que se integran al programa en ejecución. Estos
datos pueden ser tanto numéricos, como alfabéticos.
Hay dos tipos de arreglos:
1. Arreglos Unidimensionales:
En este tipo de arreglos, solo consta de una columna, pero puede contener un
número indefinido de filas, declarándose de la siguiente manera:
TipodeDato NombredelArreglo [TamañodelArreglo];
O sea…
int arregloD [6];
Luego de eso, la poción en donde ira el dato a ingresar se definirá a partir de 0, para
luego colocar un igual, y el dato que se ubicará en dicho espacio.
Esto quiere decir, que si el tamaño de arreglo es de seis, para colocar algo en la 5ta
posición, se tendrá que escribir:
arregloD[6]=32;
2. Arreglos Bidimensionales:
En este caso, los arreglos hechos a partir de arreglos en dos dimensiones pueden
también ser vistos y considerados como una matriz, ya que este tipo de arreglos,
puede contar con un número indefinido tanto de filas, como de columnas.
Los arreglos bidimensionales se declaran de la siguiente manera:
TipodeDato NombredelArreglo [NroFilasArreglo][NroColumnasArreglo];
O sea…
int arregloB [2][3];
Ya habiendo hecho eso, para poder ingresar un dato se deber de hacer lo mismo que
para un arreglo dimensional, solo que esta vez, se deberá ingresar la fila, y la
columna, en donde se quiere colocar dicho dato.
De la siguiente manera:
arregloB[1][1]=23;

13. 12
IX. Estructuras:
Las estructuras, que también pueden ser llamados registros, nos permiten agrupar
varios datos, que mantengan cierto tipo de relación los unos con los otros. De esta
forma, los datos brindados en una estructura en específico, podrán ser manipulados,
con un mismo identificador, ya sea todos juntos, o por separado.
Las estructuras se declaran de la siguiente manera:
struct identificador
{
TipodeDato NombredeObjeto;
};
La representación anteriormente dada se puede ver ejemplificar de la siguiente manera:
struct individuo
{
char Nombre;
int Edad;
};
Tanto el identificador como el nombre del objeto pueden ser nombrados como se
desee.
Respecto al tipo de dato, se puede ingresar el que sea, y la cantidad que se requiera,
siempre y cuando siempre se mantengan la sintaxis correcta de estos, como el tener
siempre presente el punto y coma al final de cada línea.

14. 13
X. Ficheros:
Muy bien, hasta ahora ya hemos aprendido como se declaran variables y con
ejecutarlas.
Pero… ¿Cómo se almacena la información adquirida?
Para estas situaciones, se usan los ficheros.
Los ficheros pueden clasificar de muchas maneras:
 De entrada: Si los datos son leídos por el programa desde el archivo.
 De salida: Si los datos se escriben por el programa hacia el archivo.
 De entrada y salida: Si los datos pueden ser escritos y leídos.
Dependiendo de los valores, pueden ser:
 De texto.
 Binarios.
Dependiendo del tipo de acceso, estos archivos serán:
 Secuenciales:Que se encargande imitarel modode accesode antiguosficherosexistentes.
 De accesoaleatorio:Que permitenaccederal archivo desde cualquier punto para la lectura
y/o escritura.
Y respecto al flujo de datos de dichos ficheros, estos admiten seis modos diferentes:
 r: Son solo de lectura, y el fichero ya deberá de existir.
 w: Es para escritura, funciona tanto para ficheros nuevos como viejos.
 a: Sirve para añadir más información a ficheros existente. Y si el fichero no existe, se crea.
 r+: Lectura y escritura, y el fichero ya deberá de existir.
 w+: Lectura y escritura, funciona tanto para ficheros nuevos como viejos.
 a+: Lectura, escritura, y también para añadir más información un fichero, que si en dado
caso no existe, se crea.

15. 14
XI. Printf/Scanf:
Comúnmente, se tiende a usar sola y únicamente las palabras reservadas “Cin” y “Cout”
a la hora de declarar una variable, sobre todo si se hace en C++.
Pero también existen “printf” y “scanf”, que son las funciones de declaración usadas en
el lenguaje C.
Para este tipo de declaración hay que ser más cuidadosos, ya que para usar estas
funciones también hay que saber usar correctamente los ficheros, ya que son necesarios
para su correcta ejecución.
Su sintaxis es la siguiente:
printf/scanf (“%tipodefichero”, datos);

16. 15
XII. Bibliotecas:
Las bibliotecas, o librerías, son el componente de la programación, que contienen el
código de muchos programas que permiten ejecutar todas y cada una de las funciones
anteriormente mencionadas.
Estas están clasificadas según lo que hacen, y pueden ser de entrada/salida,
matemáticas, manejo de textos, entre muchas cosas más.
Para poder declarar, y así inlcluir una biblioteca a nuestro programa, se debe de escribir
de conocer el nombre y a función del librero que necesitamos, ya sabiendo eso, se
escribe de la siguiente manera:
#include <Nombre de la librería a agregar>;
NOTA: El nombre de la librería debe ir siempre entre “<>” para que funcione
correctamente, ya que si no se hace esto, el programa fallará y no se ejecutará.
Entre las librerías más comunes se encuentran las siguientes:
 ftream  math  ostream  typeinfo  iterator
 iosfwd  memory  stdio  vector  regex
 iostream  new  stdlib  forward_list  thread
 list  numeric  string  list  iterator

17. 16
XIII. Ficheros:
Los ficheros bien pueden definirse como el sistema usado para declarar archivos en un
programa, en el cual se puede guardar múltiples datos que llegaran a usarse más
adelante.
Con la palabra reservada “FILE” se escribe un asterisco y el nombre del archivo.
Según su comando clave, hay varios tipos de archivos que se pueden crear…
 r: Sólo lectura. El fichero debe existir.
 w: Se abre para escritura, se crea un fichero nuevo o se sobreescribe si ya existe.
 a: Añadir, se abre para escritura, el cursor se situa al final del fichero. Si el fichero no
existe, se crea.
 r+: Lectura y escritura. El fichero debe existir.
 w+: Lectura y escritura, se crea un fichero nuevo o se sobreescribe si ya existe.
 a+: Añadir, lectura y escritura, el cursor se situa al final del fichero. Si el fichero no
existe, se crea.
 t: Tipo texto, si no se especifica "t" ni "b", se asume por defecto que es "t"
 b: Tipo binario.
Y así como esos comandos, también hay multiples declaraciones que se usan
principalmente en los ficheros. Entre ellos están:
 fwrite: Sirve para escribir un dato en el archivo.
 fread: Lee datos del fichero.
 fprintf: Tiene la misma función que printf pero dentro de un fichero.
 fscanf: Lee datos de un fichero al igual que fread.

18. 17
XIV. CodeBlocks:
Bien, ya conocemos lo básico acerca de los lenguajes de programación que usaremos.
Pero para poder ejecutarlos nos hará falta un programa especial, uno que nos permita
ejecutar todo tipo de acciones con todos esos comandos y así crear nuestros propios
programas. Y el programa que usaremos para ello, es CodeBlocks.
A continuación, se mostraran algunas demostraciones de las lecciones previamente
aprendidas planteadas y ejecutadas en CodeBlocks…
 Ejemplos:
a) Arreglos unidimensionales…
Se inicia declarando el tamaño de
arreglo unidimensional con el que
vamosa trabajar, sinolvidarnuncael
punto y coma al final de cada línea.
Seguido de eso, se coloca la
información que se desea ingresar en
cada una de las casillas del arreglo.
Tal y como se habia explicado
anteriormente.
Y por último la variables
son planteadas,mostrando
primero el texto a
aparecer, y seguido de
esto, la casilla del arreglo
que corresponde a dicho
lugar.

19. 18
b) Arreglos bidimensionales…
Aquí se puede ver el arreglo ejecutado de la
manera correcta y debida.
De una manera muy similar al
ejemploanterior, se iniciadeclarando
el tamaño de arreglo con el que
vamos a trabajar, solo que en este
caso, se deben especificar tanto las
filas como las columnas.
Seguido de eso, se coloca la
información que se desea ingresar en
cada una de las casillas del arreglo.
Con el cuidado de no escribir
erróneamente las posiciones,
evitando confundir filas con
columnas y viceversa.
Y luego se escribe lo que se quiere
que aparezca en pantalla.

20. 19
c) Estructuras…
La tabla anterior se puede ver aquí, planteada correctamente.
En el caso de las
estructuras, estas deben
siempre colocarse
primero que el Main
Principal, con la
estructura que se puede
ver y que fue orientada
en puntos anteriores, sin
olvidar nunca el punto y
coma al final de las
llaves.
Nota: Esto SOLAMENTE
se hace en el struct.

21. 20
Seguido de eso, se escriben las variables y la forma de ingresarlas al programa, Teniendo en
cuenta la estructura a la que pertenecen.
Se pueden usar las palabras “fflush” y “getline” para así integrar los espacios al programa.
Esta parte es muy delicada, ya que se debe de ver la estructura a la que la variable pertenece y
así integrarla de la forma correcta. Sino, habrá un error y el programa no se podrá inicializar.
Para ya luego al final, lanzar la información brindada de una vez al usuario.

22. 21
Al ejecutarse la
aplicación, será en esta
parte en la que el
usuario llenar los
requerimientos pedidos
por el programa…
Para que ya al final, esta sea presentada una vez más por el programa al usuario que ingreso
dicha información.

23. 22
d) Printf/Scanf:
Aquí se muestran
ejemplos claros, del
“printf” y el “scanf”.
En donde también se
usan los ficheros
según el dato que
este ingresado o se
vaya a ingresar.