Esta página necesita un navegador reciente (con soporte para SharedArrayBuffer). Por favor, actualiza Chrome, Edge, Firefox o Safari a la última versión.
1Básicos de C
1.1
main, printf y funciones
Todo programa C comienza en main. #include <stdio.h> incluye un encabezado para poder usar printf para imprimir. Una función es un bloque nombrado que puedes llamar; \n inicia una nueva línea. main retorna 0 para significar "éxito".
#include <stdio.h>
void greet(void) {
printf("Hello, world!\n");
}
int main(void) {
greet();
printf("I am learning C.\n");
return 0;
}
Cada programa C se ejecuta desde main tras incluir las cabeceras
1.2
Variables, tipos y aritmética
C necesita un tipo para cada variable: int (entero), double (punto flotante), char (un carácter). printf usa un especificador de formato — %d, %f, %c — para cada valor. / entre dos enteros es división entera; % es el residuo.
#include <stdio.h>
int main(void) {
int n = 17;
double pi = 3.14;
char grade = 'A';
printf("%d %.2f %c\n", n, pi, grade); // 17 3.14 A
printf("%d %d\n", 7 / 2, 7 % 2); // 3 1
return 0;
}
La cadena de formato controla tanto la impresión como la lectura:
Especificador
Tipo
Ejemplo de salida
%d
int
17
%f
double (%.2f = 2 decimales)
3.14
%c
char
A
%s
una cadena
Mei
%zu
un tamaño (de sizeof / strlen)
3
%x
unsigned int, impreso en base 16
ff
scanf("%d", &n) lee un int a través de su dirección (note el &). Los formatos de entrada y salida no son idénticos: printf("%f", x) imprime un double, pero scanf("%lf", &x) lee un double; la entrada %f necesita un float *. Verifique el conteo devuelto de ítems asignados con éxito. Su hermano sscanf analiza valores extraídos de una cadena:
#include <stdio.h>
int main(void) {
char line[] = "Mei 88";
char name[20];
int score;
if (sscanf(line, "%19s %d", name, &score) != 2) return 1;
printf("%s scored %d\n", name, score); // Mei scored 88
return 0;
}
1.3
Comentarios y estilo
Un comentario es una nota para humanos; el compilador lo ignora. Use // para una línea y /* ... */ para un bloque. La buena indentación y nombres claros hacen que el código sea fácil de leer.
#include <stdio.h>
int main(void) {
// a single-line comment
/* a block
comment */
int total = 3 + 4; // clear names help
printf("%d\n", total); // 7
return 0;
}
Errores comunes
Las declaraciones y las expresiones de sentencia terminan con ;; un bloque compuesto { ... } no necesita punto y coma adicional. main debería retornar int (return 0;).
printf necesita una cadena de formato: %d para int, %f para double, y \n para una nueva línea.
Un formato incorrecto como %d para un double causa comportamiento indefinido; no está garantizado simplemente imprimir basura. Coincida el tipo de argumento.
2Selección
2.1
if / else
Un if ejecuta un bloque cuando una condición es verdadera. Una condición se evalúa como número: 0 es falso y cualquier valor distinto de cero es verdadero. (C99's <stdbool.h> añade un tipo booleano, bool con true y false, pero debajo siguen siendo 1 y 0.) Encadenar opciones con else if y else. Comparar con ==, !=, <, >, <=, >=.
#include <stdio.h>
int main(void) {
int score = 72;
if (score >= 90) {
printf("A\n");
} else if (score >= 60) {
printf("Pass\n");
} else {
printf("Fail\n");
}
return 0;
}
if elige la rama verdadera; else la rama falsa
2.2
switch
Un switch selecciona un case mediante un valor entero. Use break para saltar cuando un caso deba terminar. Sin una transferencia de control, la ejecución continúa en el siguiente caso; esto puede ser intencional. default se ejecuta cuando nada coincide.
#include <stdio.h>
int main(void) {
int day = 3;
switch (day) {
case 1: printf("Mon\n"); break;
case 2: printf("Tue\n"); break;
case 3: printf("Wed\n"); break;
default: printf("Other\n");
}
return 0;
}
Errores comunes
if (x = 5) asigna y siempre es verdadero; usa == para comparar.
Termine un caso switch con break; si no se desea que la ejecución continúe en el siguiente caso.
0 es falso y cualquier valor distinto de cero es verdadero en una condición.
3Bucles
3.1
bucles while y for
Un bucle repite un bloque de código. Un bucle while se ejecuta mientras una condición sea verdadera. Un bucle for agrupa el inicio, la prueba y el incremento (i++) en una sola línea — es ideal cuando se sabe cuántas veces se debe repetir.
#include <stdio.h>
int main(void) {
int i = 1;
while (i <= 3) {
printf("%d ", i);
i++;
}
printf("\n"); // 1 2 3
for (int j = 0; j < 5; j++) {
printf("%d ", j);
}
printf("\n"); // 0 1 2 3 4
return 0;
}
el bucle while verifica una condición; el bucle for cuenta con un paso
3.2
Acumulación
Un patrón común: iniciar un acumulador en 0, luego sumarle valores dentro del bucle. La misma idea sirve para contar elementos o encontrar una suma total.
#include <stdio.h>
int main(void) {
int total = 0;
for (int i = 1; i <= 5; i++) {
total += i; // 1 + 2 + 3 + 4 + 5
}
printf("%d\n", total); // 15
return 0;
}
3.3
Bucle anidados y patrones
Un bucle dentro de otro bucle es un bucle anidado. El bucle interior se completa completamente por cada paso del bucle exterior — perfecto para cuadrículas y patrones.
#include <stdio.h>
int main(void) {
for (int row = 0; row < 3; row++) {
for (int col = 0; col < 3; col++) {
printf("*");
}
printf("\n");
}
return 0;
}
Errores comunes
for (i = 0; i < n; i++) se ejecuta n veces; un punto y coma inmediatamente después de for (...) crea un bucle vacío.
Un while cuya condición nunca se vuelve falsa produce un bucle infinito.
Declarar el contador (int i) antes o dentro del encabezado del for.
4Funciones
4.1
Parámetros y valores de retorno
Una función toma parámetros (entradas) y devuelve un valor de retorno. El tipo de retorno aparece primero (int, double, …); void significa que no devuelve nada.
#include <stdio.h>
int square(int x) { // x is a parameter
return x * x; // hand back a value
}
int main(void) {
int r = square(5);
printf("%d\n", r); // 25
return 0;
}
Parámetros entrada; valor de retorno salida
4.2
Prototipos y alcance
C lee de arriba hacia abajo, por lo que una función debe estar declarada antes de ser llamada. Un prototipo — la línea del encabezado más el ; — la declara tempranamente para que pueda mantener main al principio. El alcance de una variable es el bloque en el que vive: es local y desaparece cuando termina el bloque.
#include <stdio.h>
int add(int a, int b); // prototype: declared before use
int main(void) {
printf("%d\n", add(3, 4)); // 7
return 0;
}
int add(int a, int b) { // definition comes later
int sum = a + b; // sum is local to add
return sum;
}
Errores comunes
Una función usada antes de su definición necesita un prototipo encima de main.
Los argumentos se pasan POR VALOR — los cambios dentro de una función no afectan al llamador a menos que pase un puntero.
Una variable declarada dentro de una función es local a ella.
5Arreglos
5.1
Arrays 1-D
Un arreglo contiene varios valores de un solo tipo. Indexe desde 0. C no almacena la longitud de un arreglo, así que un truco común calcula el recuento de elementos: sizeof(a) / sizeof(a[0]).
#include <stdio.h>
int main(void) {
int scores[3] = {88, 71, 95};
printf("%d\n", scores[0]); // 88
scores[1] = 100;
printf("%d\n", scores[1]); // 100
int n = sizeof(scores) / sizeof(scores[0]);
printf("%d\n", n); // 3
return 0;
}
Los espacios del array se indexan desde 0
5.2
Algoritmos con arrays
Recorra un arreglo con un bucle for para encontrar un máximo, un total o un recuento. Siempre itere desde 0 hasta n - 1.
#include <stdio.h>
int main(void) {
int a[] = {3, 9, 2, 7};
int n = sizeof(a) / sizeof(a[0]);
int max = a[0], total = 0;
for (int i = 0; i < n; i++) {
if (a[i] > max) max = a[i];
total += a[i];
}
printf("%d %d\n", max, total); // 9 21
return 0;
}
5.3
Arrays 2-D
Un array bidimensional 2-D es una cuadrícula de filas y columnas: grid[row][col]. Usa dos bucles anidados para visitar cada celda.
#include <stdio.h>
int main(void) {
int grid[2][3] = {{1, 2, 3}, {4, 5, 6}};
printf("%d\n", grid[1][2]); // 6
for (int r = 0; r < 2; r++) {
for (int c = 0; c < 3; c++) {
printf("%d ", grid[r][c]);
}
}
printf("\n"); // 1 2 3 4 5 6
return 0;
}
Errores comunes
C NO verifica los límites del array: escribir a[n] en un array de tamaño n es comportamiento indefinido.
Los índices válidos van de 0 a n - 1.
En la mayoría de las expresiones un arreglo se convierte en un puntero a su primer elemento, pero el propio arreglo no es un puntero. sizeof(a) da el tamaño total en bytes para un arreglo real; un parámetro de arreglo se ajusta a un puntero, por lo que esa función necesita una longitud suministrada separadamente.
6Punteros
6.1
&, * y punteros por referencia
Un puntero 指针 almacena la dirección 地址 de una variable. &x devuelve la dirección de x; *p desreferencia 解引用 el puntero: lee o escribe el valor almacenado en esa ubicación. Pasar un puntero permite que una función modifique la variable del llamador (punteros por referencia).
Un puntero almacena una dirección; al desreferenciarlo, se sigue la flecha hacia el valor
#include <stdio.h>
void addOne(int *p) { // p holds an address
*p = *p + 1; // change the value at that address
}
int main(void) {
int x = 10;
int *ptr = &x; // & takes the address of x
printf("%d\n", *ptr); // * reads the value: 10
addOne(&x);
printf("%d\n", x); // 11 — changed through the pointer
return 0;
}
El uso clásico es una función de intercambio. Al pasar valores solo se copian — el intercambio se pierde. Al pasar punteros, la función accede a las variables del llamador:
#include <stdio.h>
void swap_values(int a, int b) { // copies: the caller sees nothing
int t = a; a = b; b = t;
}
void swap_pointers(int *a, int *b) { // addresses: the swap is real
int t = *a; *a = *b; *b = t;
}
int main(void) {
int x = 1, y = 2;
swap_values(x, y);
printf("%d %d\n", x, y); // 1 2 (unchanged!)
swap_pointers(&x, &y);
printf("%d %d\n", x, y); // 2 1 (swapped)
return 0;
}
El nombre de un array actúa como un puntero a su primer elemento, y la aritmética de punteros 指针运算 avanza en pasos enteros de elementos:
#include <stdio.h>
int main(void) {
int a[] = {10, 20, 30};
int *p = a; // same as &a[0]
printf("%d\n", *p); // 10
printf("%d\n", *(p + 2)); // 30 — same as a[2]
return 0;
}
NULL es el puntero que no apunta a nada — compruébelo antes de desreferenciarlo.
Errores comunes
&x es la dirección de x; *p es el valor almacenado en la ubicación apuntada por p.
Nunca use *p sobre un puntero sin inicializar o NULL — causará un fallo o dañará la memoria.
Para modificar la variable del llamador, pase su dirección y escriba a través del puntero.
7Cadenas
7.1
Arrays de caracteres y el terminador nulo
Una cadena en C es un array de char. Cada cadena termina con un terminador nulo oculto '\0', que marca dónde finaliza. strlen (de <string.h>) cuenta los caracteres hasta ese '\0'. Imprime una cadena completa con %s y un solo carácter con %c.
#include <stdio.h>
#include <string.h>
int main(void) {
char name[] = "Mei"; // 'M', 'e', 'i', '\0'
printf("%s\n", name); // Mei
printf("%zu\n", strlen(name)); // 3 (stops at '\0')
printf("%c\n", name[0]); // M
return 0;
}
Una cadena en C es un array de char que termina con un terminador nulo oculto
Puedes recorrer una cadena mediante un bucle hasta alcanzar '\0'.
#include <stdio.h>
int main(void) {
char word[] = "banana";
int count = 0;
for (int i = 0; word[i] != '\0'; i++) {
if (word[i] == 'a') count++;
}
printf("%d\n", count); // 3
return 0;
}
7.2
La librería string.h
#include <string.h> te proporciona las herramientas habituales para manejar cadenas:
Función
Realiza
strlen(s)
la longitud, sin contar el terminador
strcpy(dst, src)
copia — dst debe ser lo suficientemente grande
strcat(dst, src)
appende src al final de dst
strcmp(a, b)
compara: 0 si son iguales, caso contrario negativo / positivo
#include <stdio.h>
#include <string.h>
int main(void) {
char full[40];
strcpy(full, "Mei"); // full is now "Mei"
strcat(full, " Chen"); // append -> "Mei Chen"
printf("%s (%zu)\n", full, strlen(full)); // Mei Chen (8)
printf("%d\n", strcmp("apple", "apple") == 0); // 1 (equal)
return 0;
}
strcmp devuelve 0 cuando las cadenas son iguales, por lo que la comprobación es strcmp(a, b) == 0 — nunca uses a == b.
El array destino debe tener espacio suficiente para el resultado más el terminador.
Errores comunes
Una cadena en C necesita un byte extra para el terminador \0: una palabra de 5 letras requiere char[6].
Copia y compara cadenas usando strcpy / strcmp, no = / ==.
Olvidar el \0 hace que printf("%s", ...) se salga del límite del texto.
8Estructuras
8.1
struct, typedef, . vs ->
Una estructura agrupa valores relacionados en un solo tipo. Cada valor es un miembro. typedef le da a la estructura un nombre corto para que pueda escribir Dog en lugar de struct Dog. Use . en un valor de estructura, pero -> en un puntero a una estructura.
#include <stdio.h>
typedef struct {
char name[20];
int age;
} Dog;
int main(void) {
Dog d = {"Rex", 3};
printf("%s is %d\n", d.name, d.age); // Rex is 3 (. on a value)
Dog *p = &d;
p->age = 4; // -> on a pointer
printf("%s is %d\n", d.name, d.age); // Rex is 4
return 0;
}
Errores comunes
Usa . en un valor de struct y -> en un puntero a struct.
typedef le permite omitir la palabra struct al declarar; sin él escribe struct Point p;.
Asignar un struct a otro copia todos sus campos.
. for struct values; -> for pointers to structs
9Memoria dinámica
9.1
malloc, free y realloc
malloc asigna memoria en el montón en tiempo de ejecución y retorna un puntero a ella. realloc redimensiona ese bloque; free la devuelve. Cada malloc necesita un free correspondiente, o obtendrá una fuga de memoria. Estos viven en <stdlib.h>.
Las variables locales residen en la pila (stack); la memoria asignada con malloc permanece en el montículo hasta que se libera.
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n = 3;
int *a = malloc(n * sizeof(int)); // room for 3 ints
if (a == NULL) return EXIT_FAILURE;
for (int i = 0; i < n; i++) a[i] = i * 10;
int *grown = realloc(a, 4 * sizeof *a); // positive size
if (grown == NULL) {
free(a);
return EXIT_FAILURE;
}
a = grown;
a[3] = 30;
for (int i = 0; i < 4; i++) printf("%d ", a[i]);
printf("\n"); // 0 10 20 30
free(a); // hand the memory back
return 0;
}
calloc(n, size) asigna un arreglo como malloc Y además lo rellena con ceros.
Errores comunes
Cada malloc necesita un correspondiente free; olvidar llamar a free provoca fugas de memoria.
Usar memoria después de free (un "uso-después-de-liberar" o use-after-free) es un error grave.
Verifique que malloc no haya devuelto NULL antes de utilizar la memoria.
Para tamaños positivos, una realloc fallida retorna NULL y deja intacta la antigua asignación: verifique un resultado temporal antes de reemplazar su único puntero. El éxito preserva el menor de los conteos de bytes antiguos/nuevos; las celdas añadidas están sin inicializar. Este ejemplo evita solicitudes de tamaño cero y desbordamiento de tamaño. Las variables locales ordinarias no estáticas tienen duración de almacenamiento automática y generalmente se implementan en una pila; C no requiere esa disposición.
10Estructuras de datos
10.1
Listas enlazadas
Una lista enlazada 链表 es una cadena de nodos 节点. Cada nodo contiene un valor y un puntero al next nodo; el último apunta a NULL. A diferencia de un arreglo, crece un nodo a la vez con malloc. Siempre free cada nodo cuando haya terminado.
Una lista enlazada: cada nodo contiene un valor y un puntero al siguiente, terminando en NULL
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int value;
struct Node *next;
} Node;
int main(void) {
Node *head = NULL;
for (int v = 10; v <= 30; v += 10) { // prepend 10, 20, 30
Node *n = malloc(sizeof(Node));
n->value = v;
n->next = head;
head = n;
}
for (Node *p = head; p != NULL; p = p->next) {
printf("%d ", p->value); // 30 20 10
}
printf("\n");
while (head != NULL) { // free the whole list
Node *t = head;
head = head->next;
free(t);
}
return 0;
}
10.2
Pilas y colas
Una pila 栈 es LIFO 后进先出 (último en entrar, primero en salir): se apilan y desapilan en el mismo extremo. Una cola 队列 es FIFO 先进先出 (primero en entrar, primero en salir): se añade al final y se elimina desde el frente. Ambas son fáciles de implementar sobre un arreglo usando variables de índice.
#include <stdio.h>
int main(void) {
int stack[10];
int top = 0; // next free slot
stack[top++] = 1; // push
stack[top++] = 2;
stack[top++] = 3;
while (top > 0) {
printf("%d ", stack[--top]); // pop: 3 2 1
}
printf("\n");
return 0;
}
#include <stdio.h>
int main(void) {
int queue[10];
int front = 0, back = 0;
queue[back++] = 1; // enqueue
queue[back++] = 2;
queue[back++] = 3;
while (front < back) {
printf("%d ", queue[front++]); // dequeue: 1 2 3
}
printf("\n");
return 0;
}
Errores comunes
En una lista enlazada, nunca pierda el head puntero, o toda la lista será inaccesible.
Libere cada nodo cuando haya terminado, recorriendo la lista antes de desconectarla.
Verifique si la lista está vacía (un NULL head) antes de hacer un pop.
11Búsqueda, ordenamiento y recursión
11.1
Búsqueda lineal y búsqueda binaria
La búsqueda lineal 线性查找 (linear search) revisa cada elemento en secuencia — funciona con cualquier arreglo. La búsqueda binaria 二分查找 (binary search) es mucho más rápida, pero requiere un arreglo ordenado 已排序: revisa el elemento central y descarta la mitad en cada paso. Ambas devuelven el índice, o -1 si no se encuentra.
#include <stdio.h>
int linear(int a[], int n, int target) {
for (int i = 0; i < n; i++)
if (a[i] == target) return i;
return -1;
}
int binary(int a[], int n, int target) {
int lo = 0, hi = n - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] == target) return mid;
else if (a[mid] < target) lo = mid + 1;
else hi = mid - 1;
}
return -1;
}
int main(void) {
int a[] = {2, 5, 8, 12, 16, 23};
int n = sizeof(a) / sizeof(a[0]);
printf("%d %d %d\n", linear(a, n, 12), binary(a, n, 12), binary(a, n, 9));
return 0; // 3 3 -1
}
Búsqueda lineal explora todo; búsqueda binaria reduce a la mitad un rango ordenado
11.2
Ordenamiento
El ordenamiento burbuja 冒泡排序 compara repetidamente los elementos adyacentes e intercambia 交换 cualquier par que esté fuera de orden. Después de cada pasada, el valor más grande "sube" hacia el final.
#include <stdio.h>
int main(void) {
int a[] = {5, 2, 9, 1, 7};
int n = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (a[j] > a[j + 1]) {
int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
}
}
}
for (int i = 0; i < n; i++) printf("%d ", a[i]);
printf("\n"); // 1 2 5 7 9
return 0;
}
11.3
Recursión
La recursión 递归 es una función que se llama a sí misma. Necesita un caso base 基准情形 para detenerse, y una llamada recursiva que se acerque a él. Sin un caso base, nunca termina.
#include <stdio.h>
int factorial(int n) {
if (n <= 1) return 1; // base case
return n * factorial(n - 1); // recursive call
}
int main(void) {
printf("%d\n", factorial(5)); // 120
return 0;
}
Errores comunes
La búsqueda binaria necesita un arreglo ordenado; la recursión necesita un caso base.
Cada llamada recursiva debe acercarse al caso base, o la pila desbordará.
El ordenamiento burbuja y el de inserción son O(n²): adecuados para aprender, pero lentos a gran escala.
12Archivos y errores
12.1
Archivos de texto
fopen devuelve un puntero de archivo; la cadena de modo indica qué hacer — "w" escribir, "r" leer, "a" añadir. Escriba con fprintf, lea con fscanf, y siempre cierre fclose al finalizar.
#include <stdio.h>
int main(void) {
FILE *out = fopen("scores.txt", "w"); // open for writing
if (out == NULL) {
perror("scores.txt");
return 1;
}
fprintf(out, "Alice 80\nBob 95\n");
fclose(out);
FILE *in = fopen("scores.txt", "r"); // open for reading
if (in == NULL) {
perror("scores.txt");
return 1;
}
char name[20];
int score;
while (fscanf(in, "%19s %d", name, &score) == 2) { // %19s leaves room for '\0'
printf("%s -> %d\n", name, score);
}
fclose(in);
return 0;
}
fopen → lectura/escritura → fclose
12.2
Manejo de errores con códigos de retorno
C no tiene excepciones integradas. Una función puede reportar su resultado mediante un código de retorno; revise las reglas de esa función antes de usar el resultado. El ejemplo de abajo usa 0 para éxito y -1 para fallo. fopen en cambio devuelve un puntero de flujo, o NULL cuando falla.
#include <stdio.h>
// returns 0 on success, -1 if the divisor is 0
int safe_divide(int a, int b, int *result) {
if (b == 0) return -1; // error code
*result = a / b;
return 0; // success
}
int main(void) {
int r;
if (safe_divide(10, 2, &r) == 0)
printf("10 / 2 = %d\n", r); // 10 / 2 = 5
if (safe_divide(10, 0, &r) != 0)
printf("cannot divide by zero\n"); // error reported
return 0;
}
Errores comunes
Verifique que fopen no devolvió NULL antes de leer o escribir.
Cierre siempre el archivo con fclose cuando termine de usarlo.
Devuelva un código distinto de cero desde main para indicar un error al llamador.
13Bits y datos
13.1
Bits, binario y operadores bit a bit
Un bit 位 es un único 0 o 1; los números se almacenan en binario 二进制. Los operadores bit a bit 按位 actúan directamente sobre los bits: & AND, | OR, ^ XOR, << desplazamiento a la izquierda (×2 por cada paso), >> desplazamiento a la derecha (÷2).
#include <stdio.h>
int main(void) {
int a = 12; // 1100
int b = 10; // 1010
printf("%d\n", a & b); // 8 AND -> 1000
printf("%d\n", a | b); // 14 OR -> 1110
printf("%d\n", a ^ b); // 6 XOR -> 0110
printf("%d\n", a << 1); // 24 left shift
printf("%d\n", a >> 1); // 6 right shift
return 0;
}
La notación hexadecimal 十六进制 (base 16) escribe el binario de forma compacta: un dígito hexadecimal equivale exactamente a cuatro bits. Escribe literales hexadecimales con 0x; imprime con %x:
#include <stdio.h>
int main(void) {
printf("%d\n", 0xFF); // 255 (0x marks a hex literal)
printf("%x\n", 255); // ff
printf("%x\n", 12); // c
return 0;
}
Los operadores bit a bit actúan sobre los bits de los enteros
13.2
Codificación por longitud de corrida
La codificación por longitud de corrida (RLE, por sus siglas en inglés) es un método simple de compresión 压缩: reemplaza cada corrida 游程 de caracteres repetidos con un contador y el carácter. Es sin pérdida 无损 — el original se puede recuperar completamente.
#include <stdio.h>
#include <string.h>
int main(void) {
char *s = "aaabbc";
int n = strlen(s);
for (int i = 0; i < n; ) {
char c = s[i];
int run = 0;
while (i < n && s[i] == c) { run++; i++; }
printf("%d%c", run, c); // 3a2b1c
}
printf("\n");
return 0;
}
Errores comunes
& es AND bit a bit y && es AND lógico — no los confundas.
Un desplazamiento a la izquierda << 1 duplica un valor; un desplazamiento a la derecha >> 1 lo reduce a la mitad.
El bit n tiene el valor 1 << n (C no tiene el operador de potencia **); verifica un bit con (x >> n) & 1.
14Preprocesador y calificadores
14.1
Preprocesador, const, static, enum
El preprocesador se ejecuta antes de compilar. #define crea una macro — texto plano que se reemplaza en todas partes. const define una constante que no puede modificarse. static dentro de una función mantiene el valor de una variable entre llamadas. Un enum (enumeración) nombra un conjunto de enteros que comienza en 0.
#include <stdio.h>
#define MAX 100 // macro: text replaced before compiling
enum Color { RED, GREEN, BLUE }; // named integers 0, 1, 2
int next_id(void) {
static int count = 0; // keeps its value between calls
count++;
return count;
}
int main(void) {
const double PI = 3.14; // cannot be changed
printf("%d %.2f\n", MAX, PI); // 100 3.14
printf("%d %d %d\n", RED, GREEN, BLUE); // 0 1 2
int a = next_id();
int b = next_id();
printf("%d %d\n", a, b); // 1 2
return 0;
}
Los programas más grandes se dividen en varios archivos: las declaraciones van en un archivo de cabecera (mine.h), que se incluye con #include "mine.h" — las comillas indican tu propio archivo, mientras que los ángulos < > indican la biblioteca estándar. Una protección contra inclusión múltiple (#ifndef MINE_H / #define MINE_H / #endif) evita que una cabecera sea incluida dos veces.
Errores comunes
#define realiza un reemplazo de texto sin verificación de tipos; encierra los cuerpos y argumentos de las macros entre paréntesis.
Un valor const no puede cambiarse después de haber sido asignado.
Una variable local static conserva su valor entre llamadas a la función.
#define, const, enum, y static mantienen el código claro