Manual de C/C++ elaborado por Leonel Barberena

1. Facultad de Ciencia, Tecnología y Ambiente
Ingeniería en Sistemas de Información
“Manual de Programación en C/C++”
Docente: Elsner B. González O.
Alumno: Leonel Octavio Barberena Cordero.
Carnet: 2016530019
Grupo: 0114

2. Contenido
1. Tabla ASCII......................................................................................................................... 1
2. Palabras reservadasen C.................................................................................................... 2
3. Identificadores................................................................................................................... 2
3.1. Reglas para dar nombre a un identificador................................................................... 2
4. Tipos de datos.................................................................................................................... 3
5. Const................................................................................................................................. 3
6. Operadores de C................................................................................................................ 3
6.1. Tipos de operadores................................................................................................... 4
6.1.1. Operadores aritméticos....................................................................................... 4
6.1.2. Operadores de asignación en C ............................................................................ 4
6.1.3. Operadores relacionales...................................................................................... 5
6.1.4. Operadores lógicos.............................................................................................. 5
7. Size Of............................................................................................................................... 6
8. Cast................................................................................................................................... 6
8.1. Sintaxis ...................................................................................................................... 6
9. Sintaxis para declarar una variable...................................................................................... 7
10. Arreglos......................................................................................................................... 7
10.1. Arreglos unidimensionales....................................................................................... 7
10.1.1. Sintaxis de arreglos unidimensionales................................................................... 7
10.1.2. Ejemplo de arreglo unidimensional ...................................................................... 8
10.2. Arreglo Bidimensional ............................................................................................. 8
10.2.1. Sintaxis arreglo Bidimensional.............................................................................. 8
10.2.2. Ejemplo de arreglo Bidimensional ........................................................................ 8
11. Estructuras..................................................................................................................... 9
11.1. Sintaxis de struct..................................................................................................... 9
11.2. Ejemplo de estructuras...........................................................................................10
12. Printf y scanf.................................................................................................................12
12.1. Sintaxis de printf y scanf.........................................................................................12
12.2. Tabla de caracteres de conversión ..........................................................................12
13. Entrada y salida sin formato...........................................................................................13
14. Sentencias de control ....................................................................................................13
14.1. If- else...................................................................................................................13

3. 14.1.1. Sintaxis de if-else................................................................................................13
14.2. else-if....................................................................................................................14
14.2.1. sintaxis else-if ....................................................................................................14
14.3. switch....................................................................................................................14
14.3.1. Sintaxis de switch...............................................................................................14
14.4. Bucle While ...........................................................................................................15
14.4.1. Sintaxis de While................................................................................................15
14.5. Ciclo For................................................................................................................15
14.5.1. Sintaxis de For....................................................................................................15
14.6. Ciclos do-while.......................................................................................................16
14.6.1. Sintaxis do-while................................................................................................16
15. Ficheros........................................................................................................................17
15.1. Función fopen........................................................................................................17
15.1.1. Sintaxis..............................................................................................................17
15.1.2. Parámetros de entrada.......................................................................................17
15.2. función fclose ........................................................................................................18
15.2.1. Sintaxis de fclose................................................................................................18
15.3. Función fgetc.........................................................................................................18
15.4. Sintaxis de fgetc.................................................................................................18
15.5. Función feof.......................................................................................................18
15.5.1. Sintaxis feof.......................................................................................................18
15.6. Función rewind y sintaxis........................................................................................18
15.7. Función fgets y sintaxis...........................................................................................19
15.8. Función fread y sintaxis..........................................................................................19
15.9. Fscanf y sintaxis .....................................................................................................19
15.10. fputc y sintaxis.......................................................................................................20
15.11. Función fputs y sintaxis ..........................................................................................20
15.12. función fwrite........................................................................................................20
15.13. fprintf y sintaxis .....................................................................................................20

5. 1
1. Tabla ASCII

