C Piscine — C 06

El módulo más corto: cuatro ejercicios, y todos son programas con su propia función main. El tema es uno solo — los argumentos de la línea de comandos: qué son argc y argv, de dónde salen y qué puedes hacer con ellos.

El concepto que vertebra el módulo: quién llama a tu main — Hasta ahora escribías funciones que evaluaba un tester. Aquí escribes programas, y un programa en C empieza en main… pero main no se ejecuta solo: lo llama el sistema operativo cuando tecleas ./a.out uno dos tres. Y le pasa dos argumentos igual que tú se los pasas a cualquier función: int main(int argc, char **argv). argc (argument count) es cuántas palabras había en la línea, contando el propio nombre del programa. argv (argument vector) es un array de cadenas con esas palabras: argv[0] es siempre el nombre con el que se invocó el programa, argv[1] el primer argumento real, y así hasta argv[argc-1]; por convención argv[argc] es NULL. No hay magia: es el mismo shell que trabajaste en Shell 00/01 el que trocea tu línea por espacios y te la entrega. Todo ls -la, grep patrón fichero o cc -Wall main.c que has escrito llega a su main exactamente así. Este módulo es donde por fin ves el otro lado del mostrador. (El prólogo reproduce la escena de los bolos de El Gran Lebowski, con Walter gritando "¡apunta un cero!"; puro relleno marca de la casa.)

GGlosario de teoría

C 06 es el primer módulo en el que entregas programas y no funciones sueltas, y casi todo gira alrededor de cómo le llegan a main las palabras que escribes en la terminal. Aquí está cada término explicado desde cero y con un ejemplo sacado del propio módulo. En el resto de la página, la primera vez que sale uno de estos términos en cada tarjeta lleva un enlace a su entrada.

Programas y línea de comandos

Programa frente a función

Una función es un trozo de código que alguien llama desde otro código: hasta C 05, la llamaba el main de pruebas de la Moulinette. Un programa es un ejecutable completo que se lanza desde la terminal, y para eso necesita su propia función main, que es por donde empieza a ejecutarse.

El enunciado lo dice en cada ejercicio de C 06: «tu archivo .c deberá contener una función main». Es al revés que en los módulos anteriores, donde dejar un main sin comentar hacía fallar la entrega.

main y su prototipo con argumentos

main es la función que el sistema llama al arrancar el programa. Tiene dos formas válidas: int main(void), si no te interesan los argumentos, e int main(int argc, char **argv), si sí. Los nombres argc y argv son una costumbre, no una obligación, pero todo el mundo los usa.

Los cuatro ejercicios usan la segunda forma, porque los cuatro leen la línea de comandos.

argc (argument count)

Un int con cuántas palabras tenía la línea de comandos, contando el nombre del programa. Por eso nunca vale menos de 1 en un uso normal: ./ft_print_params a secas tiene argc == 1, y ./ft_print_params a b tiene argc == 3.

Es lo que pone el límite de los bucles: ex01 recorre de 1 a argc - 1, ex02 al revés.

argv (argument vector) y char **

Un array de cadenas con esas palabras. Su tipo, char **, se lee «puntero a puntero a char»: argv apunta a la primera casilla de un array, y cada casilla es un char * que apunta a una cadena. Así, argv[1] es una cadena entera y argv[1][0] es su primer carácter.

./ft_print_params uno dos

argv[0] → "./ft_print_params"
argv[1] → "uno"
argv[2] → "dos"
argv[3] → NULL          (argc == 3)

El estándar de C garantiza que argv[argc] es NULL: es un centinela, como el '\0' de las cadenas pero un nivel más arriba.

argv[0]: el nombre del programa

La primera casilla de argv no es un argumento tuyo sino el nombre con el que se lanzó el programa, tal como se escribió. No es «el nombre del archivo»: si lo llamas con la ruta completa, sale la ruta completa, y si lo llamas a través de un enlace simbólico, sale el nombre del enlace.

Con el ex00 del repo: ./ft_print_program_name imprime ./ft_print_program_name; lanzado con su ruta absoluta, imprime la ruta absoluta; y con un enlace hola que apunta a él, ./hola imprime ./hola.

Cómo trocea el shell la línea

No es tu programa quien separa las palabras: lo hace el shell (bash, zsh) antes de lanzarlo. Corta por espacios, salvo lo que va entre comillas, que queda como una sola palabra; las comillas en sí no llegan al programa. Una cadena vacía entre comillas, '', es un argumento de longitud 0.

