UNIVERSIDAD TECNOLÓGICA DE PANAMÁ

FACULTAD DE INGENIERÍA DE SISTEMAS COMPUTACIONALES

DEPARTAMENTO DE PROGRAMACIÓN DE COMPUTADORAS

Asignatura:
Programación de Computadoras I

Código de Asignatura:
3015

Tema:
Lenguaje de Programación C

Docente:
Ing. Doris E. Gutiérrez Rosales Msc.

Año:
2015
 Índice

Contenido
Contenido ............................................................................................................................... 3
Introducción al lenguaje C..................................................................................................... 3
Características de C ............................................................................................................ 3
Reglas generales del C ............................................................................................................ 3
Estructura de un Programa en C ......................................................................................... 4
Elementos básicos del C ......................................................................................................... 7
Identificadores palabras reservadas .................................................................................... 7
Palabras reservadas ............................................................................................................. 8
Tipos de datos básicos ........................................................................................................ 8
Constantes........................................................................................................................... 9
Variables ........................................................................................................................... 10
Clases de almacenamiento ................................................................................................ 11
Entrada y salida de datos ...................................................................................................... 12
scanf() ............................................................................................................................... 13
Gets() ................................................................................................................................ 13
Printf() .............................................................................................................................. 14
Entradas y salidas sin formato .......................................................................................... 15
Operaciones y expresiones ................................................................................................... 16
Operadores aritméticos. .................................................................................................... 17
Operadores monarios ........................................................................................................ 18
Operadores relacionales y lógicos. ................................................................................... 19
Operadores de asignación ................................................................................................. 20
Sentencias de Control ........................................................................................................... 21
Sentencia If ....................................................................................................................... 21
Sentencia de Selección Múltiple (switch) ........................................................................ 23
Sentencia While ................................................................................................................ 23
Sentencia Do While .......................................................................................................... 24
Sentencia For .................................................................................................................... 24
 Contenido

Introducción al lenguaje C
El lenguaje de programación C, fue desarrollado por Dennis Ritchie en los Laboratorios
BELL AT&T, basándose en el lenguaje B, creado por Ken Thompson. El mismo se utilizó
para escribir y mantener es sistema operativo UNIX.

C fue desarrollado como un lenguaje de programación de sistemas, es decir, un lenguaje de

programación para escribir sistemas operativos y utilidades propias del sistema. S e cataloga
como un lenguaje de nivel medio, puesto que combina elementos de lenguajes de alto nivel
(Fortran, Pascal, Basic, etc.) con la funcionalidad del lenguaje ensamblador.

Características de C
C es un lenguaje de programación que maneja un conjunto de elementos que lo hacen ser
muy flexible al momento de desarrollar programas, algunas de sus características son:
 Lenguaje Compilado: Convierte el código fuente en un fichero objeto y éste en un
fichero ejecutable.
 Lenguaje de Nivel Medio: Combina elementos de lenguaje de alto nivel con la
funcionalidad del lenguaje Ensamblador.
 Lenguaje Estructurado: Permite crear procedimientos en bloques dentro de otros
procedimientos.
 Lenguaje Portable: Permite utilizar el mismo código en diferentes equipos y
sistemas informáticos; es independiente de la arquitectura de cualquier máquina en
particular.

Reglas generales del C

1. Todos los elementos en C, deben contener la función main().
2. Todas las sentencias deben terminar con punto y coma (;).
3. Se deben declarar todos los objetos, variables, constantes etc, antes de ser utilizados.
 4. Toda función debe comenzar con un paréntesis de llave “{“ y debe cerrarse con un
paréntesis de llave “}”, por ejemplo:
Nombre de la función()
{
Sentencia 1;
Sentencia 2;
.
.
.
Sentencia n;
}
5. Los comentarios empiezan con un /* y terminan con */, cuando se desee encerrar
bloques de comentarios y el // cuando es una sola línea de comentario.
6. Hace diferencia entre las mayúsculas y las minúsculas en los nombres de
identificadores creados por el usuario y los estándares. Regla válida para cualquier
instrucción en el lenguaje.

Estructura de un Programa en C
La estructura típica completa de un programa en C, debe contemplar el siguiente esquema:
 Directiva del procesador: Son instrucciones que se le dan al compilador antes de que el