6. 2
2. Palabras reservadas en C
3. Identificadores
Un identificador es una secuencia de caracteres alfabéticos, numéricos y el guion bajo. Con
ellos podemos dar nombre a variables, constantes, tipos de dato, nombres de funciones o
procedimientos, etcétera.
3.1. Reglas para dar nombre a un identificador
1. Debe comenzar con una letra (A a Z)mayúscula o minúscula y no puede contener espacios
en blanco. En lenguaje C, el carácter “_” (guión bajo) es considerado como letra, por lo que
se puede utilizar como primer carácter.
2. El lenguaje C distingue mayúsculas de minúsculas porque tienen diferente código ASCII.
3. Letras, dígitos y el carácter guión bajo están permitidos después del primer carácter.
4. No pueden existir dos identificadores iguales, es decir, dos elementos de un programa no
pueden nombrarse de la misma forma. Sin embargo, un identificador puede aparecer más
de una vez en un programa.
5. No se puede utilizar una palabra reservada como identificador, sin embargo, los
identificadores estándar se pueden redefinir.
6. En lenguaje C existen identificadores que podrían tener uno o varios puntos, tales como:
persona.apellidoPaterno
El punto indica el acceso a un campo de una estructura.

7. 3
4. Tipos de datos
Tipos de datos más destacados o más comunes en un algoritmo están:
char: Palabra que se usa para clasificar un dato como carácter o cadena. Un
ejemplo de su uso: char “HOla”; Aquí este está declarando que “HOLa” es de
tipo Carácter.
int: Palabra que se usa para clasificar un dato como numero Entero. Un
ejemplo de su uso: int x = 5; Aquí está declarando que “x” es de tipo Entero y
se inicializa con el valor de 5.
float: Palabra que se usa para clasificar un tipo de dato como numero
Flotante, Real o Decimal: float y = 12.34.
double:Se usa como un float, pero con doble precisión (Para números
elevados y con exponentes precisos)
5. Const
Este comando sirve para declarar una variable como constante, esto ayuda a
que en cualquier parte de la estructura de un algoritmo sea recordado el
valor de la variable.
6. Operadores de C
Un Operador es un símbolo que permite relacionar dos datos en una expresión y evaluar
el resultado de la operación.
Los programas de las computadoras se apoyan esencialmente en la realización de
numerosas operaciones aritméticas y matemáticas de diferente complejidad.
Los operadores fundamentales son:
• Aritméticos.
• Relacionales.
• Lógicos.
• Asignación.

8. 4
6.1. Tipos de operadores
6.1.1. Operadores aritméticos
6.1.2. Operadores de asignación en C

9. 5
6.1.3. Operadores relacionales
6.1.4. Operadores lógicos

10. 6
7. Size Of
Esta función u operador se usa para mostrar el tamaño de una cadena, por lo
general cuando cuenta la cadena empieza desde “0” hasta el tamaño que
tenga.
- Con el comando Size of medimos cuanto espacio en memoria ocuparía
la variable, y como se observa nos dio resultado 4 bytes siendo un
entero.
8. Cast
El comando Cast seutiliza para castear o cambiar valores, pasar de un tipo de
dato a otro.
8.1. Sintaxis

11. 7
9. Sintaxis para declarar una variable
<Tipo de dato> <Nombre del identificador>;
<Tipo de dato> <Nombre del identificador> = <Inicialización>;
10. Arreglos
Un arreglo es un tipo de dato estructurado que almacena en una sola variable un conjunto
limitado de datos o elementos del mismo tipo.
Es un conjunto de localidades de memoria contiguas donde la dirección más baja
corresponde al primer elemento y la dirección más alta al último.
Un arreglo se caracteriza por:
1. Ser una lista de un número finito de n elementos del mismo tipo.
2. Almacenar los elementos del arreglo en memoria contigua.
3. Tener un único nombre de variable que representa a todos los elementos y éstos se
diferencian por un índice o subíndice.
4. Acceder de manera directa o aleatoria a los elementos individuales del arreglo, por el
nombre del arreglo y el índice o subíndice.
10.1. Arreglos unidimensionales
Un arreglo unidimensional es un conjunto de n elementos del mismo tipo almacenados en
memoria continua en un vector o lista.Para accedera cadaelemento del arreglo serequiere
de un solo índice o subíndice, el cual representa la posición en la que se encuentra.
10.1.1. Sintaxis de arreglos unidimensionales
<tipo_dato><identif_arreglo>[<tam_arreglo>];

