Introducción al lenguaje C/C++: manual de programación

Manual C/C++
UCA
Facultad de Ciencia, Tecnología
y Ambiente
Laboratorio De Programación I
Nombre: Néstor Josué Flores González
Facilitado por: Ing. Elsner B. González O

TABLA DE CONTENIDO
Tabla de contenido ..............................................................................................................2
Introducción al lenguaje C/C++ .........................................................................................1
Definición y origen de C ..................................................................................................1
Definición y origen de C++ .............................................................................................2
Palabras reservadas............................................................................................................3
Operadores y Tipos de datos.............................................................................................5
Operadores .......................................................................................................................5
Aritméticos. ...................................................................................................................5
Incremento y decremento...........................................................................................5
Relacionales. ................................................................................................................6
Lógicos. .........................................................................................................................7
Operadores de asignación .........................................................................................7
Operador condicional ..................................................................................................8
Identificadores ..................................................................................................................9
Tipos de datos ................................................................................................................10
Numéricos ...................................................................................................................10
Tipo reales o de coma flotante (float/double):.......................................................11
Lógicos (booleanos en C++) ....................................................................................11
Caracteres...................................................................................................................11
Void..............................................................................................................................11
Juego de caracteres permitidos...................................................................................13
Variables..........................................................................................................................14
Cómo declarar una variable .....................................................................................14
Entrada de datos: Leer datos...........................................................................................16
Leer datos en Lenguaje C. ...........................................................................................16
Salida de datos: Imprimir datos .......................................................................................18
Función sizeof ().................................................................................................................21
Conversión de datos o Casting........................................................................................22

Arreglos ...............................................................................................................................25
Arreglo unidimensional..................................................................................................25
Leer un arreglo ...............................................................................................................27
Imprimir un arreglo .........................................................................................................27
Arreglos bidimensionales..............................................................................................28
Inicializar un arreglo bidimensional.........................................................................29
Estructuras ..........................................................................................................................33
Ficheros...............................................................................................................................39
Archivo de texto..............................................................................................................39
Archivo Binario ...............................................................................................................39
Manejo de archivos........................................................................................................39
Apertura de archivos .....................................................................................................39
Modos de apertura.........................................................................................................40
Funciones........................................................................................................................40
Función fopen() ..........................................................................................................40
Función fclose()..........................................................................................................41
Función fseek ()..........................................................................................................41
ftell () ............................................................................................................................41
Otras funciones ..........................................................................................................42
Estructuras de control de Datos ......................................................................................43
Estructuras Condicionales............................................................................................43
Sentencia If simple.....................................................................................................43
Condicional doble (if- else).......................................................................................44
Condiciones anidadas (if-else).................................................................................44
Switch...........................................................................................................................45
Estructuras repetitivas...................................................................................................45
While ............................................................................................................................45
Do-While......................................................................................................................46
For ................................................................................................................................46
Programación Modular......................................................................................................47

Función main()................................................................................................................48
Funciones........................................................................................................................48
Ejecución de Funciones............................................................................................48
Llamada o invocación de una función ....................................................................48
Prototipo de una función...........................................................................................48
Argumentos de Funciones........................................................................................49
Forma de transferir argumentos ..........................................................................49

NÉSTOR JOSUE FLORES 1
INTRODUCCIÓN AL LENGUAJE C/C++
Definición y origen de C
El lenguaje C es un lenguaje de programación de
propósito general que ofrece a los
programadores economía sintáctica, control de
flujo y estructuras sencillas y un buen conjunto de
operadores.
Se dice que no es un lenguaje de muy alto nivel
y más bien un lenguaje pequeño, sencillo ya que
no está especializado en ningún tipo de aplicación. Pero a la vez es esto lo hace un
lenguaje potente, con un campo de aplicación ilimitado y sobre todo, se aprende
rápidamente. En poco tiempo, un programador puede utilizar la totalidad del
lenguaje.
Este lenguaje ha sido estrechamente ligado al sistema operativo UNIX, puesto que
fueron desarrollados conjuntamente. Sin embargo, este lenguaje no está ligado a
ningún sistema operativo ni a ninguna máquina concreta. Se le suele llamar lenguaje
de programación de sistemas debido a su utilidad para escribir compiladores y
sistemas operativos, aunque de igual forma se puede desarrollar cualquier tipo de
aplicación.
La base de C fue escrito por Martin Richards, y del B escrito por Ken Thompson en
1970 para el primer sistema UNIX en un DEC PDP-7. Estos son lenguajes sin tipos,
al contrario que el C que proporciona varios tipos de datos. Los tipos que ofrece son
caracteres, números enteros y en coma flotante, de varios tamaños. Además se
pueden crear tipos derivados mediante la utilización de punteros, vectores, registros
y uniones. El primer compilador de C fue escrito por Dennis Ritchie para un DEC
PDP-11 y escribió el propio sistema operativo en C.
C trabaja con tipos de datos que son directamente tratables por el hardware de la
mayoría de computadoras actuales, como son los caracteres, números y
direcciones. Estos tipos de datos pueden ser manipulados por las operaciones
aritméticas que proporcionan las computadoras. No proporciona mecanismos para
tratar tipos de datos que no sean los básicos, debiendo ser el programador el que
los desarrolle. Esto permite que el código generado sea muy eficiente y de ahí el
éxito que ha tenido como lenguaje de desarrollo de sistemas. No proporciona otros
mecanismos de almacenamiento de datos que no sea el estático y no proporciona
mecanismos de entrada ni salida. Ello permite que el lenguaje sea reducido y los