programa se compile. Estas instrucciones pueden ser funciones predefinidas, datos,
macros, archivos fuentes adicionales, pero su uso más frecuente en C es la inclusión de
archivos cabeceras estándares tales como: stdio.h, math.h, string.h. que en un momento
dado pueden requerir los programas elaborados por el ususario.
El orden de los archivos de inclusión no importa, lo que si se requiere es que se declare
antes de utilizar funciones propias de una directiva.
Formato:
#tipo de directiva <nombre del archivo.extensión>
#include “nombre del archivo.extensión”
Ejemplo:
#include <stdio.h>
#include “graficos.h”
 Los símbolos (< >) no son parte del nombre de la directiva, se utilizan para indicar que
el archivo es un archivo de la biblioteca estándar de C.
El primer formato indica que los archivos se encuentran en el directorio por defecto
include, y en el segundo se indica que el archivo está en el directorio actual. En un
programa pueden estar presetnes ambos, si el archivo que desea incluir no se encuentra
en el directorio actual ubique la ruta completa.
Ejemplo:
#include “d:\materia\programa\grafo.h\”
 Directiva define: indica al procesador que defina un elemento de dato u operación
para el programa C.
Formato:
#define nombre del identificador valor
Ejemplo:
#define linea 25
 Declaraciones globales: Indican al compilador que las funciones y/o variables definidas
por el programador son comunes a todas las funciones del programa. Deben ser
declaradas antes de la función main.
Formato:
tipo de dato nombre del identificador;
declararión de funciones.
Ejemplo:
int grados;
float raiz()
{
x = sqrt(4);
}
Si “grado” y “raiz” son declaradas globales cualquier función del programa incluyendo
el main pueden tener acceso a ellas.
 Definición de otras funciones: Módulos de programas que realizan tareras específicas.
Son ejeutadas desde el main o desde otra función.
Formato:
tipo de dato de la función nombre de la función ()
{
sentencia 1;
sentencia2;
return expresión;
}
Ejemplo:
int suma(int a, int b)
{
return a + b;
}
 Función principal main: Todo programa en C debe incluirla e indica el punto de entrada
al programa.
El cuerpo principal es un conjunto de sentencias delimitado por dos llaves, una al inicio
después de los paréntesis del main “{“ y otra al final de la función “}”.
Una función en C es un grupo de instrucciones que realizan una o más acciones.

Figura 1. Ejemplo de un programa completo en C.

Elementos básicos del C
Un programa en C requiere de un conjunto de elementos que le permiten al usuario escribir
diversas instrucciones para ser funcional. A continuación veremos los elementos que pueden
ser manejados por un programa en C.
Identificadores palabras reservadas
Son nombres diseñados por el usuario, que se componen de una secuencia de caracteres
(letras, números y subrayados). Se utilizan para identificar objetos, variables, constantes,
funciones, etiquetas u otros elementos que el usuario requiera.
Reglas para formar nombres de identificadores
 El primer carácter debe ser una letra.
 No hay límites para la longitud del nombre de un identificador, pero se recomienda
utilizar un máximo de 10 caracteres.
 Los nombres de identificadores son sensibles a mayúsculas.
 Los identificadores no pueden ser palabras reservadas.

Recomendaciones
 Escribir identificadores de variables con letras minúsculas.
 Escribir identificadores de constantes con letras mayúsculas.
 Escribir identificadores de funciones tanto con mayúsculas como con minúsculas.
Ejemplo:

Calcular_Media pobla población

Total2006 balance SALDO

Palabras reservadas
Las palabras reservadas son identificadores predefinidos por un lenguaje de programación
que tienen significados especiales y no se pueden utilizar como identificadores de sus
programas.
Ejemplos:

case char float for

continue void return short

Tipos de datos básicos

C no soporta un gran número de tipos de datos estándares, pero tien la capacidad de crear sus
propios tipos de datos. En C se manejan tres tipos de datos básicos, estos son:
 Enteros: Son valores numéricos que pueden tomar como máximo cinco dígitos, tanto
positivo como negativo, y debe estar en el rango de -32,768 y + 32,768. El signo
positivo, el negativo y la falta de signo son manejados de igual manera. Se tiene
dentro de los enteros al int, long, short, y unsigned int, y el uso de cada uno dependerá
de la cantidad de dígitos que requiera su aplicación.
 Reales (float, double): Los reales con valores numéricos que representan una parte