12. 8
10.1.2. Ejemplo de arreglo unidimensional
10.2. Arreglo Bidimensional
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.
10.2.1. Sintaxis arreglo Bidimensional
<tipo_dato> <ident_arr> [<tam_fila>][<tam_col>];
10.2.2. Ejemplo de arreglo Bidimensional

13. 9
11. Estructuras
La programaciónestructuradaes un paradigmao formade programar. Es un conjuntode técnicas
que nos permitendesarrollarprogramas fáciles de escribir, verificar, leer y mantener e incluyen:
1. Diseño descendente (top-down).
2. Estructuras de datos.
3. Estructuras de control.
4. Programación modular.
11.1. Sintaxis de struct
<struct> <identificador>{
<Tipo de dato> <Identificador>= <Inicialización>;
};

14. 10
11.2. Ejemplo de estructuras

15. 11

16. 12
12. Printf y scanf
Mediante la función printf podemos escribir datos en el dispositivo de salida estándar
(pantalla). Complementariamente a scanf, printf puede escribir cualquier
combinación de valores numéricos, caracteres sueltos y cadenas de caracteres. La
función printf transporta datos desde la memoria a la pantalla, a diferencia de scanf,
que envía datos desde el teclado para almacenarlos en la memoria. La función printf
devuelve el número de caracteres escritos. Si devuelve un valor negativo indica que
se ha producido un error.
12.1. Sintaxis de printf y scanf
printf (cadena de control, lista de argumentos);
En donde cadena de control hace referencia a una cadena de caracteres que
contiene información sobre el formato de la salida y la lista de argumentos son
argumentos que representan los datos de salida.
A diferencia de la función scanf, los argumentos en la función printf no representan
direcciones de memoria y por tanto no son precedidos por &. Además, dentro de los
argumentos se pueden incluir referencias a funciones.
En la cadena de control se incluyen grupos individuales de caracteres cada uno de
los cuales deben comenzar por %. Normalmente, un grupo de caracteres estará
formado por el signo de porcentaje seguido de un carácter de conversión que indica
el tipo del dato correspondiente (debe haber igual número de caracteres de
conversión como de argumentos).
12.2. Tabla de caracteres de conversión

17. 13
13. Entrada y salida sin formato
Las funciones principales que realizan la entrada y salida sin formato son:
getche() L ee un carácter del teclado, no hay que esperar hasta que se pulse la tecla
<enter>. Visualiza el eco del carácter.
getchar() Lee un carácter del teclado, espera hasta que se pulsa la tecla <enter>.
getch() Lee un carácter del teclado, no hay que esperar que se pulse la tecla
<enter>. No visualiza el eco del carácter.
putchar() Imprime un carácter en la pantalla en la posición actual del cursor.
gets() Lee una cadena de caracteres introducida por el teclado.
puts() Imprime una cadena en la pantalla, seguida de un carácter de salto de línea.
fflush (stdin) Limpia el buffer (memoria intermedia) utilizado por la entrada estándar
del sistema, generalmente el teclado.
fflush (stdout) La función printf no escribe directamente en la pantalla, sino en una
memoria intermedia (buffer). Cuando este buffer (memoria intermedia) se llena o
cuando oprimimos un carácter ‘ n’ es cuando se envía el texto a la pantalla. La
función fflush(stdout) lo que hace es enviar a la pantalla lo que hay en ese buffer.
14. Sentencias de control
14.1. If- else
Son una estructura de control, que nos permiten tomar cierta decisión al interior de
nuestro algoritmo, es decir, nos permiten determinar qué acciones tomar dada o no
cierta condición, por ejemplo determinar si la contraseña ingresada por el usuario
es válida o no y de acuerdo a esto darle acceso al sistema o mostrar un mensaje de
error.
14.1.1. Sintaxis de if-else
if (expresión) {
sentencia1}
else {
sentencia}