compiladores de fácil implementación en distintos sistemas. Por contra, estas
carencias se compensan mediante la inclusión de funciones de librería para realizar
todas estas tareas, que normalmente dependen del sistema operativo.
Definición y origen de C++
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

PALABRAS RESERVADAS
En C, como en cualquier otro lenguaje, existen una serie de palabras clave
(keywords) que no puede utilizarse como identificadores. Estas palabras sirven para
indicar al computador que realice una tarea muy determinada (desde evaluar una
comparación, hasta definir el tipo de una variable) y tienen un especial significado
para el compilador. Las más utilizadas son:
Palabras reservadas de C
Palabra reservada Función
abs () Calcula el valor absoluto
char Tipo de dato carácter
case Si se cumple un caso (condición)
default Opción predeterminada
typedef Crea un nuevo nombre de tipo para uno
ya definido
for Estructura de ciclo (Desde/Para)
int Tipo de dato entero
{ Inicio de un programa
} Fin del programa
do Estructura de ciclo
printf Imprime en pantalla
puts Imprime una cadena
scanf Lee una variable
gets Lee una cadena de caracteres
clrscr Borra el contenido de la pantalla
while Estructura de un ciclo
void Valor nulo
main Programa principal
sqrt Calcula raíz cuadrada

struct Estructura
float Tipo de dato real
return Regresa valor a otra función
break Termina el caso
switch Estructura de selectiva
if Estructura de condición (If)
else Estructura de condición (sino)

OPERADORES Y TIPOS DE DATOS
Operadores
Uno de los puntos fuertes de C/C++ es su gran variedad de operadores y la
flexibilidad que éstos disponen.
Los operadores son símbolos que permiten relacionar dos o más datos en una
expresión y evaluar el resultado de la operación.Esta característica de C/C++
permite la construcción de expresiones muy complejas de forma sencilla.
Existen 4 grupos de operadores:
Aritméticos.
Los operadores artiméticos son los que realizan operaciones matemáticas, donde
se implican 1 o más variables para ser sumadas, restadas, multiplicadas, divididas
etcétera.
Operadores aritméticos
Operador Significado Ejemplo
+ Suma a + b
- Resta a - b
* Multiplicación a * b
/ División a / b
% Residuo a % b
Incremento y decremento.
Los operadores de incremento y decremento son exclusivos y propios del lenguaje
C. Estos operadores pueden aplicarse a variables, pero no a constantes o
expresiones.
Operadores de incremento y decremento
Incrementa i en 1, luego se utiliza el
nuevo valor de i en la expresión.
++ i

++
Utiliza el valor actual de i en la
expresión y luego se incrementa en 1.
i ++
--
Decrementa i en 1 y luego utiliza el
nuevo valor de i en la expresión.
-- i
Utiliza el valor actual de i en la
expresión y luego se decrementa i en
1.
i --
Relacionales.
Estos operadores describen una relación, condición y comparación de dos valores.
El resultado que devuelve estas expresiones es de tipo booleano, es decir
verdadero (1) o falso (0). La principal diferencia con respecto a otros lenguajes son
los símbolos empleados en los operadores de igualdad y distinto. El de igualdad por
su similitud con la asignación lleva muchas veces a provocar errores tipográficos
involuntarios.
Operadores relacionales
> Mayor que 8 > 5
< Menor que 3 < 10
>= Mayor o igual que 6 >= 6
<= Menor o igual que -10 <= -5
== Igual que 1 == 1
!= Distinto de 100 != 36

Lógicos.
Las expresiones lógicas tienen la posiblidad de combinarse para formar expresiones
más complejas utilizando los operadores lógicos.
Operadores lógicos
&& y a && b
|| ó a || b
! No a ! b
De este modo, es importante conocer cómo evaluar las expresiones lógicas, con el
uso de la llamada “tabla de la verdad” nos permite representar cómo funciona cada
operador lógico.
Tabla de la verdad
a b !b A && b a || b
verdadero verdadero falso verdad verdad
verdadero falso falso falso verdad
falso verdadero verdad falso verdad
falso falso falso falso verdad
Operadores de asignación
Los operadores de asignación permiten evaluar una expresión y asignar el resultado
a la variable
Operadores de asignación
= Asignar
identificador = expresión
suma = n1 + n2;

Además existen otros operadores de asignación propios del lenguaje C:
Operadores de asignación de C/C++
Operador Ejemplo Equivalencia
+= a+=7 a=a+7
-= a - =7 a=a – 7
*= a*=15 a=a*15
/= a/=2 a=a/2
%= a%=4 a=a%4
Operador condicional
El operador condicional sustituye a la sentencia de condición “if…. else”.
Su estructura es:
Ejemplo de este operador:

Identificadores
Los identificadores son una secuencia de caracteres ya sea alfabéticos, numéricos
y además de éstos, el guíon bajo. Con los identificadores podemos otorgarle un
nombre a las variables, constantes, a los tipos de datos, a las funciones o
procedimientos, etcétera.
El lenguaje C no está especificado el límite del tamaño de éstas, pero en algunas
implementaciones de C++ sólo se admiten los primeros 31 caracteres.
Para crear un identificador en un algoritmo se deben seguir estas normas:
 El primer carácter debe ser una letra de la A a la Z, ya sea mayúscula o
minúscula y no pueden contener espaciones en blanco. En este lenguaje se
permite el uso de “_” (guión bajo) por lo que se puede se utilizar como letra.
 No se puede utilizar una palabra reservada como identificador ya que es propia