entera y una fraccionaria. Tiene dos maneras de representarse en punto fijo y en punto
flotante. Dentro de los reales podemos contar con float y doublé y el uso de uno u
otro dependerá de la cantidad de dígitos que se desea manejar.
Los números flotantes son siempre con signo positivo y en el caso que se utilice el
formato de exponentes, si el mismo es positivo puede obviarse el signo del mismo.
 Caracteres y Cadenas de Caracteres: Elemento(s) de un conjunto de caracteres
predefinidos. La mayoría de las computadoras utilizan el conjunto de caracteres
ASCII. Cuando manejamos un solo carácter los mismos se almacenan como números,
por ejemplo, la letra A, se representa a través del número 65, la letra B es, 66.
Puesto que los caracteres se almacenan internamente como números, se pueden
realizar operaciones aritméticas con tipos de datos char.
Ejemplo:
char car =a;
car = car + 32;
 C procesa datos carácter como cadenas, a través del tipo de dato char, especificando
la longitud máxima a tomar. Los caracteres de una cadena de caracteres son
almacenados en localizaciones sucesivas de memoria.
Cada cadena de caracteres es finalizada automáticamente por el carácter nulo
representado por la secuencia de escape \0, para ello debe ser contemplado en el largo
cuando el mismo se ubica, sino se pierde.
Ejemplo:
char nombre [15];
Ana Caballeros se pueden representar un máximo de 14 caracteres, el otro
espacio se reserva para el carácter nulo de finalización de cadena.

Tipo de datos Tamaño(byte) Rango de valores Ejemplo

short 2 -128…127 106

int 2 -32768…32767 5667

unsigned int 2 0…65535 658

long 4 2147483648…2147483647 345673

float 8 3.4*(10-38)…3.4*(1038) 16.98

double 8 1.7*(10-308)…1.7*(10308) 0.0006

char 1 0…255 ‘m’

Constantes
Son aquellas cuyos contenidos no cambian durante la ejecución de un programa; en C existen
cuatro tipos de constantes:
 Constantes enteras: const int monto = 2345;
 Constantes reales: const float real = 5.8;
 Constantes de un solo caracter: const char sw = ‘F’;
 Constantes de caracteres: const char aux[18] = “Programación en C”;
Variables
A diferencia de las constantes, el valor de las variables puede cambiar a lo largo de la
ejecución del programa.
Generalidades de la declaración de variables
 La declaración debe situarse siempre al principio de la función creada o al inicio
de la función main antes de cualquier sentencia ejecutable.
 Su ámbito de trabajo es el bloque donde está declarada.
 Toda variable utilizada en el programa debe ser previamente declarada.
 La declaración reserva un espacio de almacenamiento en memoria por cada
elemento que su programa manipule.

Declaraciones
Formato de declaración
tipo de dato nombre del identificador;

Ejemplo:
char enter; /*indica que se reserva un espacio en memoria para enter, en
este caso, un carácter ocupa un byte*/
int conta = 0; /*se declara e inicializa a cero la variable entera conta*/.

Formato de declaración e inicialización

tipo de dato nombre del identificador = valor;

Ejemplo:
float monto = 0.00;
int limite = 100
char código = ‘s’;

Una variable declarada fuera del bloque main, es por defecto global, y es accesible en el resto
del programa en el que está declarado. Por el contrario una variable declarada dentro del
bloque main es local y accesible solamente dentro de éste.
Clases de almacenamiento
Por defecto todas las variables llevan asociada una clase de almacenamiento que determina
su existencia y accesibilidad.

Tipo de Descripción Utilización

almacenamiento
auto automático Solamente con variables locales
register en un registro Solamente con variables locales
static estático Solamente con variables o funciones globales
extern externo Con variables locales, globales o funciones

Una variable declarada static es inicializada solamente una vez, cuando comienza la
ejecución del programa. No es reinicializada cada vez que se ejecuta el bloque que la
contiene. Si no es inicializada explícitamente, se inicializa automáticamente en 0.