18. 14
14.2. else-if
14.2.1. sintaxis else-if
if (expresión1) {
sentencia1}
else if(expresión2){
sentencia2}
else if(expresión3) {
sentencia3}
...
else {
sentencian }
14.3. switch
Esta sentencia es una generalización de las sentencias if...else. la expresión a
evaluar será entera, por lo tanto, el número de opciones es mucho mayor, y en
consecuencia, también es mayor el número de diferentes sentencias que se pueden
ejecutar.
Cuando se usa la sentencia switch el control se transfiere al punto etiquetado con
el case cuya expresión constante coincida con el valor de la expresión entera
evaluada dentro del switch. A partir de ese punto todas las sentencias serán
ejecutadas hasta el final del switch, es decir hasta llegar al "}".
14.3.1. Sintaxis de switch
switch (<expresión entera>)
{
[case <expresión_constante1>: [<sentencias1>]];
Break;
[case <expresión_constante2>: [<sentencias2>]];
Break;
...
[case <expresión_constanten>: [<sentenciasn>]];
Break;
[default : [<sentencia>]];
Break; }

19. 15
14.4. Bucle While
Los ciclos while son también una estructura cíclica, que nos permite ejecutar una o
varias líneas de código de manera repetitiva sin necesidad de tener un valor inicial
e incluso a veces sin siquiera conocer cuándo se va a dar el valor final que
esperamos, los ciclos while, no dependen directamente de valores numéricos, sino
de valores booleanos, es decir su ejecución depende del valor de verdad de una
condición dada, verdadera o falso, nada más. De este modo los ciclos while, son
mucho más efectivos para condiciones indeterminadas, que no conocemos cuando
se van a dar a diferencia de los ciclos for, con los cuales se debe tener claro un
principio, un final y un tamaño de paso.
14.4.1. Sintaxis de While
while(condiciónde finalización){
....
....
Bloque de Instrucciones
....
....}
14.5. Ciclo For
Los ciclos for son lo que se conoce como estructuras de control de flujo cíclicas o
simplemente estructuras cíclicas, estos ciclos, como su nombre lo sugiere, nos
permiten ejecutar una o varias líneas de código de forma iterativa, conociendo un
valor especifico inicial y otro valor final, además nos permiten determinar el tamaño
del paso entre cada "giro" o iteración del ciclo.
14.5.1. Sintaxis de For
for(inti = valor inicial;i <= valorfinal;i = i + paso) {
....
....
Bloque de Instrucciones....
....
....}

20. 16
14.6. Ciclos 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, de este
modo los ciclos do-while, son más efectivos para algunas situaciones específicas.
En resumen un ciclo do-while, es una estructura de control cíclica que permite
ejecutar de manera repetitiva un bloque de instrucciones sin evaluar de forma
inmediata una condición específica, sino evaluándola justo después de ejecutar por
primera vez el bloque.
14.6.1. Sintaxis do-while
do {
...
....
Bloque de Instrucciones....
....
.... }
while(condición de finalización);

21. 17
15. Ficheros
Es simplemente un flujo externo que se puede abrir para entrada (dando lugar a un
flujo de archivo de entrada que, para simplificar, llamaremos simplemente archivo o
fichero de entrada), para salida (dando lugar a un flujo de archivo de salida que,
para simplificar, llamaremos simplemente archivo o fichero de salida) o para
entrada-salida (archivo o fichero de entrada-salida o archivo de E/S).
15.1. Función fopen
Esta función sirve para abrir y crear ficheros en disco. El valor de retorno es un
puntero a una estructura FILE.
15.1.1. Sintaxis
FILE *fopen(char *nombre, char *modo);
15.1.2. Parámetros de entrada
- nombre: una cadena que contiene un nombre de fichero válido, esto depende
del sistema operativo que estemos usando. El nombre puede incluir el
camino completo.
- modo: especifica en tipo de fichero que se abrirá o se creará y el tipo de datos
que puede contener, de texto o binarios:
 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 binar

