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.
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.)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.
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 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.
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.
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.
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.
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.
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.
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(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.
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.
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.
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.
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.
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.
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.
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.
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".
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.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').
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.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.
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.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.
== (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.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ú.
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
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]
(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
./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
== 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
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
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
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
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
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