Ejemplo:
int n = 15;
int suma ()
{
int n1 = 15;
static n2 = 5;
n2+=5;
return n1 + n2;
}
main()
{
static int num; //su valor inicial es cero (0)
register int n1=0; /*almacenada en un registro si es posible*/
int n2 = 50, n3 = 34; /*declarada como auto por defecto*/
printf("%d %d \n", suma (n1,n2),num);
}
Entrada y salida de datos
Las operaciones de entrada y salida no forman parte del conjunto de sentencias de C, sino
que pertenecen al conjunto de funciones de la librería estándar de C. Por ello, todo programa
que utilice funciones de entrada/salida requiere de las funciones prototipos definidas en la
cabecera del programa a través de la directiva inlcude.
Para manejar la entrada y salida de datos se necesita la librería stdio.h
Formato:
#include <stdio.h>
Las entradas o salidas para se utilizadas en C requieren de un conjunto de caracteres
denominados caracteres de especificación, los cuales son usados para indicar el tipo de dato
que va a ser tratado en la lectura y/o impresión.
Caracter de Tipo de dato Explicación
especificación
%d int Entero con signo (6 dígitos)
%i int Entero con signo
%u int Entero con signo
%f double Flotante con signo de la forma (+ ,-) ddd.dd
%e double Flotante con signo de la forma (+ ,-) d.ddde(+ ,-) ddd
%c char Un solo caracter
%s char Cadena de caracteres sin espacios en blanco
%[^\n] char Cadena de caracteres con espacios en blanco
%o int Octal con signo (0-7)
%x int Hexadecimal con signo(0-9, A-F)
%ld long Entero grande
%lf double Reales
scanf()
La entrada de datos puede ser realizada desde diferentes dispositivos de entrada, pero con la
que vamos a trabajar a continuación es el teclado, para ello se utiliza la función scanf()
Formato:
scanf(“caracter de especificación”,&var1, &var2,…,&varn);
Ejemplo:
int a;
float b;
char c;
scanf(“%d %f %c”,&a, &b,&c);

Gets()
La bibilioteca de C tiene una función específica para trabajar las cadenas, la cual lee una
cadena hasta teclear “ENTER”, colocándose automáticamente al final de cadena \n o
caracter nulo \0.

Formato:
gets(var-cadena);

Ejemplo:
char nom[20];
printf(“Introduzca su nombre”);
gets(nom);

Siempre que se defina una cadena, se hará con un espacio más al espacio previsto como
máxima longitud para el caracter del fin de cadena.

Cuando se lee un carácter o una cadena de caracteres varias veces hay que utilizar la
función fflush(stdin) para limpiar el flujo de entrada porque al presionar enter queda
ese carácter en el flujo.
 Ejemplo:
#include <stdio.h>
#include <conio.h>

main()
{
char m[20];
clrscr();
printf("Ingrese la cadena");
scanf("[^\n]", m);
fflush(stdin.h);
getch();
}

Printf()
Permite mostrar en pantalla todos los resultados del programa al igual que los mensajes que
se deseen.
Formato:
printf(“cadena de control”, objeto); donde

Cadena de control puede ser caracteres de especificación, o constante de cadena o secuencia escape
o una combinación de lo anterior.
Objeto puede ser una variable, constante, expresión, o una combinación de ellas.

Ejemplo:
printf(“Introduzca su nombre”);

Secuencia de escape
Caracter Descripción
\n Salto de línea
\a Campana
\b Retroceso del carro (1 espacio)
\t Avance del carro (6 espacios)
\” Aparece la doble comilla
\\ Aparece la barra \
\? Aparece el signo ?
También es posible especificar el máximo números de cifras decimales para un valor en como
flotante, o el máximo número de caracteres. Esta especificación se denomina precisión. La
precisión es un entero sin signo que siempre es precedido por un punto decimal. Si se
especifica la longitud de campo además de la precisión, entonces la especificación de campo
debe preceder a la precisión y ambas preceden al carácter de conversión.
Formato:
%6.2f
Precisión
Longitud del campo

Ejemplo:
float i = 2.0, j = 3.0;
float x =890.476;
printf(“%f %f %f %f”, I,j,i+j,sqrt(i+j)); /*salida: 2.000000 3.000000 5.000000
2.0236068*/
printf(“%f %7.3f %7.1f”, x,x,x); /*salida: 890.476 890.476 890.5*/

Un número en como flotante se redondeará si se debe ajustar la precisión especificada. Ahora

no es necesario que la especificación de precisión vaya acompañada de la longitud de campo
mínima, pero la precisión debe seguir apareciendo después del punto decimal.