del lenguaje.
 Este lenguaje puede distinguir entre mayúsculas y minúsculas por que tienen
diferente código ASCII.
 En un programa no se pueden nombrar dos identificadores con el mismo
nombre.
 Los identificadores pueden tener uno o varios puntos, según la estructura
empleada.
Sin embargo, para mejorar el uso de los identificadores en los algoritmos se sugiere
que:
 El identificador tenga un nombre significativo, que dé una idea de la
información que almacenará.
 Utilizar identificadores cortos, apoyándose con abreviaturas.
 Para un mejor aspecto en los identificadores compuestos (más de un
nombre) se puede escribir la primera palabra en minúscula y la primera letra
de la segunda en mayúscula.
De lo anteriormente dicho, he aquí unos de ejemplos sobre el uso recomendado de
los identificadores:
Correcto Incorrecto
notaLabP1 1notalabp
IC2016 2016IC
Manual_C Manual C

Tipos de datos
Los tipos de datos en un algoritmo son los conjunto de valores que se pueden
almacenar en una variable. Éstos están delimitados por un rango de valores, si se
excede ese límite de datos, el compilador no podrá ejecutar dicho programa.
El tipo de dato asociado a una variable sólo puede utilizarse con el mismo tipo de
dato. Por ejemplo, una variable de tipo int no puede almacenar datos de tipo char,
por lo que de igual manera no se pueden calcular operaciones con esta variable.
Los tipos de datos se asignan a las variables por dos razones principales:
 Detectar errores de operaciones en los programas.
 Determinar cómo ejecutar las operaciones del algoritmo.
Los tipos de datos simples son los datos indivisibles, es decir, que no se pueden
descomponer.
Estos datos son los: numéricos (enteros y reales), lógicos (booleanos) y
caracteres.
Numéricos
Este tipo de dato se divide en enteros y reales.
Tipo entero:
Son aquellos números que no tienen fracciones o decimales. Pueden ser positivos
y negativos y su rango es de -32,768 a 32,767. Aunque variar según el compilador
utilizado. Se almacen en la memoria RAM con un tamaño de 2 o 4 bytes según el
tamaño.
Estos tipos de datos pueden ser:
 unsigned int (entero sin signo)
 Short (entero corto)
 Int (entero)
 Unsigned long (entero largo sin signo)
 Long (entero largo)

Tipo reales o de coma flotante (float/double):
Estos tipos de datos contienen una coma o punto decimal, pueden ser positivos y
negativos. Para representar los números grandes o pequeños se puede utilizar la
notación científica (número real x10 elevado a la potencia).
Estos tipos pueden ser:
 float (4 bytes en memoria).
 double (8 bytes).
 long double (16 bytes).
Lógicos (booleanos en C++)
Los datos lógico/booleanos en lenguaje C/C++ además de tomar uno de los valores
verdadero (true) o falso (false) se puede implementar con un número entero; el 0
como falso y 1 o cualquier otro número diferente de 0 como verdadero.
Caracteres
Los caracteres se almacenan en el interior de computadoras como “palabras” de 1
bytes (8 bits). Se representan en enteros de rango -128 a +127. En lenguaje C se
puede utilizar el tipo unsigned char para representar los valores de 0 a 255, de este
modo se utiliza el código ASCII. Al guardarse como números enteros, estos se
pueden utilizar con operaciones aritméticas.
Void
Son datos vacíos. Este se puede emplear cuando la función main no regreas ningun
valor, por lo que la reemplazamos por void main () o void main (void).

En resumen, los tipos de datos del lenguaje C/C++ se clasifican en:
Tipo de dato Descripción Tamaño
(bytes)
Rango Ejemplo
int
signed entero con
signo
4
-32,768 a 32,767
signed int nota=+3879
short entero corto 2 short int nota=150
long entero largo 4 -2147483648 a 2147483647 long int nota=5555555
unsigned entero sin signo 4 0 a 65535 unsigned int nota=9163
bool - valor lógico 1 false-true bool sexo=1
char
- carácter 1 -128 a +127 char=’A’
unsigned caracter ASCII 1 0 a 255 unsigned char uca=15
float
- coma flotante o
decimal
4 3.4E-38 a 3.4E+38 float pi=3.1416
double
- decimal de
doble precisión
8 1.7E-308 a 1.7E+308 double clases=9.5E+15
long decimal largo de
doble precisión
16 3.4E-4932 a 1.1E+4932 long double
clases=5.4E+1000

Juego de caracteres permitidos
El estándar de C++ especifica un juego básico de caracteres de código fuente que
se puede usar en los archivos de código fuente. Para representar caracteres ajenos
a este conjunto, los caracteres adicionales se pueden especificar mediante el uso
de un nombre de carácter universal. Cuando se compila, el juego básico de
caracteres de ejecución y el juego básico de caracteres anchos de
ejecución representan los caracteres y las cadenas que pueden aparecer en un
programa. La implementación de Visual C++ permite caracteres adicionales en el
código fuente y el código compilado.
El juego básico de caracteres de código fuente consta de 96 caracteres que pueden
usarse en archivos de código fuente. Este conjunto incluye el carácter de espacio,
tabulación horizontal, tabulación vertical, avance de página y caracteres de control
de nueva línea.
Entre estos se encuentran los caracteres del código ASCII:
El código ASCII (acrónimo inglés de American Standard Code for Information
Interchange — Código Estándar Estadounidense para el Intercambio de
Información), es un código de caracteres basado en el alfabeto latino, tal como se
usa en inglés moderno.