$ ./ft_print_params uno "dos tres" '' cuatro | cat -e
uno$
dos tres$
$
cuatro$

Cuatro argumentos, argc == 5. El tercero es una línea vacía, y es correcto: existe, solo que no tiene caracteres.

Valor de retorno de main y código de salida

Lo que devuelve main es el código de salida del programa, que el shell guarda en $?. Por convención, 0 significa «todo bien» y cualquier otro valor, error. Desde C99, si main llega a su llave final sin return, devuelve 0 igualmente.

ex01, ex02 y ex03 del repo no tienen return en main, y echo $? tras ./ft_print_params da 0. ex00 sí lo pone.

Cadenas y punteros

Cadena en C y el terminador '\0'

En C una cadena es una fila de char seguidos en memoria que termina en el carácter '\0' (el byte 0). No guarda su longitud: para saber dónde acaba hay que recorrerla hasta encontrar ese byte. "uno" ocupa 4 bytes: 'u' 'n' 'o' '\0'.

Es lo que hace ft_putstr en los cuatro archivos del repo: while (str[i]) escribe un carácter tras otro hasta dar con el 0.

write y la salida estándar

write(fd, dirección, n) escribe n bytes a partir de una dirección en el descriptor de archivo fd. El 1 es la salida estándar (la terminal, o lo que venga después de un |). No sabe nada de cadenas: escribe exactamente los bytes que le digas.

Es la única función autorizada en C 06. write(1, &str[i], 1) escribe un carácter; write(1, "\n", 1), el salto de línea.

(void)argc y las flags -Wextra -Werror

Con -Wextra el compilador avisa de los parámetros que no se usan, y con -Werror todo aviso se convierte en error que impide compilar. Escribir (void)argc; «usa» el parámetro sin hacer nada con él: lo convierte a void y descarta el resultado.

Solo hace falta en ex00, que no mira argc. Los otros tres lo usan en sus bucles.

Comparar cadenas: strcmp

strcmp(a, b) compara dos cadenas carácter a carácter hasta encontrar la primera diferencia (o el final de las dos) y devuelve un número negativo si a va antes, 0 si son iguales y positivo si va después. No se puede comparar con a == b: eso compara las direcciones de memoria, y dos cadenas con el mismo texto en sitios distintos darían «distintas».

En ex03 hay que escribirla a mano, porque solo está autorizada write.

Orden ASCII

ASCII es la tabla que asigna un número a cada carácter: '0' es 48, 'A' 65, 'a' 97. Ordenar «según el orden ASCII», como pide el enunciado, es comparar esos números, así que las cifras van antes que las mayúsculas y las mayúsculas antes que las minúsculas. Y se compara carácter a carácter, no por valor numérico: "10" va antes que "9" porque '1' < '9'.

$ printf '%s\n' b B a 10 9 | LC_ALL=C sort | tr '\n' ' '
10 9 B a b

Es la salida que debería dar ./ft_sort_params b B a 10 9.

signed y unsigned char

Un char es un byte. En Linux x86 es con signo (signed): va de −128 a 127, y los bytes de 128 a 255 se leen como negativos. Un unsigned char va de 0 a 255. Los caracteres no ASCII, como las letras con tilde en UTF-8, usan esos bytes altos.

Por eso ex03 hace el cast a unsigned char antes de restar, igual que el strcmp real. Con "é" (bytes 0xC3 0xA9) frente a "a": con signo la resta da −158 y "é" iría antes; sin signo da 98, como strcmp.

Paso por valor e intercambio de punteros (swap)

En C, los argumentos se pasan por valor: la función recibe una copia. Si dentro cambias la copia, el original no se entera. Para que una función cambie una variable de quien la llama hay que pasarle su dirección.

Para intercambiar dos casillas de argv, que son char *, hay que pasar punteros a ellas (char **) o hacer el intercambio en el propio bucle, como la tarjeta de ex03 con tmp. El ft_swap(char *a, char *b) del repo intercambia sus copias locales a y b y no cambia nada fuera.

Gnome sort

Un algoritmo de ordenación muy corto: se recorre la lista comparando cada pareja de vecinos; si está en orden, se avanza; si no, se intercambian y se vuelve atrás (o al principio). Termina cuando se llega al final sin encontrar ninguna pareja desordenada. Es O(n²): con listas grandes es lento, con argumentos de línea de comandos da igual.

El sort de la tarjeta de ex03 vuelve a i = 1 tras cada intercambio, y el ft_sort del repo a i = 0: la misma idea.

Segmentation fault y desreferenciar NULL