22. 18
15.2. función fclose
Es importante cerrar los ficheros abiertos antes de abandonar la aplicación. Esta
función sirve para eso. Cerrar un fichero almacena los datos que aún están en el
buffer de memoria, y actualiza algunos datos de la cabecera del fichero que
mantiene el sistema operativo. Además permite que otros programas puedan abrir
el fichero para su uso. Muy a menudo, los ficheros no pueden ser compartidos por
varios programas.
Un valor de retorno cero indica que el fichero ha sido correctamente cerrado, si ha
habido algún error, el valor de retorno es la constante EOF. El parámetro es un
puntero a la estructura FILE del fichero que queremos cerrar.
15.2.1. Sintaxis de fclose
int fclose(FILE *fichero);
15.3. Función fgetc
Esta función lee un carácter desde un fichero.
El valor de retorno es el carácter leído como un unsigned char convertido a int. Si
no hay ningún carácter disponible, el valor de retorno es EOF. El parámetro es un
puntero a una estructura FILE del fichero del que se hará la lectura.
15.4. Sintaxis de fgetc
int fgetc(FILE *fichero);
15.5. Función feof
Esta función sirve para determinar si el cursor dentro del archivo encontró el final
(end of file). Existe otra forma de verificar el final del archivo que es comparar el
caracter que trae fgetc del archivo con el macro EOF declarado dentro de stdio.h,
pero este método no ofrece la misma seguridad (en especial al tratar con los
archivos "binarios"). La función feof siempre devolverá cero (Falso) si no es
encontrado EOF en el archivo, de lo contrario regresará un valor distinto de cero
(Verdadero).
15.5.1. Sintaxis feof
int feof(FILE *fichero);
15.6. Función rewind y sintaxis
Literalmente significa"rebobinar",sitúael cursorde lectura/escrituraal principiodel archivo.
Y su sintaxises:
voidrewind(FILE*fichero);

23. 19
15.7. Función fgets y sintaxis
Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-1
caracteres o hasta que lea un cambio de línea 'n' o un final de archivo EOF. En este
último caso, el carácter de cambio de línea 'n' también es leído.
El prototipo correspondiente de fgets es:
char *fgets(char *buffer, int tamaño, FILE *archivo);
El primer parámetro buffer lo hemos llamado así porque es un puntero a un espacio
de memoria del tipo char (podríamos usar un arreglo de char). El segundo parámetro
es tamaño que es el límite en cantidad de caracteres a leer para la función fgets. Y
por último el puntero del archivo por supuesto que es la forma en que fgets sabrá a
que archivo debe leer.
15.8. Función fread y sintaxis
size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
Esta función lee un bloque de una "stream" de datos. Efectúa la lectura de un arreglo
de elementos "count", cada uno de los cuales tiene un tamaño definido por "size".
Luego los guarda en el bloque de memoria especificado por "ptr". El indicador de
posición de la cadena de caracteres avanza hasta leer la totalidad de bytes. Si esto
es exitoso la cantidad de bytes leídos es (size*count).
PARAMETROS:
ptr : Puntero a un bloque de memoria con un tamaño mínimo de (size*count) bytes.
size : Tamaño en bytes de cada elemento (de los que voy a leer).
count : Número de elementos, los cuales tienen un tamaño "size".
stream: Puntero a objetos FILE, que especifica la cadena de entrada.
15.9. Fscanf y sintaxis
La función fscanf funciona igual que scanf en cuanto a parámetros, pero la entrada
se toma de un fichero en lugar del teclado.
La sintaxis es:
int fscanf(FILE *fichero, const char *formato, argumento, ...);

