diff --git a/src/config.ts b/src/config.ts
index 412c12a..e9d8e91 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -61,7 +61,7 @@ export const navBarConfig: NavBarConfig = {
export const profileConfig: ProfileConfig = {
avatar: 'assets/images/avatar.jpg', // Relative to the /src directory. Relative to the /public directory if it starts with '/'
name: 'Grupo 932 - ISyTE',
- bio: 'v1.1',
+ bio: 'v1.1.1',
links: [
/*
{
diff --git a/src/content/posts/c-cpp-programming-course-book.md b/src/content/posts/c-cpp-programming-course-book.md
index d19d032..be728fb 100644
--- a/src/content/posts/c-cpp-programming-course-book.md
+++ b/src/content/posts/c-cpp-programming-course-book.md
@@ -16,4 +16,6 @@ A continuación se muestra una tabla de contenido de todos los artículos en est
1. [Caracteres de C](/grupo932/posts/characters-in-c/)
2. [Tipos de datos (en C)](/grupo932/posts/data-types-in-c/)
+3. [Sinónimos de un tipo (en C)](/grupo932/posts/type-synonyms-in-c/)
+4. [Literales (en C)](/grupo932/posts/literals-in-c/)
diff --git a/src/content/posts/data-types-in-c.md b/src/content/posts/data-types-in-c.md
index ff24834..43c12cf 100644
--- a/src/content/posts/data-types-in-c.md
+++ b/src/content/posts/data-types-in-c.md
@@ -193,12 +193,9 @@ main()
}
```
Ejecución del programa:
-
-
-Color: 3[Entrar]
+Color: 3[Entrar]
3
-
-
+
### *float*
El tipo **float** se utiliza para declarar un dato en coma flotante de 32 bits (4 bytes) en el formato IEEE 754 (este formato utiliza 1 bit para el signo, 8 bits para el exponente y 23 para la [mantisa](https://dle.rae.es/mantisa)). Los datos de tipo **float** almacenan valores con una precisión aproximada de 6-7 digítos. Para especificar que una constante (un literal) es de tipo **float**, hay que añadir al final de su valor la letra 'f' o 'F'. El siguiente ejemplo declara las variables *a*, *b* y *c*, de tipo real de precisión simple:
```c
@@ -222,3 +219,4 @@ Los tipos derivados son más complejos que los tipos primitivos. Siendo franco,
Por otro lado, si sabes usar los tipos derivados, puedes acercarte conmigo para actualizar este artículo con tu apoyo.
:::
+Siguiente artículo: [Sinónimos de un tipo (en C)](/grupo932/posts/type-synonyms-in-c/)
\ No newline at end of file
diff --git a/src/content/posts/literals-in-c.md b/src/content/posts/literals-in-c.md
new file mode 100644
index 0000000..8249ca2
--- /dev/null
+++ b/src/content/posts/literals-in-c.md
@@ -0,0 +1,171 @@
+---
+title: Literales (en C)
+published: 2024-09-21
+description: 'Los literales son valores constantes. Son fundamentales en los lenguajes de programación, incluyendo C. Aprender a usarlos es esencial.'
+image: ''
+tags: [c, recurso, libro, tipos, binario, decimal, hexadecimal]
+category: 'Recurso'
+draft: true
+language: ''
+---
+## Tabla de contenido
+- [Literales enteros](#literales-enteros)
+- [Literales reales](#literales-reales)
+- [Literales de un solo carácter](#literales-de-un-solo-carácter)
+- [Literales de cadena de caracteres](#literales-de-cadena-de-caracteres)
+___
+Artículo previo: [Sinónimos de un tipo (en C)](/grupo932/posts/type-synonyms-in-c/)
+:::note[NOTA]
+Esta información fue principalmente extraída del libro *C/C++ Curso de programación (2ª ed.)*, escrita por *Fco. Javier Ceballos* (páginas 29-32).
+:::
+Un literal es la expresión de un valor de un tipo primitivo, o bien de una cadena de caracteres (conjunto de caracteres entre comillas dobles). Por ejemplo, son literales: `5`, `3.14`, `'a'`, y `"hola"`. En realidad son valores constantes.
+
+Según lo expuesto, un literal en C puede ser: un entero, un real, un carácter y una cadena de caracteres.
+## Literales enteros
+El lenguaje C permite especificar un literal entero en base 10, 8 y 16.
+
+En general, el signo `+` es opcional si el valor es positivo y el signo `-` estará presente siempre que el valor sea negativo. El tipo de un literal entero depende de su base, de su valor y de su sufijo. La sintaxis para especificar un literal entero es:
+
+{[+]|-}literal_entero[{L|U|UL}]
+
+Si el literal es decimal y no tiene sufijo, su tipo es el primero de los tipos `int`, `long int` o `unsigned long int` en el que su valor pueda ser representado.
+
+Si es octal o hexadecimal y no tiene sufijo, su tipo es el primero de los tipos `int`, `unsigned int`, `long int`, `unsigned long int` en el que su valor pueda ser representado.
+
+También se puede indicar explícitamente el tipo de un literal entero, añadiendo los sufijos *L*, *U* o *UL* (mayúsculas o minúsculas).
+
+Si su sufijo es *L*, su tipo es `long` cuando el valor puede ser representado en este tipo, si no es `unsigned long`. Si el sufijo es *U*, su tipo es `unsigned int` cuando el valor puede ser representado en este tipo, si no es `unsigned long`. Si el sufijo es *UL*, su tipo es `unsigned long`.
+
+Un *literal entero decimal* puede tener uno o más dígitos del *0* al *9*, de los cuales el primero de ellos es distinto de *0*. Por ejemplo:
+
+
+ 4326 |
+ constante entera int |
+
+
+ 1522U |
+ constante entera unsigned int |
+
+
+ 1000L |
+ constante entera long |
+
+
+ 325UL |
+ constante entera unsigned long |
+
+
+
+Un *literal entero octal* puede tener uno o más dígitos del *0* al *7*, precedidos por un *0*. Por ejemplo:
+
+
+
+ 0326 |
+ constante entera int en base 8 |
+
+
+
+Un *literal entero hexadecimal* puede tener uno o más dígitos del *0* al *9* y letras de la *A* a la *F* (en mayúsculas o minúsculas) precedidos por *0x* o *0X* (*cero* seguido de *x*). Por ejemplo:
+
+
+
+ 256 |
+ número decimal 256 |
+
+
+ 0400 |
+ número decimal 256 expresado en octal |
+
+
+ 0x100 |
+ número decimal 256 expresado en hexadecimal |
+
+
+ -0400 |
+ número decimal -256 expresado en octal |
+
+
+ -0x100 |
+ número decimal -256 expresado en hexadecimal |
+
+
+
+## Literales reales
+Un literal real está formado por una *parte entera*, seguido por un *punto decimal*, y una *parte fraccionaria*. También se permite la notación científica, en cuyo caso se añade al valor una *e* o *E*, seguida por un exponente positivo o negativo.
+
+{[+]|-}parte-entera.parte-fraccionaria[{e|E}{[+]|-}exponente]
+
+donde *exponente* representa cero o más dígitos del *0* al *9* y *E* o *e* es el símbolo de exponente de la base 10 que puede ser positivo o negativo (2E−5 = 2 × 10-5 ). Si la constante real es positiva no es necesario especificar el signo y si es negativa lleva el signo menos (−). Por ejemplo:
+
+
+ -17.24 |
+ 17.244283 |
+ .008e3 |
+ 27E-3 |
+
+
+Un literal real tiene siempre tipo `double`, a no ser que se añada al mismo una *f* o *F*, en cuyo caso será de tipo `float`. Por ejemplo:
+```c
+17.24F /* constante real de tipo float */
+```
+## Literales de un solo carácter
+Los literales de un solo carácter son de tipo `char`. Este tipo de literales está formado por un único carácter encerrado entre *comillas simples*. Una secuencia de escape es considerada como un único carácter. Algunos ejemplos son:
+
+
+
+ ' ' |
+ espacio en blanco |
+
+
+ 'x' |
+ letra minúscula x |
+
+
+ '\n' |
+ retorno de carro más avance de línea |
+
+
+ '\x07' |
+ pitido |
+
+
+ '\1B' |
+ carácter ASCII Esc |
+
+
+
+El valor de una constante de un solo carácter es el valor que le corresponde en el juego de caracteres de la máquina.
+## Literales de cadena de caracteres
+Un literal de cadena de caracteres es una secuencia de caracteres encerrados entre *comillas dobles* (incluidas las secuencias de escape como `\"`). Por ejemplo:
+```c
+"Esto es una constante de caracteres"
+"3.1415926"
+"Paseo de Pereda 10, Santander"
+"" /* cadena vacía */
+"Lenguaje \"C/C++\"" /* produce: Lenguaje "C/C++" */
+```
+En el ejemplo siguiente el carácter `\n` fuerza a que la cadena "*O pulse Entrar*" se escriba en una línea:
+```c
+printf("Escriba un número entre 1 y 5\nO pulse Entrar");
+```
+Cuando una cadena de caracteres es demasiado larga puede utilizarse el carácter `\` como carácter de continuación. Por ejemplo:
+
+printf("Esta cadena de caracteres es dema\[Entrar]
+siado larga.\n");
+
+El ejemplo anterior daría lugar a una sola línea como la siguiente:
+
+Esta cadena de caracteres es demasiado larga.
+
+Dos o más cadenas separadas por un espacio en blanco serían concatenadas en una sola cadena. Por ejemplo:
+```c
+printf("Primera cadena, "
+"segunda cadena.\n");
+```
+El ejemplo anterior daría lugar a una sola cadena:
+
+Primera cadena, segunda cadena.
+
+Los caracteres de una cadena de caracteres son almacenados en localizaciones sucesivas de memoria. Cada carácter ocupa un byte y una cadena de caracteres es finalizada automáticamente por el carácter nulo representado por la secuencia de escape `\0`. Por ejemplo, la cadena `"hola"` sería representada en memoria así:
+
+h o l a \0
diff --git a/src/content/posts/type-synonyms-in-c.md b/src/content/posts/type-synonyms-in-c.md
index 4f339db..c0dc61d 100644
--- a/src/content/posts/type-synonyms-in-c.md
+++ b/src/content/posts/type-synonyms-in-c.md
@@ -13,9 +13,7 @@ Artículo previo: [Tipos de datos (en C)](/grupo932/posts/data-types-in-c/)
Esta información fue principalmente extraída del libro *C/C++ Curso de programación (2ª ed.)*, escrita por *Fco. Javier Ceballos* (páginas 28-29).
:::
Utilizando la palabra reservada `typedef` podemos declarar nuevos nombres de tipo de datos; esto es, sinónimos de otro tipo ya sean primitivos o derivados, los cuales pueden ser utilizados más tarde para declarar variables de esos tipos. La sintaxis de `typedef` es la siguiente:
-```c
-typedef declaración_tipo sinónimo[, sinónimo]...;
-```
+typedef declaración_tipo sinónimo[, sinónimo]...;
donde *declaración_tipo* es cualquier tipo definido en C, primitivo o derivado, y *sinónimo* es el nuevo nombre elegido para el tipo especificado.
Por ejemplo, la sentencia siguiente declara el nuevo tipo *ulong* como sinónimo del tipo `unsigned long`:
```c
@@ -57,3 +55,4 @@ typedef enum
azul, amarillo, rojo, verde, blanco, negro
} t_colores;
```
+Siguiente artículo: [Literales (en C)](/grupo932/posts/literals-in-c/)
\ No newline at end of file
diff --git a/src/content/spec/history.md b/src/content/spec/history.md
index cf1d249..0bcb934 100644
--- a/src/content/spec/history.md
+++ b/src/content/spec/history.md
@@ -5,17 +5,23 @@ Puede que existan cambios que no hayan sido mencionados en este artículo.
___
## Tabla de contenido
- [1.1](#11) (19/09/2024)
+ - [1.1.1](#111) (20/09/2024)
- [1.0](#10) (13/09/2024)
- [1.0.1](#101) (14/09/2024)
___
## 1.1
(19/09/2024)
-
+
- **Se agregaron 2 nuevos artículos especiales**.
1. [Horario](/grupo932/schedule/)
2. [Historia](#historia)
- Eliminado el botón "Acerca De" en la barra de navegación superior, ya que era redundante.
- Modificado el perfil de la sección izquierda para mostrar el nombre de la página y su versión más reciente.
+### 1.1.1
+(20/09/2024)
+- **Se agregaron 2 nuevos artículos**.
+ 1. [Sinónimos de un tipo (en C)](../posts/type-synonyms-in-c/)
+ 2. [Literales (en C)](../posts/literals-in-c/)
___
## 1.0
(13/09/2024)