NULL es un puntero que no apunta a nada. Desreferenciarlo, leer lo que hay «en» esa dirección (a[0] con a == NULL), es un acceso a memoria prohibida, y el sistema mata el programa con Segmentation fault (código de salida 139). Según las instrucciones de la piscine, un segfault en evaluación es un 0.

Le pasa al ex03 del repo con dos o más argumentos: main pone argv[0] = NULL y luego ft_sort empieza comparando tab[0] con tab[1]. ./ft_sort_params b a termina con código 139.

ex00ft_print_program_name

Entrega: ft_print_program_name.cAutorizado: write

Imprimir el nombre del programa (el propio ./a.out) seguido de un salto de línea.

int	main(int argc, char **argv)
{
	int	i;

	(void)argc;
	i = 0;
	while (argv[0][i])
	{
		write(1, &argv[0][i], 1);
		i++;
	}
	write(1, "\n", 1);
	return (0);
}

El nombre está en argv[0], que es una cadena como cualquier otra: se recorre carácter a carácter hasta el '\0'. El (void)argc; es necesario porque compilamos con -Wextra -Werror y no usar un parámetro es un aviso que aquí se convierte en error; "tocarlo" con el cast a void le dice al compilador "sé que existe y lo ignoro a propósito".

Qué te obliga a aprender — Que argv[0] no es un extra: es el primer elemento y siempre está. De ahí sale el idioma Unix de que un mismo binario se comporte distinto según con qué nombre lo llames (un enlace simbólico con otro nombre y un if sobre argv[0]). Y aprendes a lidiar con -Werror sin trampas: el cast a void es la forma limpia y estándar de silenciar un parámetro no usado.

ex01ft_print_params

Entrega: ft_print_params.cAutorizado: write

Imprimir cada argumento en su propia línea, en orden, saltándose argv[0].

int	main(int argc, char **argv)
{
	int	i;

	i = 1;
	while (i < argc)
	{
		print_str(argv[i]);
		i++;
	}
	return (0);
}

El bucle empieza en i = 1 para saltar el nombre del programa y llega hasta argc - 1. print_str es un pequeño helper static que escribe una cadena y su salto de línea (mismo patrón de recorrer hasta el '\0').

Qué te obliga a aprender — La estructura real de argv: un char **, es decir, un array de punteros a cadenas. argv[i] es una cadena completa; argv[i][j] es un carácter suelto. Recorrer argv con un índice acotado por argc es el modelo mental que necesitarás para cualquier programa de línea de comandos, incluidos los que parsean opciones y flags.

ex02ft_rev_params

Entrega: ft_rev_params.cAutorizado: write

Lo mismo que ex01 pero en orden inverso: del último argumento al primero (sin argv[0]).

int	main(int argc, char **argv)
{
	int	i;

	i = argc - 1;
	while (i >= 1)
	{
		print_str(argv[i]);
		i--;
	}
	return (0);
}

El único cambio respecto a ex01 es la dirección del recorrido: se arranca en argc - 1 (el último) y se baja hasta 1.

Qué te obliga a aprender — Que recorrer una colección de atrás hacia delante es solo cuestión de invertir el índice y la condición, no de tocar los datos. No hace falta mover ni copiar nada en argv: cambiamos cómo lo leemos. Es la misma idea que verás al invertir una cadena o una lista, pero sin escribir en memoria.

ex03ft_sort_params

Entrega: ft_sort_params.cAutorizado: write

Imprimir los argumentos (sin argv[0]) ordenados según el orden ASCII, uno por línea.

static int	ft_strcmp(char *a, char *b)
{
	int	i;

	i = 0;
	while (a[i] && a[i] == b[i])
		i++;
	return ((unsigned char)a[i] - (unsigned char)b[i]);
}

static void	sort(char **tab, int size)
{
	char	*tmp;
	int		i;

	i = 1;
	while (i < size)
	{
		if (ft_strcmp(tab[i - 1], tab[i]) > 0)
		{
			tmp = tab[i - 1];
			tab[i - 1] = tab[i];
			tab[i] = tmp;
			i = 1;
		}
		else
			i++;
	}
}

Ordenar cadenas necesita saber cuál va "antes": eso lo decide ft_strcmp, que compara carácter a carácter y devuelve la diferencia en el primer punto donde difieren. Y ordenar necesita mover: pero lo que se intercambia no son las cadenas sino los punteros del array tab (por eso tmp es un char *). El algoritmo es un gnome sort, el mismo de C01: si el par está desordenado lo intercambia y reinicia; si no, avanza.

