int
, otra de tipo char
y una tercera de tipo float
.
#include<stdio.h> int main(int argc, char * argv[]) { int unInt = 65; char unChar = 'A'; float unFloat = 3.1416; printf("El entero vale %d\n", unInt); printf("El carácter vale %c\n", unChar); printf("El real vale %f\n", unFloat); return 0; }El compilador crea automáticamente la siguiente tabla de variables, sin que el usuario tenga que preocuparse de las direcciones en que comienzan las variables, ni tampoco de su extensión. El compilador se asegura de que las operaciones realizas con estas variables sean las adecuadas para su tipo: por ejemplo, no permitirá almacenar un char en un float, ni concatenar dos int.
Nombre | Dirección | Extensión | Tipo | Valor |
unInt | &unInt | 4 bytes | int | ?? |
unChar | &unChar | 1 byte | char | ?? |
unFloat | &unFloat | 4 bytes | float | ?? |
main()
, en este caso) serán variables locales de la función main()
, y por tanto resultarán invisibles para cualquier otro subprograma.
main()
, serán variables globales dentro del fichero en que reside el programa. Esto es, todas las funciones declaradas dentro de ése fichero podrán utilizar las variables globales como si fuesen propias; esto sive para intercambiar información entre funciones, pero puede suponer un riesgo de corrupción de información si una función hace uso inadvertidamente de una variable global en lugar de emplear una variable local.
tipo variable_1 = valor_1, variable_2, ..., variable_n = valor_m; /* Por ejemplo */ int dia = 7, mes = 9, semana = 42;Evidentemente, el valor asignado tiene que pertenecer al tipo de la variable declarada.En el caso de que la variable sea estructurada, es preciso escribir los valores correspondientes entre llaves, y separados mediante comas. La asignación de valores a los distintos elementos de la variable estructurada se realiza por orden cronológico (por filas, para ser exactos), y por tanto será preciso respetar el número y tipo de los elementos que formen esa variable estructurada.
Nombre | Tamaño | Alcance |
short
|
16 bits
|
desde -32.768 hasta 32.767 |
unsigned short
|
16 bits
|
desde 0 hasta 65535 |
int
|
32 bits
|
desde -2.147.483.648 hasta 2.147.483.647 |
unsigned int
|
32 bits
|
desde 0 hasta 4.294.967.295 |
long
|
32 bits
|
desde -2.147.483.648 hasta 2.147.483.647 |
unsigned long
|
32 bits
|
desde 0 hasta 4.294.967.295 |
long long
|
64 bits
|
desde -9.223.372.036.854.775.808 hasta 9.223.372.036.854.775.807 |
unsigned long long
|
64 bits
|
desde 0 hasta 18.446.744.073.709.551.615 |
long long
y unsigned long long
pueden no encontrarse en todos los compiladores.
short alfa; unsigned short b, campo, d; int e; unsigned int f = 2, g, hache = 7; /* Declaración con asignación de valor inicial */ long largo; unsigned long mas_largo; long long larguisimo; unsigned long long tremebundo = 31415926535; /* Declaración con asignación de valor inicial */
/* Este comentario abarca varias líneas. */
printf()
y scanf()
.
stdio.h
, y esta es la razón por la cual se incluye ese archivo en todos los programas que contengan operaciones de entrada/salida.
printf(cadena_de_formato, lista_de_variables);y
scanf(cadena_de_formato, lista_de_direcciones);en donde los significados de
cadena_de_formato
, lista_de_variables
y lista_de_direcciones
son como sigue: cadena_de_formato
es una cadena de caracteres (una colección de letras y números encerrada entre comillas) que indica la forma en que hay que escribir en pantalla las variables que aparezcan en el segundo argumento (lista_de_variables
). En general, la cadena_de_formato
contiene una información literal, que se reproducirá sin cambio alguno, y una información de formato, que se empleará para dar formato únicamente a las variables situadas en posiciones homólogas dentro de la lista de variables. Quierese decir que si la cadena de formato tiene tres indicadores de formato (se reconocen fácilmente porque empiezan por el signo de %
), entonces el primer indicador se empleará para dar formato a la primera variable; el segundo afectará al formato de la segunda variable, y el tercero se empleará para dar formato a la tercera variable. Si sobran formatos (faltan variables) el resultado es imprevisible. Si sobran variables, se imprimen los valores de aquellas variables para las cuales hay especificador de formato, y no se imprimen las restantes. Los indicadores de formato comienzan por el signo %
, y van seguidos por caracteres que indican el tipo de formato que debe darse a la variable correspondiente. En el caso de las variables enteras, las letras que hay que utilizar son d
o ld
(%d o bien %ld), en función de la longitud del tipo entero empleado. Los compiladores actuales producen resultados correctos para ambos tipos de enteros empleando el factor de conversión %d.
lista_de_variables
es una colección de variables formada por uno o más elementos separados mediante comas. Se admiten tanto los nombres de variables explícitas como los punteros de char (que se interpretan como dirección de comienzo de una cadena de caracteres). Téngase en cuenta lo expuesto en el punto anterior sobre el exceso de descriptores o de variables. Téngase en cuenta también que el compilador utilizará los descriptores homólogos, sin importarle que coincidan correctamente los tipos. Los resultados son a menudo interesantes, pero no los esperados.
Lista_de_direcciones
es una colección de direcciones de variables (estáticas o dinámicas) que scanf() emplea como destino de la información leída a partir del teclado, una vez traducida, si procede al formato especificado en el descriptor correspondiente. Dicho de otro modo, scanf() cree firmemente que las direcciones que se le proporcionan corresponden a variables de tipo correcto y extensión suficiente para almacenar el resultado de la lectura. Si se lee más información que la que cabe en la variable señalada por una dirección, los resultados son imprevisibles y generalmente negativos. Si el programador sospecha que esto hay peligro de entrada de datos excesivo y/o incorrectos, procederá emplear la función fgets() para limitar la extensión de la cadena leída, realizando después una traducción al formato oportuno mediante funciones como strtol(), strtof(), etc.
/* Formatos enteros en C */ #include<stdio.h> int alfa = 1, beta = 2, delta = 3; void main(void) { printf("Alfa vale %d, beta vale %d y delta vale %d. Gamma vale %d\n", alfa, beta, delta); /* Aquí sobra el último %d */ printf("Alfa vale %d, beta vale %d\n", alfa, beta, delta); /* Aquí sobra la última variable */ } /* Resultados de la ejecución Alfa vale 1, beta vale 2 y delta vale 3. Gamma vale 40242420 Alfa vale 1, beta vale 2 */Las operaciones de lectura de enteros son similares a las de escritura. Esta vez la cadena de especificación describe el formato que adoptarán los datos suministrados; el compilador analiza estos datos y efectúa las transformaciones pertinentes, almacenando los valores obtenidos en las variables situadas en los correspondientes lugares cronológicos.
#include<stdio.h> /* Este programa muestra la forma de leer y escribir enteros */ int a, b, c; void main(void) { /* Aquí se piden los datos, y se leen individualmente */ printf("Escriba el valor de a: "); scanf("%d", &a); printf("Escriba el valor de b: "); scanf("%d", &b); printf("Escriba el valor de d: "); scanf("%d", &c); /* Aquí se escriben los números leídos */ printf("El primero es %d, el segundo es %d y el tercero es %d\n\n", a, b, c); /* Ahora se leen tres números en una sola línea */ printf("Escriba tres enteros separados por espacios:\n\n"); scanf("%d %d %d", &a, &b, &c); printf("Ahora el primero es %d, el segundo vale %d y el tercero es %d\n\n", a, b, c); }
Operación | Operador | Ejemplo |
---|---|---|
Suma | + | c = a + b; |
Resta | - | c = a - b; |
Multiplicación | * | c = a * b; |
División | / | c = a / b; |
Módulo | % | c = a % b; |
#include<stdio.h> /* Este programa muestra un uso elemental de las cuatro reglas */ short a, b; /* Variables globales */ int main(void) { printf("Este programa muestra el uso de las cuatro reglas\n\n"); printf("Escriba dos números enteros separados por un espacio:"); scanf("%d %d", &a, &b); printf("\n\n%d + %d = %d\n", a, b, a + b); printf("%d - %d = %d\n", a, b, a - b); printf("%d * %d = %d\n", a, b, a * b); printf("%d / %d = %d\n", a, b, a / b); printf("\nTerminación normal del programa.\n\n"); return 0; }
short
, cuyo rango de validez oscila entre -32768 y 32767. El compilador de C no indica el desbordamiento, limitándose a mostrar el resultado (incorrecto).
#include<stdio.h> /* Prototipos */ void probar_operaciones_short(void); void probar_operaciones_unsigned_short(void); void probar_operaciones_int(void); void probar_operaciones_unsigned_int(void); void probar_operaciones_long(void); void probar_operaciones_unsigned_long(void); void probar_operaciones_longlong(void); void probar_operaciones_unsignedlonglong(void); /* Programa principal */ int main(int argc, char * argv[]) { printf("Este programa muestra el uso de las cuatro reglas\n\n"); probar_operaciones_short(); probar_operaciones_unsigned_short(); probar_operaciones_int(); probar_operaciones_unsigned_int(); probar_operaciones_long(); probar_operaciones_unsigned_long(); probar_operaciones_longlong(); probar_operaciones_unsignedlonglong(); printf("\nTerminación normal del programa.\n\n"); return 0; } /* Definición de las funciones */ void probar_operaciones_short(void) { short a, b; printf("\nEscriba dos short separados por un espacio: "); scanf("%hd %hd", &a, &b); printf("\n\n%d + %d = %d\n", a, b, a + b); printf("%d - %d = %d\n", a, b, a - b); printf("%d * %d = %d\n", a, b, a * b); printf("%d / %d = %d\n", a, b, a / b); } void probar_operaciones_unsigned_short(void) { unsigned short a, b; printf("\nEscriba dos unsigned short separados por un espacio: "); scanf("%hd %hd", &a, &b); printf("\n\n%u + %u = %u\n", a, b, a + b); printf("%u - %u = %u\n", a, b, a - b); printf("%u * %u = %u\n", a, b, a * b); printf("%u / %u = %u\n", a, b, a / b); } void probar_operaciones_int(void) { int a, b; printf("\nEscriba dos int separados por un espacio: "); scanf("%d %d", &a, &b); printf("\n\n%d + %d = %d\n", a, b, a + b); printf("%d - %d = %d\n", a, b, a - b); printf("%d * %d = %d\n", a, b, a * b); printf("%d / %d = %d\n", a, b, a / b); } void probar_operaciones_unsigned_int(void) { unsigned int a, b; printf("\nEscriba dos unsigned int separados por un espacio: "); scanf("%d %d", &a, &b); printf("\n\n%u + %u = %u\n", a, b, a + b); printf("%u - %u = %u\n", a, b, a - b); printf("%u * %u = %u\n", a, b, a * b); printf("%u / %u = %u\n", a, b, a / b); } void probar_operaciones_long(void) { long a, b; printf("\nEscriba dos long separados por un espacio: "); scanf("%ld %ld", &a, &b); printf("\n\n%ld + %ld = %ld\n", a, b, a + b); printf("%ld - %ld = %ld\n", a, b, a - b); printf("%ld * %ld = %ld\n", a, b, a * b); printf("%ld / %ld = %ld\n", a, b, a / b); } void probar_operaciones_unsigned_long(void) { unsigned long a, b; printf("\nEscriba dos unsigned long separados por un espacio: "); scanf("%ld %ld", &a, &b); printf("\n\n%lu + %lu = %lu\n", a, b, a + b); printf("%lu - %lu = %lu\n", a, b, a - b); printf("%lu * %lu = %lu\n", a, b, a * b); printf("%lu / %lu = %lu\n", a, b, a / b); } void probar_operaciones_longlong(void) { long long a, b; printf("\nEscriba dos long long separados por un espacio: "); scanf("%qd %qd", &a, &b); printf("\n\n%qd + %qd = %qd\n", a, b, a + b); printf("%qd - %qd = %qd\n", a, b, a - b); printf("%qd * %qd = %qd\n", a, b, a * b); printf("%qd / %qd = %qd\n", a, b, a / b); } void probar_operaciones_unsignedlonglong(void) { unsigned long long a, b; printf("\nEscriba dos unsigned long long separados por un espacio: "); scanf("%qd %qd", &a, &b); printf("\n\n%qd + %qd = %qd\n", a, b, a + b); printf("%qd - %qd = %qd\n", a, b, a - b); printf("%qd * %qd = %qd\n", a, b, a * b); printf("%qd / %qd = %qd\n", a, b, a / b); } /* Resultados de la ejecución Este programa muestra el uso de las cuatro reglas Escriba dos short separados por un espacio: 32768 32767 -32768 + 32767 = -1 -32768 - 32767 = -65535 -32768 * 32767 = -1073709056 -32768 / 32767 = -1 Escriba dos unsigned short separados por un espacio: 65536 65535 0 + 65535 = 65535 0 - 65535 = 4294901761 0 * 65535 = 0 0 / 65535 = 0 Escriba dos int separados por un espacio: 2147483648 2147483647 -2147483648 + 2147483647 = -1 -2147483648 - 2147483647 = 1 -2147483648 * 2147483647 = -2147483648 -2147483648 / 2147483647 = -1 Escriba dos unsigned int separados por un espacio: 4294967296 4298672295 0 + 3704999 = 3704999 0 - 3704999 = 4291262297 0 * 3704999 = 0 0 / 3704999 = 0 Escriba dos long separados por un espacio: 2147483648 2147483647 -2147483648 + 2147483647 = -1 -2147483648 - 2147483647 = 1 -2147483648 * 2147483647 = -2147483648 -2147483648 / 2147483647 = -1 Escriba dos unsigned long separados por un espacio: 4294967296 4298672295 0 + 3704999 = 3704999 0 - 3704999 = 4291262297 0 * 3704999 = 0 0 / 3704999 = 0 Escriba dos long long separados por un espacio: 9223372036854775808 9223372036854775807 9223372036854775807 + 9223372036854775807 = -2 9223372036854775807 - 9223372036854775807 = 0 9223372036854775807 * 9223372036854775807 = 1 9223372036854775807 / 9223372036854775807 = 1 Escriba dos unsigned long long separados por un espacio: 18446744073709551616 18446744073709551615 9223372036854775807 + 9223372036854775807 = -2 9223372036854775807 - 9223372036854775807 = 0 9223372036854775807 * 9223372036854775807 = 1 9223372036854775807 / 9223372036854775807 = 1 Terminación normal del programa. */Notas
if (a % b == 0) printf("%d no es primo porque es divisible por %d", a, b);Esta sentencia imprimirá en pantalla un mensaje si el resto de dividir a por b es cero, esto es, si a es divisible por b. Se pide escribir un programa que permita averiguar si es primo un número menor que 20.
#include<stdio.h> int main(int argc,char * argv[]) { int numero; int es_primo; int i; do { printf("\nPor favor, escriba un entero entre 1 y 20: "); scanf("%d", &numero); } while (numero < 1 || numero > 20); es_primo = 1; /* suponemos inicialmente que el número es primo */ for(i=2;i<numero;i++) if (numero % i == 0) { es_primo = 0; break; } if (es_primo) printf("\nEl número %d es primo.\n\n", numero); else printf("\nEl número %d no es primo, es divisible por %d.\n\n", numero, i); return 0; } /* Resultado de varias ejecuciones del programa: Por favor, escriba un entero entre 1 y 20: 8 El número 8 no es primo, es divisible por 2. [maxus~:] coti% ./a.out Por favor, escriba un entero entre 1 y 20: 2 El número 2 es primo. [maxus~:] coti% ./a.out Por favor, escriba un entero entre 1 y 20: 1 El número 1 es primo. [maxus~:] coti% ./a.out Por favor, escriba un entero entre 1 y 20: 3 El número 3 es primo. [maxus~:] coti% ./a.out Por favor, escriba un entero entre 1 y 20: 4 El número 4 no es primo, es divisible por 2. [maxus~:] coti% ./a.out Por favor, escriba un entero entre 1 y 20: 5 El número 5 es primo. [maxus~:] coti% ./a.out Por favor, escriba un entero entre 1 y 20: 6 El número 6 no es primo, es divisible por 2. [maxus~:] coti% ./a.out Por favor, escriba un entero entre 1 y 20: 7 El número 7 es primo. [maxus~:] coti% ./a.out Por favor, escriba un entero entre 1 y 20: 45 Por favor, escriba un entero entre 1 y 20: 20 El número 20 no es primo, es divisible por 2. */