24. 20
15.10. fputc y sintaxis
Esta función escribe un carácter a la vez del archivo que esta siendo señalado con
el puntero *archivo. El valor de retorno es el carácter escrito, si la operación fue
completada con éxito, en caso contrario será EOF.
La sintaxis es:
int fputc(int carácter, FILE *archivo);
15.11. Función fputs y sintaxis
La función fputs escribe una cadena en un fichero. la ejecución de la misma no
añade el carácter de retorno de línea ni el carácter nulo final. El valor de retorno es
un número no negativo o EOF en caso de error. Los parámetros de entrada son la
cadena a escribir y un puntero a la estructura FILE del fichero donde se realizará la
escritura.
La sintaxis es:
int fputs(const char *buffer, FILE *archivo);
15.12. función fwrite
Esta función está pensada para trabajar con registros de longitud constante y forma
pareja con fread. Es capaz de escribir hacia un fichero uno o varios registros de la
misma longitud almacenados a partir de una dirección de memoria determinada. El
valor de retorno es el número de registros escritos, no el número de bytes. Los
parámetros son: un puntero a la zona de memoria de donde se obtendrán los datos
a escribir, el tamaño de cada registro, el número de registros a escribir y un puntero
a la estructura FILE del fichero al que se hará la escritura.
La sintaxis es:
size_t fwrite(void *puntero, size_t tamano, size_t cantidad, FILE *archivo);
15.13. fprintf y sintaxis
La función fprintf funciona igual que printf en cuanto a parámetros, pero la salida se
dirige a un archivo en lugar de a la pantalla.
El prototipo correspondiente de fprintf es:
int fprintf(FILE *archivo, const char *formato, argumento, ...);

25. 21
16. Funciones
Una función es un conjunto de líneas de código que realizan una tarea específica y
puede retornar un valor. Las funciones pueden tomar parámetros que modifiquen
su funcionamiento. Las funciones son utilizadas para descomponer grandes
problemas en tareas simples y para implementar operaciones que son comúnmente
utilizadas durante un programa y de esta manera reducir la cantidad de código.
Cuando una función es invocada se le pasa el control a la misma, una vez que esta
finalizó con su tarea el control es devuelto al punto desde el cual la función fue
llamada.
16.1. Ejemplo de una función
16.2. Parámetros
Normalmente, las funciones operan sobre ciertos valores pasados a las mismas ya
sea como constantes literales o como variables, aunque se pueden definir funciones
que reciban parámetros. Existen dos formas en C++ de pasar parámetros a una
función; por referencia o por valor. El hecho es que si en una declaración de función
se declaran parámetros por referencia, a los mismos no se les podrá pasar valores
literales ya que las referencias apuntan a objetos (variables o funciones) residentes
en la memoria; por otro lado, si un parámetro es declarado para ser pasado por
valor, el mismo puede pasarse como una constante literal o como una variable. Los
parámetros pasados por referencia pueden ser alterados por la función que los
reciba, mientras que los parámetros pasados por valor o copia no pueden ser
alterados por la función que los recibe, es decir, la función puede manipular a su
antojo al parámetro, pero ningún cambio hecho sobre este se reflejará en el
parámetro original.
16.2.1. Parámetros por valor
La función cuadrado() (ver arriba) es un clásico ejemplo que muestra el paso de
parámetros por valor, en ese sentido la función cuadrado() recibe una copia del
parámetro n. En la misma función se puede observar que se realiza un calculo
( n*n ), sin embargo el parámetro original no sufrirá cambio alguno, esto seguirá
siendo cierto aún cuando dentro de la función hubiera una instrucción parecida a
n = n * n; o n*=n;

26. 22
16.2.2. Parámetros por referencia
Para mostrar un ejemplo del paso de parámetros por referencia, vamos a retomar
el caso de la función cuadrado, salvo que en esta ocasión cambiaremos ligeramente
la sintaxis para definir la misma.
16.3. Llamar a una función
Para llamar a la función cuadrado() vista anteriormente, podemos emplear:
16.4. Funciones void
Bajo ciertas circunstancias se deseará escribir funciones que no regresen valor
alguno (esto sería algo parecido a escribir procedures en Pascal) y para ello
podemos declarar a la función como void. La palabra reservada void es utilizada
para declarar funciones sin valor de retorno y también para indicar que una función
específica no requiere de parámetros.