Variables
Una variable es un dato cuyo valor almacenado en memoria que se puede modificar
en cualquier momento o ser conservado para ser usado en los momentos que se
necesite.
Como ya se ha expuesto, existen varios tipos de variables: reales, enteras,
caracteres, booleanas (C++) y cadenas.
El lenguaje C permite denominar libremente las variables con el nombre que el
programador considere correcto, para esto se siguen las normas anteriormente
dichas.
Cómo declarar una variable
Las variables que se utilicen en un algoritmo deben ser declaradas antes de ser
usadas. Todas deben asociarse con un tipo de dato, identificador (nombre de la
variable) y valor.
La sintaxis para definir una variable en lenguaje C es:
Si se desea inicializar una variable y asignar un valor en esa mismo momento se
utiliza la siguiente estructura:
En dependencia del tipo de valor que se utiliza en un variable, se debe utilizar otras
estructuras. Por ejemplo:
Para inicializar una
variable tipo entero
variable tipo char
Inicializar una variable char
con arreglo de cadena

Como se puede observar, cuando se inicializa una variable de tipo carácter, ésta
tiene que ser usada entre comillas simples ‘’ . Mientras que al inicializar una cadena
de caracteres se debe especificar como arreglo, contando los caracteres de la
cadena + 1 espacio más en el arreglo y entre comillas “”.
Si las variables que se quieren declarar son del mismo tipo de dato, se pueden
definir en una sola línea:
Una variable puede declararse en cuatro lugares diferentes del algoritmo o
programa:
• Fuera de todos los subprogramas o funciones (global).
• Dentro de un subprograma o función (local a la función).
• Dentro de un bloque enmarcado por llaves { } (local al bloque).
• Dentro de una instrucción, por ejemplo: for (int i50; i,510; i11).
• Como parámetro formal (local a la función).
variable tipo float o double

ENTRADA DE DATOS: LEER DATOS.
Leer datos en Lenguaje C.
El lenguaje C al no tener palabras reservadas para la entrada/salida del sistema
(teclado y pantalla), estas operaciones se realizan por medio de las funciones de la
biblioteca <stdio.h> (standar input-output).
La función scanf() se usa para la entrada y permite leer datos a través del teclado
y asignarlos a una variable del algoritmo, de acuerdo a su formato específico.
La sintaxis de la función scanf() es:
La cadena de control contiene uno o varios especificadores o códigos de formato
que indican el tipo de dato de los argumentos a utilizar y su anchura. Estos códigos
están precedidios por el carácter % seguido del carácter de conversión, cabe
recalcar que estos siempre se escriben entre comillas “”.
Tabla de los especificadores para cada tipo de dato en scanf():
Tipo de dato Especificador de formato
char %c
char unsigned %c
char (cadena terminada en 0) %s
int %d - %i
unsigned int %u
short int %hd
unsigned short int %hu
signed short int %d
long int %ld
unsigned long int %lu
signed long int %l
float %f - %g - %G - %e - %E
double %lf - %lg - %lG - %le - %lE

long double %lf - %lg - %lG - %e - %lE
octal sin signo %o
hexadecimal minúscula %x
hexadecimal mayúscula %X
La lista de argumentos son las variables. Esta función necesita saber la posición de
memoria en la que la variable se almacenará, por lo que se utiliza el símbolo
ampersand (&), ubicado antes del nombre de la variable.
A continuación, estos ejemplos del uso de scanf() con sus respectivos
especificadores:
Se declara la variable numAsig como entero, luego se utiliza la función scanf, entre
paréntesis el especificador entre comillas, seguido del & y nombre de la variable.
Esta función permitirá leer datos de tipo int desde el teclado y asignarselos a la
variable.
Se declara la variable universidad como char, ésta se utilizara como cadena. A
diferencia de las otros tipos de datos, al utilizar una cadena, se puede obviar el
ampersand (&) por lo que simplemente sería la función scanf, seguido del
especificador entre comillas y el identificador.

Una de las ventajas que posee esta función, es que permite leer distintas variables
con una sola línea de código, simplificando el algoritmo. Sólo basta con agregar los
especificadores e identificadores separados por coma.
SALIDA DE DATOS: IMPRIMIR DATOS
La función printf() es similar a la función scanf(), pero ésta se utiliza para imprimir
datos en la salida; permite escribir textos y datos en la pantalla con determinado
formato.
La sintaxis de esta función es:
Al igual que en la función scanf(), la cadena de controladores son los
especificadores y los argumentos los identificadores o nombres de variables.
Ademas la cadena de control debe escribirse entre comillas (“ ”) y puede tener al
menos uno de estos tres elementos:
 Los caracteres que se imprimirán en pantalla (los cuales se visualizarán
idénticos).
 Uno o varios especificadores o códigos de formato (indica de qué tipo de dato
se trata, como ya se había indicado en la función scanf() ).
 Secuencias de escape: estas secuencias nos permiten añadir otras
características a la salida.
Secuencia de escape Descripción
a Alerta
b Espacio atrás
f Salto de página
n Salto de línea
r Retorno de carro
t Tabulación horizontal
v Tabulación vertical

Ejemplo de imprimir datos:
 Se imprime el valor de la variable edad de tipo entero.

Los códigos de formato pueden controlar aspectos de la apariencia de los datos: la
longitud, el número de decimales y la justificación a izquierda o derecha.
Sintaxis:
Los valores entre [ ] son opcionales, donde:
 signo: indica si el valor aparecerá a la izquierda (signo menos), o a la derecha