printf(“%.3f %.1f”, x,x,x); /*salida: 890.476 890.476 890.5*/

Entradas y salidas sin formato

Las siguientes funciones son para leer un solo caracter del teclado.
getchar():
 Se ve el carácter tecleado en la pantalla.
 Se debe dar enter para aceptarlo
Ejemplo:
//Permite introducir n cantidad de caracteres hasta que sea fin
#include <stdio.h>
main()
{
 int c;
while((c=getchar()) != ‘\n’) /*cuando se da enter al pulsar el carácter el C
putchar (c); toma -1*/
}

getch():
 No se ve el caracter tecleado en la pantalla.
 No se da enter, pero lo acepta.

Ejemplo:
char c;
getch(); o c = getch();

getche():
 Se ve el caracter tecleado en la pantalla.
 No se da enter, pero lo acepta.

Ejemplo:
char c;
getche(); o c = getche();

Salida sin formato para cadenas

PUTCHAR(): Imprime un solo caracter

Ejemplo:
char c;
c = getchar();
putchar(c);

PUTS(): Imprime una cadena hasta encontrar \n.

Ejemplo:
Char nom[20];
printf(“Introduzca su nombre: “);
gets(nom);
printf(“\n nombre: “);
puts(nom);

Operaciones y expresiones
Expresiones: puede ser una variable, constante, funciones predefinidas combinados e
interrelacionados a través de operadores. En c tenemos expresiones:
Aritméticas
 3+4 = 7
Lógicas
A>B
Los datos sobre los cuales actúan los operadores se les denomina operandos. Algunos
operadores requieren dos operando, mientras que otros actúan sobre uno.
Operadores: Son símbolos que indican como son manipulados los datos. Veremos:
Operadores aritméticos.
Trabajan sobre valores numéricos, enteros, reales y char; en C existen 5 operadores
aritméticos.
Operador Descripción Ejemplo

+ Suma 3+4=7

- Resta 10.00-4 = 6.00

* Multiplicación 5 *6 = 30

/ División 15 / 3 = 5

% Residuo de una división 10 % 3 = 1

No existe operador de exponenciación en C, sin embargo la función pow(a,c) realiza la

exponenciación a cualquier potencia.
El operador % requiere que los dos operandos sean enteros y el segundo no puede ser cero.

Conversiones de tipo en expresiones

Cuando se mezclan constantes y variables de diferentes tipos en una expresión, el compilador
C las convierte al mismo tipo. Convierte todos los operandos al tipo del operando más grande
en una operación según la base de esta operación:
 Todos los char y short se convierten a int.

 Todos los float se convierten a double.

Operadores monarios
Son operadores que actúan sobre un solo operando, para producir un nuevo valor. Los
operadores monarios suelen preceder a su único operando, aunque algunos operadores
monarios se escriben después de su operando.

Operador monario Descripción

++ Incremento de 1

-- Decremento de 1

Formato:
Operador monario valor numérico

Ejemplo (utilizado sin el =)

++x ó x++ equivalen a x = x+1
--x ó x-- equivalen a x = x-1

Ejemplo: (cuando se utiliza con el =)

X=10;
Y=++x; //suma primero y después asigna
//resulta x =10, y =11
X=10;
Y=x++; //primero asigna y después suma
//resulta x =11, y =10

Jerarquía de operación

1 ()
2 ++, --
3 *,/,%
4 +, -
Operadores relacionales y lógicos.
Operadores relacionales: Siempre devuelve 1 0 dependiendo del resultado de la prueba:
0 es falso
1 es cierto

Operador relacional Descripción

< Menor que
<= Menor o igual a
> Mayor que
>= Mayor o igual a
== Igual a
!= No igual, distinto que

Operadors lógicos

Operador Descripción
relacional
&& AND Da como resultado 1, si ambas comparaciones son ciertas.

|| OR Si una de las comparaciones es 1(cierta) el resultado es 1.

! NOT El resultado es 0, si la comparación es 1; y es 1 si la comparación es

0

Jerarquía
1 !

2 <,<=,>,>=
3 ==, !=
4 &&
5 ||
Operadores de asignación
En una operación de asignación el valor de derecha es convertido al tipo del valor de la
izquierda.

Operador Descripción
relacional
= Asignación