Qué te obliga a aprender — Dos ideas grandes. (1) Comparar cadenas no es comparar con == (eso compararía direcciones, no contenido): hay que recorrerlas, y el cast a unsigned char asegura que el orden de bytes altos sea el correcto — así se comporta el strcmp real. (2) Ordenar un array de punteros mueve las referencias, no los datos: barato y sin tocar las cadenas originales, que además no debes modificar. Aquí se juntan todo lo del módulo (recorrer argv) con lo de C01 (punteros, swap, sort) — por eso es el cierre natural de C06.

?Preguntas probables de la evaluación

Lo que es fácil que pregunte quien te evalúe, con una respuesta corta y el enlace a la sección donde está explicado. Están agrupadas en: argumentos, comparar y ordenar, y puntos débiles. Las respuestas hablan del código de tu entrega (repo/), que no siempre es el mismo que se muestra en las tarjetas. Antes de mirar la respuesta, intenta contestar tú.

Argumentos

¿Qué son argc y argv y quién los rellena?

argc es cuántas palabras hay en la línea, contando el nombre del programa; argv, un array de cadenas con esas palabras, terminado en NULL (argv[argc] == NULL). Las trocea el shell antes de lanzar el programa, y el sistema se las pasa a main. → argc, argv, cómo trocea el shell

¿Qué imprime ex00 si lo lanzas con la ruta completa?

La ruta completa: argv[0] es el nombre tal como se escribió, no el nombre del archivo. Con ./ft_print_program_name sale eso mismo, y con un enlace simbólico sale el nombre del enlace. → ex00, argv[0]

¿Para qué sirve (void)argc;?

Para que compile con -Wall -Wextra -Werror. ex00 no usa argc, el compilador avisaría de un parámetro sin usar y -Werror convierte el aviso en error. El cast a void lo «usa» sin hacer nada. → ex00, (void)argc

¿Cuántas líneas imprime ./ft_print_params uno "dos tres" ''?

Tres: uno, dos tres y una línea vacía. Las comillas juntan palabras en un solo argumento y no llegan al programa; '' es un argumento vacío pero existe. Sin argumentos, ex01 y ex02 no imprimen nada y salen con 0. → ex01, cómo trocea el shell

Comparar y ordenar

¿Por qué no comparas los argumentos con == o <?

Porque argv[i] es un puntero: == compararía direcciones de memoria, no el texto. Hay que recorrer las dos cadenas hasta la primera diferencia y restar esos caracteres, que es lo que hace ft_strcmp. → ex03, strcmp

¿En qué orden deben salir b B a 10 9?

10, 9, B, a, b. En ASCII las cifras van antes que las mayúsculas y estas antes que las minúsculas, y se compara carácter a carácter: "10" va antes que "9" porque '1' < '9'. → orden ASCII

¿Por qué el cast a unsigned char en ft_strcmp?

Porque char tiene signo en esta máquina, y los bytes de 128 a 255 (letras con tilde en UTF-8) saldrían negativos y se ordenarían antes que 'a'. El strcmp real compara como unsigned char: "é" frente a "a" da 98 y no −158. → signed y unsigned char

Puntos débiles (mejor tener la respuesta preparada)

¿Funciona tu ft_sort_params con dos argumentos?

No: ./ft_sort_params b a da Segmentation fault (código 139). main pone argv[0] = NULL y ft_sort empieza en i = 0, así que lo primero que hace es ft_strcmp(NULL, argv[1]). Con cero o un argumento sí funciona, porque el bucle no llega a comparar. Hay que ordenar desde argv + 1 o empezar en i = 1. → ex03, segfault

Aunque no petara, ¿ordenaría bien?

Tampoco. ft_swap(char *a, char *b) recibe copias de los punteros y las intercambia entre sí, sin tocar argv: el intercambio se pierde al salir. Y el if (ft_strcmp(...) < 0) está al revés: intercambia las parejas que ya están en orden. Con las dos cosas juntas, la primera pareja en orden haría i = 0 sin cambiar nada, para siempre. Lo correcto: intercambiar si es > 0, y pasar &tab[i] y &tab[i + 1] a un swap de char **. → paso por valor, gnome sort

¿Pasa la Norma? ¿Usas alguna función prohibida?

norminette 3.3.59 da OK! en los cuatro archivos, y solo se llama a write, la única autorizada. ft_putstr está repetida en cada archivo porque cada ejercicio es un programa aparte que se compila solo. → write, programa frente a función