(por defecto).
 longitud: longitud máxima del valor que aparecerá en la pantalla.
 precisión: indica el número máximo de decimales que tendrá el valor.
 l/L: se utiliza l cuando se trata de una variable de tipo long, y L cuando es de
tipo double.
Ejemplo:
Al utilizar esta función, el código de formato que se ejecuta “%4d” indica que
imprimirá un número entero en cuatro posiciones o lugares, justificando a la
derecha. El relleno es blanco.

FUNCIÓN SIZEOF ()
La función sizeof permite mostrar en la salida de un algoritmo la cantidad de
memoria que ocupa un elemento de datos, éste lo
indica en bytes.
Su estructura es sencila:
Para tener una mejor percepción del funciomaniento de este operador, un ejemplo
realizado en C++:
Al momento de ser compilado y ejectuado, en la salida se muestra los valores de
cada valores, así como también el espacio que ocupa cada una en la memoria,
utilizando la función sizeof ()

CONVERSIÓN DE DATOS O CASTING
En el lenguaje C/C++ existe la posiblidad de forzar la conversión de un dato a otro
tipo diferente. A esta conversión se le conoce como “cast o casting”.
Su sintaxis es:
A partir de esta tabla se puede tomar en cuenta qué datos se pueden convertir a
otros datos. Algunas conversiones pueden variar según la cantidad de valores que
se utilicen en las variables:
Tipo de Datos short
signed
Short
unsigned
Short boolean double
long
double int
signed
int
unsigned
int
short S S S S S S S S
signed Short S S S S S S S S
unsigned
Short
S S S S S S S S
bool S S S S S S S S
double S S S S S S S S
long double S S S S S S S S
int S S S S S S S S
signed int S S S S S S S S
unsigned int S S S S S S S S
long S S S S S S S S S
signed long S S S S S S S S S
unsigned long S S S S S S S S S
float S S S S S S S S S
char S S S S S S S S S
unsigned char S S S S S S S S S

long signed long
unsigned
long float
cha
r
unsigned
char
S S S S S S
S S S S S S
S S S S S S
S S S S S S
S S S S S S
S S S S S S
S S S S S S
S S S S S S
S S S S S S
S S S S S
S S S S S
S S S S S
S S S S S
S S S S S
S S S S S
Al compilar y ejecutar algunos códigos utilizando el casting se puede lograr ver en la salida:

En el anterior ejemplo, se puede observar que al momento de convertir un valor de
tipo int (entero) a una variable de tipo char (carácter), éste lo toma como un código
ASCII por lo que en la salida muestra una arroba “@” como símbolo, ya que el éste
es el número 64 en el código ASCII.

ARREGLOS
Los arreglos son el tipo de dato estructurado que almacena en una sola variable un
conjunto .limitado de elementos del mismo tipo. Un arreglo en lenguaje C inicia en
la posición 0 (cero) por lo tanto el último elemento está en la posición i-1, es decir
el número de arreglos declarados -1.
Para acceder a un elemento específico de un arreglo se usa un índice o subíndice.
Las características del arreglo son:
 Ser una lista de un número finito de n elementos del mismo tipo.
 Almacenar los elementos del arreglo en memoria contigua.
 Tener un único identificador o nombre de variable que representa a todos los
elementos y éstos se diferencian por un índice o subíndice.
 Acceder de manera directa o aleatoria a los elementos individuales del
arreglo, por el nombre del arreglo y el índice o subíndice.
Es importante declarar los arreglos con el tamaño adecuado, ya que si un arreglo
que se le 50 elementos, sólo se ocupan 10, se dejarían 40 espacios sin usar por lo
que se estaría desperdiciando un lugar en la memoria.
Los arreglos se clasifican en:
Arreglo unidimensional
El arreglo unidimensional es un conjunto de n elementos del mismo tipo
almacenados en memoria continua en un vector o lista. Para acceder a cada
elemento del arreglo se requiere de un solo índice o subíndice, el cual representa la
posición en la que se encuentra el valor.
La sintaxis de un arreglo unidimensional es:
Donde:
 tipo_dato se refiere al tipo de dato de cada elemento del arreglo; puede ser
entero, real, carácter, etcétera.
 identif_arreglo es el nombre que representa a todo el arreglo
 tam_arreglo es la cantidad de elementos que contiene el arreglo.

Existen varias formas de inicializar los valores de los elementos de un arreglo.
 Directamente con llaves: de esta forma se utiliza la sintaxis anterior y se añaden
llaves para indicar los valores de cada elemento del arreglo:
 Declaración por separado: se conserva la misma sintaxis, pero al asignar los
valores de cada elemento se hace de modo independiente. Cada elemento
debe ser indicado por su índice entre corchete [ ], empezando del 0 hasta el
número de elementos -1.
La representación de como sería un arreglo en memoria es esta, tomando en cuenta
el anterior arreglo:
16 64 32 8 4
[0] [1] [2] [3] [4]
ÍNDIC
ES

Leer un arreglo
Para leer un arreglo se debe de indicar el subíndice del elemento al que se le va a
asignar un valor. Para esto se escribe el nombre del arreglo y entre corchetes [ ] el
elemento a asignar.
Ejemplo:
 En lenguaje C utilizando scanf()
 En lenguaje C++ utilizando cin
De este modo estamos asignando un valor de tipo entero al elemento 0 del arreglo
llamado edad (edad[0])
Imprimir un arreglo
Para imprimir un arreglo, al igual que cuando se lee un arreglo, se debe indicar qué
elemento del arreglo se debe mostrar. Para esto se utiliza el nombre del arreglo y el
elemento a imprimir entre corchete [ ].
 En lenguaje C utilizando printf
 En lenguaje C++ utilizando cout