*= Multiplicación más asignación

/= División más asignación

%= Módulo más asiganción

+= Suma más asignación

-= Resta más asignación

<<= Desplazamiento a la izquierda más asignación

>>= Desplazamiento a la derecha más asignación

Ejemplos:
x*=3; //equivale a x =x*3;
x*=n-3 //x = x*(n-3)
Sentencias de Control
Cuando hay un conjunto de sentencias a realizar por la parte cierta o por la parte falsa, hay
que utilizar llaves para indicar el inicio y fin de bloque en C.
Sentencia If
En la programación es escencial el manejo de bifurcaciones (si-entonces), en el Lenguaje C
se usa la sentencia if().
 Sentencia if (simple)
Formato
if(condicion)
{
Sentencia;

}
Ejemplo
#include <stdio.h>
int main()
{
int i;
printf("Introduzca un número: ");
scanf("%d",&i);
if(i<0)
printf("El número es negativo\n");
else
printf("El número es positivo o cero\n");
return 0;
}

Las acciones dentro de las llaves {} se ejecutarán siempre y cuando se cumpla la condición
especificada entre los peréntesis (). También es posible omitir las llaves si se fuera a ejecutar
una sola acción.
La condición puede ser cualquier expresión lógica como por ejemplo a<=b ó x!= 0 ó z+10 <
a && b>0, entre otras.
 Sentencia if (compuestos)
Formato
if (expresión)
sentencia(s);
else
if(expresión)
sentencia(s);
else
sentencia(s);

Ejemplo:
if(c ==1)
printf(“soltero”);

else if(c ==2)

printf(“casado”);

else if(c ==3)

printf(“viudo”);
else
printf(“Ninguna de las anteriores”);

 Sentencia if (anidados)
Formato
if (expresión)
if (expresión)
if (expresión)
sentencia(s);
else
sentencia(s);
else
sentencia(s);
else
Ejemplo:
if (a==1)
if (b==2)
if (b==3)
printf(“Todas son ciertas”);
else
printf(“\nC no es 3”);
else
printf(“\nb no es 2”);;
else
printf(“\na no es 1”);;
Sentencia de Selección Múltiple (switch)
Un programa puede contener una serie de decisiones en las cuales una variable o expresión
se probará por separado contra cada uno de los valores constantes enteros que pueda asumir
y se tomarán diferentes acciones. Para esta forma de toma de decisiones se proporciona la
estructura de decisión múltiple switch.
Formato
switch (expresión)
{
case const1:
sentencia(s);
break;
case const2:
sentencia(s);
break;
default: //opcional
sentencia(s);
}

Ejemplo:
Sentencia While
Evalúa una condición y, si ésta da como resultado verdadero (true), ejecuta una sentencia o
serie de sentencias antes de volver a ejecutar el bucle para evaluar la condición nuevamente.
Después de que la condición dé como resultado falso (false), se omite la sentencia o serie de
sentencias y finaliza el bucle.
Formato
while(expresión)
sentencia(s);
/*si tiene más de una instrucción dentro del ciclo se colocan llaves*/

Ejemplo:
#include <stdio.h>
void main()
{
int num=0;
while(num<=20);
{
printf(“%d\n”, num);
++num;
}
}
Sentencia Do While
Es similar a la estructura while. La diferencia es que la condición de continuación del ciclo
se testea después de ejecutar el cuerpo del ciclo y por lo tanto el cuerpo del ciclo se ejecutará
al menos una vez.
Formato
do
{ sentencia(s); }
while(expresión);

Ejemplo:
#include <stdio.h>
void main()
{
int num=0;
do
{
printf(“%d\n”, num);
++num;
}while(num<=20);
}

Sentencia For
Evalúa la expresión inicialización una vez y, a continuación, inicia una secuencia de
reproducción indefinida. La secuencia de reproducción indefinida se inicia evaluando la
expresión condición. Si la expresión condición da como resultado true, se ejecutan la o las
sentencias y se evalúa la expresión incremento/decremento. La secuencia de reproducción
indefinida se inicia nuevamente con la evaluación de la expresión condición.
Formato
for(inicialización;condición; incremento/decremento)
sentencia(s);
Ejemplo
#include <stdio.h>

void main() {
int n;
for (n = 1; n <= 10; n++)
{
printf(“Número %d:”, n);
}
}