1 Instalar CodeBlocks
Bienvenidos a este tutorial de C, nivel básico. Durante los próximos 10 episodios voy a mostraros lo más esencial para poder empezar a trabajar con C, un lenguaje de programación con un gran legado.
2 Funciones y hola mundo
En este episodio construimos el clásico 'hola mundo' no sin antes explicar qué es una función, cómo construimos una función en C y qué tipos de datos más importantes tiene C.
3 Variables y tipos de datos
En este vídeo revisamos los tipos de datos que nos podemos encontrar en C. Ya mostré algunos en el episodio anterior pero hoy concreto los tipos de entero que hay. Y hablamos de cómo declarar, asignar y obtener el valor de variables.
4 Condicionales y operadores lógicos
Las sentencias condicionales permiten ejecutar unas instrucciones u otras según si una condición se cumple o no. Aquí presentamos IF y SWITCH, y por el camino nos llevamos los operadores lógicos.
5 Bucles
Los bucles permiten repetir una serie de instrucciones un número de ocasiones mientras una condición se cumpla. En C tenemos el bucle WHILE, el bucle DO-WHILE y el bucle FOR.
6 Punteros
Los punteros permiten almacenar referencias a posiciones de memoria y los usamos para acceder y manipular el valor de celdas concretas de memoria.
7 Arrays
Los arrays permiten guardar de forma estructurada una serie de datos del mismo tipo de forma secuencial, pudiendo acceder a cada uno de los datos para leerlo o escribirlo mediante un mismo identificador y un índice.
8 Estructuras
En este episodio hablamos de las estructuras y de cómo se pueden usar para agrupar datos. Por medio de la palabra clave struct podemos declararlas y luego podemos usarlas para hacer cosas chulas.
9 Otras construcciones de C
Prestemos un poco de atención al resto de construcciones que nos ofrece C: union, enum y typedef. También las ofrece C y también tienen derecho a tener sus 5 minutos de fama.
10 Memoria dinámica
Terminamos este tutorial básico de C presentando las principales funciones que permiten trabajar con memoria dinámica en C, malloc y free, y un caso básico de uso.
11 El preprocesador (parte 1)
En el primer episodio de la segunda temporada del Tutorial de C comenzamos a hablar del preprocesador, hasta ahora tratada como una deidad. ¿Cómo funciona realmente el preprocesador? Hablaremos de las directivas soportadas según el estándar de C.
12 El preprocesador (parte 2)
En el segundo episodio de la T2 del Tutorial de C, hablamos de macros, de condicionales en tiempo de compilación mediante otras directivas del preprocesador, y de la desconocida directiva error.
13 Archivos de cabecera y múltiples .c (parte 1)
Cuando un proyecto es grande, es más que apropiado estructurarlo en múltiples archivos .c para un tratamiento más cómodo, sobre todo si trabajan muchas personas en ese proyecto. En el caso de C, cuando empecemos a trocear un archivo habrá que prestar atención a las declaraciones compartidas de tipos y funciones, que son los typedefs, y que tendremos que declarar en archivos de cabecera.
14 Archivos de cabecera y múltiples .c (parte 2)
Si nos limitamos a crear archivos de cabecera sin ningún tipo de medida de control, podrá ocurrir que un archivo de cabecera se incluya múltiples veces en una misma unidad de compilación. Vamos a ver cómo usar los guards para evitar que eso pase y que tengamos problemas de redefinición de elementos.
15 C desde la línea de comandos (parte 1)
gcc y clang aceptan una serie de parámetros que pueden darse desde una línea de comandos en una terminal para obtener resultados más precisos de cara a compilar manualmente un archivo o a manipular la cadena de compilación. En este episodio os cuento los distintos parámetros que podemos aplicar para compilar sin IDE.
16 C desde la línea de comandos (parte 2)
En este vídeo hablo del resto de parámetros que quedan por contar para invocar a gcc y clang desde la línea de comandos y continúo mostrando cómo podría usarse tal cual gcc o clang sin ningún IDE para compilar nuestros programas.
17 Break y continue
Break y continue son dos instrucciones que podemos usar en bucles para manipular el flujo de ejecución de las iteraciones de nuestros bucles. Aunque corren el riesgo de complicar el código, a veces son lo suficientemente concisos y limpios como para justificar su uso.
18 Goto
Goto es una sentencia que te permite cambiar el flujo de ejecución de un programa de formas que probablemente no deberías de todos modos. En este vídeo te explico cómo crear etiquetas, cómo insertar un goto, por qué tal vez no sea lo óptimo, y algunas soluciones al respecto.
19 Manipulación de bits
C dispone de operadores booleanos que permiten transformar los bits que componen un valor numérico. En este vídeo te explico como usar los operadores NOT, AND, OR y XOR para manipular los bits de un número.
20 Máscaras de bit
Con las máscaras de bit es posible proporcionar a las funciones una interfaz para pasar múltiples parámetros booleanos de una manera eficiente y fácil de documentar. También hablo del operador desplazamiento.
21 Archivos (1): fopen y fclose
En la tercera TERCERA TEMPORADA del Tutorial de C vamos a hablar de lo que hay dentro de stdio.h. Hoy empezamos a hablar de archivos dedicándole su tiempo a hablar de cómo usar las funciones fopen y fclose.
22 Archivos (2): leer con fgetc
Con la primitiva fgetc podemos leer caracteres de un archivo. En este vídeo cuento cómo utilizar esta función y cómo interpretar el resultado para saber si es un caracter de verdad o si estamos encontrando un error o un fin de archivo.
23 Archivos (3): fseek y ftell
fseek y ftell son un par de primitivas que forman stdio y que nos permiten desplazar el cursor a lo largo de un archivo para poder determinar qué será leído o dónde será escrito cuando usemos las primitivas de lectura y escritura de la API de archivos de C.
24 Archivos (4): leer con fgets
Con la primitiva fgets podemos leer del tirón un montón de caracteres y depositarlos en un buffer que luego podemos tratar como una cadena de caracteres. En este vídeo analizamos el funcionamiento de esta primitiva, sus riesgos y la manera correcta de tratar sus errores.
25 Archivos (5): fputc y fputs
Con las primitivas fputc y fputs podemos escribir cadenas de caracteres o caracteres sueltos en archivos. En este vídeo muestro un ejemplo de uso, prestando atención a las particularidades de cada una de las funciones.
26 Archivos (6): volcar en archivos con fwrite
En este vídeo vamos a ver cómo podemos usar la primitiva fwrite para transferir regiones de memoria a streams o archivos, para permitir serializar de forma pura estructuras o arrays complejos de una manera mucho más precisa que trabajando con cadenas de caracteres.
27 Archivos (7): fread, fwrite y los arrays
Similar a la primitiva fwrite, en este vídeo vamos a ver el funcionamiento de la primitiva fread, para leer el contenido de un archivo y cargarlo de forma binaria en un buffer de memoria. También vemos cómo volcar un array de estructuras usando el tercer parámetro de las primitivas fread y fwrite.
28 Archivos (8): entrada estándar y salida estándar
La entrada estándar y la salida estándar son vistos en C como archivos ya abiertos que permiten enviar lo que se escriba a stdout, y recibir de lo que se lea desde stdin. En este vídeo hablo de las primitivas getchar, putchar y puts, para escribir cosas directamente sobre estos descriptores.
29 Archivos (9): buffers
El funcionamiento interno de los archivos y steams en C provoca que a veces puedan ocurrir errores sutiles. En este vídeo explico el funcionamiento de un buffer para que sepamos cómo controlar la forma en la que se vuelca contenido en un archivo.
30 Archivos (y 10): otras funciones útiles con archivos
Cerramos el bloque dedicado a archivos para hablar sobre un par de funciones que permiten trabajar con el sistema de archivos de una forma simple. Con las funciones rename y remove podemos renombrado y eliminar archivos.
31 printf (1)
printf es una función que nos ha acompañado desde el primer día, pero ¿sabemos realmente cómo funciona? printf permite imprimir con formato variables por pantalla. En este capítulo hablo de los distintos placeholders que acepta printf para imprimir variables o distintos tipos de datos.
32 printf (parte 2)
Los placeholders de la función printf aceptan más parámetros para personalizar la forma en la que las variables son enviadas a pantalla cuando se transforman. Este vídeo contiene información adicional que puede que te interese al menos saber que existe.
33 scanf (parte 1)
Si printf sirve para imprimir por pantalla, scanf sirve para leer de la entrada estandar caracteres y volcarlos en variables. La particularidad de scanf está en que puede hacer conversiones automáticamente a otros tipos que no sea el char. En este primer vídeo dedicado a scanf, hablo de su funcionamiento más rudimentario.
34 scanf (parte 2)
En el capítulo de hoy, lecturas con más y mejor formato, así como tratamiento de errores, aunque sin venirnos demasiado arriba. Sobre todo, ¿es raro que leer de scanf provoque bucles infinitos?
35 fprintf, sprintf y snprintf
Cerramos esta temporada presentando fprintf, sprintf y snprintf, tres funciones parecidas a printf pero que se diferencian en dónde vuelcan lo que van formateando. fprintf permite volcar con formato en archivos y sprintf/snprintf en cadenas de caracteres.
36 Tipos de datos opacos
Los tipos de datos opacos permiten crear punteros a estructuras de datos donde realmente no sabes lo que hay dentro de la estructura, porque todo lo que puedes ver es un puntero. Se trata de una característica avanzada de C que tiene uso principalmente en bibliotecas multiplataforma o en aquellos sitios donde se quiera ocultar la implementación a otros módulos de software.
37 Bibliotecas estáticas
Las bibliotecas estáticas nos permiten reutilizar código entre proyectos fabricando un archivo que empaqueta distintos módulos de código objeto. El propósito de este capítulo es enseñaros cómo se pueden fabricar bibliotecas estáticas con GCC y AR, y cómo luego podemos incluir un archivo .a en GCC para compilar programas que usen bibliotecas estáticas.
38 Bibliotecas dinámicas
Las bibliotecas dinámicas resuelven uno de los problemas de las bibliotecas estáticas: que el código objeto está duplicado en varios ejecutables. En una biblioteca dinámica, el código objeto compartido se mantiene en un archivo separado en todo momento (esos .so o esas .dll que puede que os suenen de algo) que se enlaza sobre la marcha por el propio sistema operativo cuando el programa es lanzado. También (específico para Linux): pegarse con ldd, ldconfig y la variable LD_LIBRARY_PATH.
39 Más flags: i mayúscula (include), wall, werror, pedantic...
Algunos otros flags de GCC que hasta ahora no hemos visto y que pueden ser muy útiles en el momento de desarrollar. En algunos entornos de desarrollo es posible activar opciones que se convierten en el uso de estos flags. Con el flag -I (I mayúscula) podremos incluir directorios de búsqueda. Con las opciones Wall, Werror y pedantic podemos aumentar el nivel de detalle de los mensajes de error.
40 pkg-config
pkg-config es una herramienta para sistemas UNIX como GNU/Linux o *BSD, que facilita la obtención de los parámetros que son necesarios proporcionarles a GCC para que el software que depende de bibliotecas dinámicas que hayamos instalado en nuestro ordenador pueda saber contra qué debe enlazarse.
41 Make
Make es una herramienta muy habitual en sistemas UNIX como es el caso de GNU/Linux, con la que se puede orquestar la compilación de programas compuestos de múltiples archivos, en base a reglas. Este es un tutorial un poco breve para introducir al uso de Make allá donde haga falta, pero tengo un curso de Make con más duración, por si quieres profundizar en algunos de los temas, que puedes ver en https://www.makigas.es/series/make.
42 GDB
Y ya para hablar esta temporada os voy a presentar GDB, que es una herramienta que sirve para depurar programas. La depuración es un proceso que nos permite mirar paso a paso la ejecución de un programa para encontrar y corregir posibles errores que hayamos cometido durante su desarrollo. GDB nos permite depurar de forma integral un programa, ejecutándolo paso a paso, haciendo un seguimiento a ciertas invocaciones, o comprobando el valor de algunas variables.