Al ejecutar los códigos, la salida se mostrará así:
Arreglos bidimensionales
Un arreglo bidimensional es un conjunto de n elementos del mismo tipo
almacenados en memoria contigua en una matriz o tabla. A diferencia de los
arreglos unidimensionales que sólo requieren de un subíndice, los arreglos
bidimensionales para acceder a cada elemento del arreglo requieren de dos índices
o subíndices declarados en dos pares de corchetes, donde el primer corchete se
refiere al tamaño de filas y el segundo al tamaño de columnas.
Su estructura es:
Ejemplo:
Para declarar un arreglo bidimensional se necesitan declarar dos elementos, donde
el primero será el número de filas y el segundo el número de columnas.

Representado como una matriz sería:
gasolina Columna 0 Columna 1 Columna 2
Fila 0 gasolina[0][0] gasolina[0][1] gasolina[0][2]
Inicializar un arreglo bidimensional
Para inicializar un arreglo bidimensional, al igual que el unidimensional se puede
realizar de varias maneras:
 Directamente con llaves: de esta forma se utiliza la sintaxis anterior y se añaden
llaves para indicar los valores de cada elemento del arreglo, como la matriz es
de 3x3, serían 9 elementos a inicializar.
 Declaración por separado: se conserva la misma sintaxis, pero al asignar los
valores de cada elemento se hace de modo independiente. Cada elemento
debe ser indicado por su índice entre corchete [ ], deben ser dos por cada uno
ya que contiene filas y columnas, empezando del 0 hasta el número de
elementos -1.

Ejemplo más avanzado:

La salida del algoritmo es:

ESTRUCTURAS
Una estructura se le denomina a un tipo de dato estructurado y definido por el
usuario que permite almacenar datos de diferente tipo en una sola variable; dichos
datos pueden ser simples (caracteres, números enteros o de coma flotante, etc.) o
compuestos (vectores, estructuras, listas, etc.). A los datos del registro se les
denomina campos, elementos o miembros. Una estructura está formada por
variables que tienen relación entre sí.
Una estructura define una plantilla con la que posteriormente se puede declarar una
variable. Una de las características de las estructuras es que hay que definirlas
antes de usarlas en la declaración de variables. En la definición no se declara ni
reservando memoria para ninguna variable, sólo se construye una estructura con
determinadas características, para después poder declarar una variable de ese tipo.
Aunque también se puede definir la estructura y declarar variables del tipo
estructura definida, lo normal es declararlas fuera de la definición. Más adelante se
muestra la forma de declarar una estructura, un tipo de dato y una variable tipo
registro (struct ).
Para crear una estructura primero comenzamos por definir el tipo de estructura, para
ello se procede de manera parecida a la definición de una variable, con algunas
modificaciones; en lenguaje C para definir una estructura, se utiliza la palabra
reservada struct, normalmente seguida por un nombre y llave izquierda; después se
define el tipo y nombre para uno o más campos. Se permite cualquier definición de
tipo habitual, incluso punteros y estructuras. Cada definición de campo acabará con
un punto y coma. Por último se coloca una llave derecha. Si hay campos del mismo
tipo, se pueden declarar en la misma línea, separándolos por comas.
Hay varias formas de definir un registro, pero la más general es la siguiente:

Al estar definida ya la estructura, para poder acceder a ella e ingresar valores a las
variables, se necesita indicar una variable a esa estructura.
De este modo:
O de igual manera, sin utilizar la palabra reservada “struct”
Ejemplo de estructuras utilizando la E/S de la cabecera stdio.h (printf-scanf)
 Estructura de estudiante

Al compilar y ejecutar el código, su salida es:

 Estructura de empleado
Salida del registro

 Estructura de vehículo
Salida del registro

 Estructura de docente

FICHEROS
Un archivo es un conjunto de bits almacenados en un dispositivo de memoria
secundario, por ejemplo el disco duro (HDD), el cual es almacenado en un conjunto
de propiedades, y es identificado por un nombre.
En C, se puede definir como un concepto lógico que es aplicado desde archivos de
discos hasta terminales.
Los ficheros se clasifican en dos tipos:
Archivo de texto
Es una secuencia de caracteres organizados en líneas terminadas y planas.
Archivo Binario
Es una secuencia de bytes que tienen una correspondencia uno a uno con un
dispositivo externo.
Manejo de archivos
Estos ficheros son administrados por un puntero, la cual es una variable de tipo
puntero al tipo FILE con variable en “F”.
Apertura de archivos
Para la apertura de archivos en C se utiliza la función fopen(), donde abre una
secuencia para ser utilizada. Su sintaxis es:
Donde:
 FILE*= declara un puntero a un puntero a un archivo y en dirección a
memoria.
 fopen() función para abirar la sentencia.
 nombre_archivo= nombre del puntero, puede incluir la especificación del
directorio.
 Modo= qué procesos se realizarán con los archivos.

Modos de apertura
Existen varios modos de abrir un fichero:
Modo Descripción
r Abrir un archivo para lectura al final , el
fichero debe existir.
w Abrir un archivo para escritura al final, se
crea si no existe o se sobreescribe si existe.
a Abrir un archivo para escritura al final del
contenido, si no existe se crea.
a+ Añade; abre o crea un fichero de texto para
actualización, lee y escribiendo al final del
fichero (EOF)
a+b ó ab+ Añade; abre o crea un fichero en modo
binario para actualización, escribiendo al
final del fichero (EOF)
r+ Abrir un archivo para lectura y escritura, el
fichero debe existir, al inicio
w+ Crear un archivo para lectura y escritura al
inicio, se crea si no existe o se sobreescribe
si existe.
r+b ó rb+ Abre un archivo en modo binario para
actualización (lectura y escritura).
rb Abre un archivo en modo binario para
lectura.
Funciones
Las funciones principales de ficheros son las siguientes:
Función fopen()
La función fopen() devuelve un puntero a archivo para abrir la sentencia. Si se
produce un error al abrir el archivo o simplemente no existe, el puntero devuelve el
valor NULL.
Ejemplo:

Función fclose()
La función fclose() cierra una sentencia que fue abierta anteriormente. Escribe la
información que tiene en el buffer y realiza el cierre normal. En caso de producirse
un error al cerrarlo, se puede generar pérdida de datos.
Su estructura es:
Un ejemplo es:
Función fseek ()
La función fseek activa el indicador de posiciónde ficheros para el stream apuntado
por stream. Para un stream binario, la nueva posición, medido en caracteres del
principio del fichero, es obtenida mediante la suma de desplazamiento y la posición
especificada por origen.
Su estructura es:
Donde su origen es:
 La posición especificada es el comienzo del fichero si origen es SEEK_SET.
 el valor actual del indicador de posición de fichero si es SEEK_CUR.
 Al final de fichero si es SEEK_END.
Un stream binario realmente no necesita soportar llamadas a fseek con un valor de
origen de SEEK_END. Para un stream de texto, o bien desplazamiento será cero,
o bien desplazamiento será un valor retornado por una llamada anterior a la función
ftell al mismo stream y origen será SEEK_SET. Una llamada correcta a la función
fseek despeja el indicador de final de fichero para el stream y deshace cualquier
efecto producido por la función ungetc en el mismo stream. Después de una llamada
a fseek, la siguiente operación en un stream de actualización puede ser de entrada
o salida.
ftell ()
La función ftell retorna el valor del indicador de posición de fichero para el stream,
si se tiene éxito. Si falla, la función ftell retorna -1L y guarda un valor positivo, según
la definición de la implementación, en errno.
Su sintaxis es:

Otras funciones
Nombre Función
fopen() Abre un archivo.
fclose() Cierra un archivo.
fgets() Lee una cadena de un archivo.
fputs() Escribe una cadena en un archivo
fseek() Busca un byte específico de un archivo.
fprintf() Escribe una salida con formato en el archivo.
fscanf() Lee una entrada con formato desde el archivo.
feof() Devuelve cierto si se llega al final del archivo.
ferror() Devuelve cierto si se produce un error.
rewind() Coloca el localizador de posición del archivo al principio del
mismo.
remove() Borra un archivo.
fflush() Vacía un archivo.

ESTRUCTURAS DE CONTROL DE DATOS
Estas estructuras controlan cómo se ejecutan los programas, es decir el orden de
las instrucciones, ya que tienen un solo punto de entrada y un punto de salida. En
la programación estructurada se mezclan las estructuras de control y las podemos
clasificar en:
Estructuras Condicionales
Las estructuras condicionales permiten realizar unas sentencias u otras
dependiendo de los valores.
Sentencia If simple
Secuencial
Estructuras
de Control
Es la estructura más sencilla ya que el programador
identifica los datos de entrada, los procesa y muestra
o imprime los datos de salida.
Selectiva
Es una estructura con una sola entrada y una sola
salida en la cual se realiza una acción (una o varias
instrucciones) de entre varias, según una condición; o
se realiza una acción según el cumplimiento o no de
una determinada condición. La condición puede ser
simple o compuesta.
Repetitiva
La repetición de una acción se lleva a cabo mientras se
cumpla cierta condición; para que la acción termine, la
acción misma debe modificar la(s) variable(s) de control
que interviene(n) en la condición. Dicha condición puede
estar predefinida como en el ciclo desde (for); o no
predeterminada, como en los bucles mientras (while)
y hacer-mientras (do_while).

Si se cumple la condición, se ejecutan las instrucciones
Estructura Ejemplo
Condicional doble (if- else)
Si se cumple la condición, se ejecuta las instrucciones del bloque if, sino se cumple
se realizan las del bloque else.
Estructura Ejemplo:
Condiciones anidadas (if-else)
Las condiciones anidadas consiste en realizar varias sentencias if-else dentro del
else.
Estructura

Switch
Permite comparar una variable con distintos valores, ejecutando para cada caso
una serie de instrucciones específicas.
Su estructura es:
Ejemplo
Estructuras repetitivas
Estas instrucción son aquellas que controlan los bucles, ciclos o repeticiones de un
algoritmo. En cada vuelta el ciclo comprueba si la condición es verdadera y finaliza
cuando ésta sea falsa.
While
Controla la ejecución de un bloque instrucciones de tal forma que éstas ejecutan
mientras se cumple la condición.
Su estructura es: Ejemplo

Do-While
Esta sentencia tiene una diferencia con respecto al while, en vez de evaluar primero
la condición y depués ejecutarla, éste se ejectua primero las instrucciones y luego
se evalua la condición.
Ejemplo:
For
El desde (for) es la estructura repetitiva más utilizada y simple de manejar, ya que
repite un conjunto de instrucciones un número determinado de veces. Una de sus
aplicaciones principales son los arreglos.
Estructura:
Dónde:
 Parte de inicialización: inicializa la variable de control del bucle, se peude
usar una o más variables.
 Parte de iteración o condición: es una expresión lógica, se cumple mientras
sea True.
 Parte de incremento: se incrementa o decrementa el valor de la variable.

PROGRAMACIÓN MODULAR
La programación modular es una técnica que consiste en dividir un programa en
tareas y dar origen a la creación de pequeños programas llamados módulos,
subprogramas o subrutinas con la finalidad de simplificar la elaboración y
mantenimiento del mismo, donde cada módulo se codifica y se procesa de manera
independiente, sin importar los detalles de otros módulos. Esto facilita la localización
de un error cuando se produce. Este tipo de programación es uno de los métodos
de diseño más flexibles y potentes para mejorar la productividad de un programa.
Ejemplo:
Al método que plantea la solución de un problema principal partiendo de las
soluciones de sus subproblemas se le conoce como diseño descendente. Se
denomina así ya que inicia en la parte superior con un problema general y el diseño
específico de las soluciones de los subproblemas.
Las ventajas de la programación modular
1. Facilita el diseño descendente.
2. Se simplifica un algoritmo complejo.
3. Cada módulo se puede elaborar de manera independiente, lo que permite
trabajar simultáneamente a
4. varios programadores y con ello disminuir el tiempo de elaboración del algoritmo.
Programa Principal
Módulo 1 Módulo 2
Módulo 3
SubMódulo 1 SubMódulo 2

5. La depuración se lleva a cabo en cada módulo.
6. El mantenimiento es más sencillo.
7. Creación de bibliotecas con módulos específicos (se pueden utilizar en otros
programas).
Función main()
El papel más importante del programa principal main() es coordinar a las otras
funciones mediante llamadas invocaciones. Mediante la sentencia return, el
programa puede devolver un código de terminación al proceso de llamada
Funciones
Es un subprograma que realiza una tarea específica que puede o no recibir valores
(parámetros). En C podemos devolver cualquier tipo de datos escalares (puntero,
tipo numérico y el tipo carácter o en su caso regresar un valor nulo que llamaremos
nada o ninguno). Asimismo, no se pueden devolver arreglos ni estructuras.
El uso de funciones es una práctica común y recomendable ya que permite dividir
el código, simplificando así el desarrollo y la depuración del mismo. Para utilizar
funciones en un programa es necesario declararlas previamente.
Ejecución de Funciones
El compilador siempre inicia con la primera instrucción que encuentra en el
programa principal (main) y continúa ejecutándolo según la estructura de control
(secuencial, selectiva o repetitiva) del programa; cuando encuentra la llamada a una
función éste se traslada y ejecuta el cuerpo de la función desde la primera
instrucción hasta encontrar el fin de la misma; cuando esto sucede el compilador
regresa a la siguiente instrucción que llamó a la función y continúa de la misma
manera.
Llamada o invocación de una función
Para llamar una función es necesario escribir el nombre o identificador de la función
y en seguida un par de paréntesis, que estarán vacíos si hablamos de funciones sin
paso de parámetros y tendrán información en caso de ser funciones con paso de
parámetros.
Prototipo de una función
Un prototipo es el encabezado de una función, es decir la primera línea de la función.
La ventaja de utilizar prototipos es que las funciones pueden estar en cualquier lugar
y en cualquier orden y pueden ser llamadas desde cualquier punto del programa
principal o de otra función.

Ejemplo de la sintaxis:
Argumentos de Funciones
Son variables locales conocidas como parámetros formales y se utilizan como un
medio para entregarle información a la función.
Los parámetros formales reciben sus valores iniciales desde los parámetros reales,
es decir desde los valores que se les pasan a través de la llamada.
Se declara de esta forma:
Se llama o invoca:
Forma de transferir argumentos
Pase por valor: copia el valor de un argumento de la llamada en el parámetro formal
de la función. Por lo tanto, los cambios en los parámetros de la función no afectan
a las variables que se usan en la llamada.
Pase por referencia: se copia la dirección del argumento en el parámetro. Los
cambios hechos a los parámetros afectan a las variables usadas en la llamada a la
función.
Declaración de variables globales y constantes
Las constantes y variables son elementos que tienen el objetivo de identificar los
datos que se utilizan en las operaciones y cálculos que realiza el programa y que
se almacenan en la memoria de la computadora. Si las variables globales son
declaradas en esta parte, pueden ser utilizadas en todo el programa.
El uso de variables globales no es aconsejable a pesar de que aparentemente nos
parezca muy útil, esto se debe a varias razones fundamentales:
 Legibilidad menor.
 Nos condiciona en muchos casos que el programa sólo sirva para un
conjunto de casos determinados.
 El uso indiscriminado de variables globales produce efectos colaterales. Esto
sucede cuando existe una alteración no deseada del contenido de una
variable global dentro de una función, bien por invocación, bien por olvidar

definir en la función una variable local o un parámetro formal con ese nombre.
La corrección de dichos errores puede ser muy ardua.
 Atenta contra uno de los principios de la programación, la modularidad. El
bajo acoplamiento supone no compartir espacios de memoria con otras
funciones, y potenciar el paso de información (llamadas) para que la función
trate la información localmente.

Introducción al lenguaje C/C++: manual de programación

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (18)

Similar a Introducción al lenguaje C/C++: manual de programación

Similar a Introducción al lenguaje C/C++: manual de programación (20)

Más de Estudiantes ISI_UCA

Más de Estudiantes ISI_UCA (20)

Último

Último (16)

Introducción al lenguaje C/C++: manual de programación