HPC06_LenguajeC_01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6853ffb2-8d8a-401b-b056-a5edc558ac4f",
   "metadata": {
    "id": "6853ffb2-8d8a-401b-b056-a5edc558ac4f"
   },
   "source": [
    "<h1 align=\"center\">Computación de Alto Desempeño</h1>\n",
    "<h1 align=\"center\">Lenguaje C</h1>\n",
    "<h1 align=\"center\">2024</h1>\n",
    "<h1 align=\"center\">MEDELLÍN - COLOMBIA </h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d69d340-1be1-4339-b416-97874110ce4b",
   "metadata": {
    "id": "5d69d340-1be1-4339-b416-97874110ce4b"
   },
   "source": [
    "***\n",
    "|[![Outlook](https://img.shields.io/badge/Microsoft_Outlook-0078D4?style=plastic&logo=microsoft-outlook&logoColor=white)](mailto:calvarezh@udemedellin.edu.co)||[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/carlosalvarezh/HPC/HPC06_LenguajeC.ipynb)\n",
    "|-:|:-|--:|\n",
    "|[![LinkedIn](https://img.shields.io/badge/linkedin-%230077B5.svg?style=plastic&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/carlosalvarez5/)|[![@alvarezhenao](https://img.shields.io/twitter/url/https/twitter.com/alvarezhenao.svg?style=social&label=Follow%20%40alvarezhenao)](https://twitter.com/alvarezhenao)|[![@carlosalvarezh](https://img.shields.io/badge/github-%23121011.svg?style=plastic&logo=github&logoColor=white)](https://github.com/carlosalvarezh)|\n",
    "\n",
    "<table>\n",
    " <tr align=left><td><img align=left src=\"https://github.com/carlosalvarezh/Curso_CEC_EAFIT/blob/main/images/CCLogoColorPop1.gif?raw=true\" width=\"25\">\n",
    " <td>Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved MIT license.(c) Carlos Alberto Alvarez Henao</td>\n",
    "</table>\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "615ce020-8ca2-4880-b00d-8d948bda1ae2",
   "metadata": {
    "id": "615ce020-8ca2-4880-b00d-8d948bda1ae2"
   },
   "source": [
    "## Tokens en C"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4e8c16a-08c0-40d5-9e6f-0e4486081f42",
   "metadata": {
    "id": "b4e8c16a-08c0-40d5-9e6f-0e4486081f42"
   },
   "source": [
    "Un *token* en C se puede definir como el elemento individual más pequeño del lenguaje de programación C que tiene significado para el compilador. Es el componente básico de un programa en C."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7de2707b-a0a7-4448-a98c-35fa45042824",
   "metadata": {
    "id": "7de2707b-a0a7-4448-a98c-35fa45042824"
   },
   "source": [
    "### Tipos de Tokens en C"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32085f72-c70b-4ba2-bc57-d29612d076b8",
   "metadata": {
    "id": "32085f72-c70b-4ba2-bc57-d29612d076b8"
   },
   "source": [
    "Los tokens del lenguaje C se pueden clasificar en seis tipos según la función que realizan. Los tipos de tokens en C son los siguientes:\n",
    "\n",
    "1. **Palabras Clave**\n",
    "   Las palabras clave son palabras predefinidas o reservadas en un lenguaje de programación. Cada palabra clave está destinada a realizar una función específica en un programa. Dado que las palabras clave son nombres referidos por el compilador, no se pueden usar como nombres de variables, ya que al hacerlo, se estaría intentando asignar un nuevo significado a la palabra clave, lo cual no está permitido. No se pueden redefinir las palabras clave. Sin embargo, puedes especificar el texto a ser sustituido por las palabras clave antes de la compilación usando directivas del preprocesador de C. El lenguaje C soporta 32 palabras clave, las cuales son:\n",
    "\n",
    "   ```\n",
    "   auto      double    int       struct\n",
    "   break     else      long      switch\n",
    "   case      enum      register  typedef\n",
    "   char      extern    return    union\n",
    "   const     float     short     unsigned\n",
    "   continue  for       signed    void\n",
    "   default   goto      sizeof    volatile\n",
    "   do        if        static    while\n",
    "   ```\n",
    "\n",
    "   **Nota:** El número de palabras clave puede variar según la versión de C que utilices. Por ejemplo, las palabras clave presentes en ANSI C son 32, mientras que en C11 se incrementaron a 44. Además, en la versión más reciente, C23, aumentaron a aproximadamente 54.\n",
    "<p>&nbsp;</p>\n",
    "\n",
    "2. **Identificadores**\n",
    "   Los identificadores se utilizan como términos generales para nombrar variables, funciones y arreglos. Son nombres definidos por el usuario que consisten en una secuencia arbitrariamente larga de letras y dígitos, donde el primer carácter debe ser una letra o un guion bajo (`_`). Los nombres de los identificadores deben diferenciarse en ortografía y mayúsculas/minúsculas de cualquier palabra clave. No puedes usar palabras clave como identificadores; están reservadas para un uso especial. Una vez declarados, puedes usar los identificadores en sentencias posteriores del programa para referirte al valor asociado. Un identificador especial llamado *etiqueta de sentencia* puede usarse en sentencias `goto`.\n",
    "\n",
    "   **Reglas para Nombrar Identificadores:**\n",
    "   - Deben comenzar con una letra o guion bajo (`_`).\n",
    "   - Deben consistir únicamente en letras, dígitos o guion bajo. No se permite ningún otro carácter especial.\n",
    "   - No debe ser una palabra clave.\n",
    "   - No debe contener espacios en blanco.\n",
    "   - Debe tener hasta 31 caracteres de longitud, ya que solo los primeros 31 caracteres son significativos.\n",
    "\n",
    "   **Nota:** Los identificadores distinguen entre mayúsculas y minúsculas, por lo que nombres como `variable` y `Variable` se tratarán como diferentes.\n",
    "\n",
    "   **Ejemplos:**\n",
    "   - `main`: nombre de método.\n",
    "   - `a`: nombre de variable.\n",
    "<p>&nbsp;</p>\n",
    "\n",
    "3. **Constantes**\n",
    "   Las constantes se refieren a variables con valores fijos. Son similares a las variables normales, pero con la diferencia de que sus valores no pueden modificarse en el programa una vez que se definen.\n",
    "\n",
    "   Las constantes pueden pertenecer a cualquiera de los tipos de datos.\n",
    "\n",
    "   **Ejemplos de Constantes en C:**\n",
    "   ```c\n",
    "   const int c_var = 20;\n",
    "   const int* const ptr = &c_var;\n",
    "   ```\n",
    "<p>&nbsp;</p>\n",
    "\n",
    "4. **Cadenas**\n",
    "   Las cadenas no son más que un arreglo de caracteres que termina con un carácter nulo (`\\0`). Este carácter nulo indica el final de la cadena. Las cadenas siempre están encerradas entre comillas dobles. Por otro lado, un carácter está encerrado entre comillas simples en C y C++.\n",
    "\n",
    "   **Ejemplos de Cadenas:**\n",
    "   ```c\n",
    "   char string[20] = {'H', 'o', 'l', 'a', ' ', 'm', 'u', 'n', 'd', 'o', '!','\\0'};\n",
    "   char string[20] = \"Hola mundo!\";\n",
    "   char string [] = \"Hola mundo!\";\n",
    "   ```\n",
    "<p>&nbsp;</p>\n",
    "\n",
    "5. **Símbolos Especiales**\n",
    "   Los siguientes símbolos especiales se utilizan en C y tienen un significado particular, por lo que no se pueden usar para otro propósito. Algunos de estos son:\n",
    "\n",
    "   - **Corchetes `[]`:** Los corchetes de apertura y cierre se utilizan como referencias a elementos de arreglos, indicando subscripciones unidimensionales y multidimensionales.\n",
    "   - **Paréntesis `()`**: Estos símbolos especiales se utilizan para indicar llamadas a funciones y parámetros de funciones.\n",
    "   - **Llaves `{}`:** Las llaves de apertura y cierre marcan el inicio y el fin de un bloque de código que contiene más de una sentencia ejecutable.\n",
    "   - **Coma `,`:** Se utiliza para separar más de una sentencia, como al separar parámetros en llamadas a funciones.\n",
    "   - **Dos puntos `:`:** Es un operador que esencialmente invoca algo llamado lista de inicialización.\n",
    "   - **Punto y coma `;`:** Se conoce como terminador de sentencia. Indica el final de una entidad lógica. Por eso, cada sentencia individual debe terminar con un punto y coma.\n",
    "   - **Asterisco `*`:** Se utiliza para crear una variable puntero y para la multiplicación de variables.\n",
    "   - **Operador de asignación `=`:** Se utiliza para asignar valores y para la validación de operaciones lógicas.\n",
    "   - **Preprocesador `#`:** El preprocesador es un procesador de macros que se utiliza automáticamente por el compilador para transformar tu programa antes de la compilación real.\n",
    "   - **Punto `.`:** Se usa para acceder a miembros de una estructura o unión.\n",
    "   - **Tilde `~`:** Operador de complemento a uno (bitwise one's complement).\n",
    "<p>&nbsp;</p>\n",
    "\n",
    "6. **Operadores**\n",
    "   Los operadores son símbolos que desencadenan una acción cuando se aplican a variables u otros objetos en C. Los elementos de datos sobre los que actúan los operadores se llaman operandos. Dependiendo del número de operandos sobre los que puede actuar un operador, los operadores se pueden clasificar de la siguiente manera:\n",
    "\n",
    "   - **Operadores Unarios:** Son aquellos operadores que requieren solo un operando para actuar. Ejemplos de estos son los operadores de incremento y decremento.\n",
    "   - **Operadores Binarios:** Son aquellos operadores que requieren dos operandos para actuar. Los operadores binarios se pueden clasificar en:\n",
    "     - Operadores aritméticos\n",
    "     - Operadores relacionales\n",
    "     - Operadores lógicos\n",
    "     - Operadores de asignación\n",
    "     - Operadores a nivel de bits\n",
    "   - **Operador Ternario:** Es el operador que requiere tres operandos para actuar. El operador condicional (`?`) también se conoce como el operador ternario."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4203a317-f503-4fa3-9178-8075bbf735e8",
   "metadata": {
    "id": "4203a317-f503-4fa3-9178-8075bbf735e8"
   },
   "source": [
    "## Palabras Clave en C"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7eacbb39-af39-496e-83b3-c6bc4b6adf57",
   "metadata": {
    "id": "7eacbb39-af39-496e-83b3-c6bc4b6adf57"
   },
   "source": [
    "En el lenguaje de programación C, existen muchas reglas que ayudan a evitar diferentes tipos de errores. Una de estas reglas es que no se pueden declarar nombres de variables con palabras como `auto`, `long`, etc. Esto se debe a que estas son palabras clave. A continuación, revisaremos todas las palabras clave en el lenguaje C."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8692b52e-7c4a-4a01-9aec-5a2d7ec9356e",
   "metadata": {
    "id": "8692b52e-7c4a-4a01-9aec-5a2d7ec9356e"
   },
   "source": [
    "#### ¿Qué son las Palabras Clave?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dc10adc",
   "metadata": {},
   "source": [
    "Las palabras clave son palabras predefinidas o reservadas que tienen significados especiales para el compilador. Son parte de la sintaxis del lenguaje y no se pueden usar como identificadores en el programa. A continuación, se muestra una lista de las palabras clave en C o palabras reservadas en el lenguaje de programación C:\n",
    "\n",
    "```\n",
    "auto        break       case        char        const\n",
    "continue    default     do          double      else\n",
    "enum        extern      float       for         goto\n",
    "if          int         long        register    return\n",
    "short       signed      sizeof      static      struct\n",
    "switch      typedef     union       unsigned    void\n",
    "volatile    while\n",
    "```\n",
    "\n",
    "- **`auto`:** es la clase de almacenamiento predeterminada para una variable que se declara dentro de una función o un bloque. Las variables `auto` solo se pueden acceder dentro de la función o bloque donde se declaran. Por defecto, las variables `auto` tienen valores basura asignados. Las variables automáticas también se llaman variables locales porque son locales a una función.\n",
    "\n",
    "```c\n",
    "auto int num;\n",
    "```\n",
    "\n",
    "Aquí, `num` es una variable de la clase de almacenamiento `auto` y su tipo es `int`. A continuación se muestra un programa en C para demostrar la palabra clave `auto`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8177d9f2",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "int printvalue()\n",
    "{\n",
    "  auto int a = 10;\n",
    "  printf(\"%d\", a);\n",
    "}\n",
    "\n",
    "// Código principal\n",
    "int main()\n",
    "{\n",
    "  printvalue();\n",
    "  return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de720bcf",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "10\n",
    "```\n",
    "\n",
    "- **`break` y `continue`:** La instrucción `break` se utiliza para terminar el bucle más interno. Generalmente, termina un bucle o una instrucción `switch`. La instrucción `continue` salta a la siguiente iteración del bucle. A continuación se muestra un programa en C para demostrar `break` y `continue`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c20bb517",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "// Código principal\n",
    "int main()\n",
    "{\n",
    "  for (int i = 1; i <= 10; i++)\n",
    "  {\n",
    "    if (i == 2)\n",
    "    {\n",
    "      continue;\n",
    "    }\n",
    "    if (i == 6)\n",
    "    {\n",
    "      break;\n",
    "    }\n",
    "    printf(\"%d \", i);\n",
    "  }\n",
    "  return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e671b509",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "1 3 4 5\n",
    "```\n",
    "\n",
    "- **`switch`, `case`, y `default`:** La instrucción `switch` en C se utiliza como una alternativa a la estructura `if-else`. Para una sola variable, permite ejecutar múltiples operaciones para diferentes valores posibles de esa variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "028d71fd",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "switch(Expression)\n",
    "{\n",
    "    case '1': // operación 1\n",
    "            break;\n",
    "    case '2': // operación 2\n",
    "            break;\n",
    "    default: // instrucción por defecto\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79f6c95f",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "// Código principal\n",
    "int main() {\n",
    "  int i = 4;\n",
    "  switch (i) {\n",
    "    case 1:\n",
    "      printf(\"Case 1\\n\");break;\n",
    "    case 2:\n",
    "      printf(\"Case 2\\n\");break;\n",
    "    case 3:\n",
    "      printf(\"Case 3\\n\");break;\n",
    "    case 4:\n",
    "      printf(\"Case 4\\n\");break;\n",
    "    default:\n",
    "      printf(\"Default\\n\");break;\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3742d18",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "Case 4\n",
    "```\n",
    "\n",
    "**Nota:** Es recomendable agregar una instrucción `break` después de cada caso para que la instrucción `switch` no siga evaluando los casos restantes.\n",
    "\n",
    "- **`char`:** se utiliza para declarar una variable de tipo carácter.\n",
    "\n",
    "```c\n",
    "char x = 'D';\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e0e577b",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "// Código principal\n",
    "int main() {\n",
    "  char c = 'a';\n",
    "  printf(\"%c\", c);\n",
    "  return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09dc0d90",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "a\n",
    "```\n",
    "\n",
    "- **`const`:** define e <stdio.h>\n",
    "\n",
    "```c\n",
    "// Código una variable cuyo valor no puede ser cambiado.\n",
    "const int num = 10;\n",
    "```\n",
    "\n",
    "A continuación se muestra un programa en C para demostrar la palabra clave `const`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89362778",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "// Código principal\n",
    "int main() {\n",
    "  const int a = 11;\n",
    "  a = a + 2;\n",
    "  printf(\"%d\", a);\n",
    "  return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83c28585",
   "metadata": {},
   "source": [
    "Este código producirá un error porque el entero `a` fue definido como constante y se intentó cambiar su valor.\n",
    "\n",
    "**Salida:**\n",
    "\n",
    "```\n",
    "error: assignment of read-only variable 'a'\n",
    "       a = a + 2;\n",
    "```\n",
    "\n",
    "- **`do`:** La instrucción `do` se utiliza para declarar un bucle `do-while`. Un bucle `do-while` es un bucle que se ejecuta al menos una vez y luego verifica su condición para ver si debe continuar con el bucle. Después de la primera iteración, continuará ejecutando el código mientras la condición sea verdadera."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20159e77",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "// Código principal\n",
    "int main()\n",
    "{\n",
    "  int i = 1;\n",
    "  do {\n",
    "    printf(\"%d \", i);\n",
    "    i++;\n",
    "  } while(i <= 5);\n",
    "  \n",
    "  return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "416f3d5e",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "1 2 3 4 5\n",
    "```\n",
    "\n",
    "- **`double` y `float`:** Los tipos de datos `double` y `float` se utilizan para declarar variables de tipo decimal. Son similares, pero los `double` tienen 15 dígitos decimales, mientras que los `float` solo tienen 7.\n",
    "\n",
    "**Ejemplo:**\n",
    "\n",
    "```c\n",
    "float marks = 97.5;\n",
    "double num;\n",
    "```\n",
    "\n",
    "A continuación se muestra un programa en C para demostrar las palabras clave `double` y `float`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2deb0908",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "// Código principal\n",
    "int main() {\n",
    "  float f = 0.3;\n",
    "  double d = 10.67;\n",
    "  printf(\"Float value: %f\\n\", f);\n",
    "  printf(\"Double value: %f\\n\", d);\n",
    "  return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47754c2d",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "\n",
    "```\n",
    "Float value: 0.300000\n",
    "Double value: 10.670000\n",
    "```\n",
    "\n",
    "- **`if-else`:** La instrucción `if-else` se utiliza para tomar decisiones. Si una condición es verdadera, entonces se ejecutará un bloque de código; si no es verdadera (`else`), entonces se ejecutará un bloque de código diferente.\n",
    "\n",
    "```c\n",
    "if(marks == 97) {\n",
    "    // si marks es 97 entonces se ejecutará este bloque de código\n",
    "}\n",
    "else {\n",
    "    // de lo contrario se ejecutará este bloque de código\n",
    "}\n",
    "```\n",
    "\n",
    "A continuación se muestra un programa en C para demostrar una instrucción `if-else`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a5cf1cb",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "// Código principal\n",
    "int main()\n",
    "{\n",
    "  int a = 10;\n",
    "  if(a < 11)\n",
    "  {\n",
    "    printf(\"A es menor que 11\");\n",
    "  }\n",
    "  else\n",
    "  {\n",
    "    printf(\"A es igual o mayor que 11\");\n",
    "  }  \n",
    "  return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "904369d8",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "A es menor que 11\n",
    "```\n",
    "\n",
    "- **`enum`:** La palabra clave `enum` se utiliza para declarar una enumeración. Una enumeración es un tipo de datos definido por el usuario que contiene una lista de constantes enteras definidas por el usuario. Por defecto, el valor de cada constante es su índice (comenzando en cero), aunque esto se puede cambiar. Puedes declarar un objeto de una enumeración y asignarle uno de los valores constantes que declaraste previamente. Aquí hay un ejemplo de cómo se podría usar una enumeración:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9e1e722",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include<stdio.h>\n",
    "\n",
    "// declaración de enum\n",
    "enum semana{Lun, Mar, Mie, Jue, Vie, Sab, Dom};\n",
    "\n",
    "// Código principal\n",
    "int main()\n",
    "{\n",
    "  // objeto de la enum (semana), llamado dia\n",
    "  enum semana dia;\n",
    "  dia = Mie;\n",
    "  printf(\"%d\", dia);\n",
    "  return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fee7fdf6",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "2\n",
    "```\n",
    "\n",
    "- **`extern`:** La palabra clave `extern` se utiliza para declarar una variable o una función que tiene un enlace externo fuera del archivo de declaración."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "872cea3d",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "extern int a;\n",
    "\n",
    "int main(){\n",
    "  \n",
    "    printf(\"%d\", a);\n",
    "\n",
    "      return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4600392d",
   "metadata": {},
   "source": [
    "- **`for`:** La palabra clave `for` se utiliza para declarar un bucle `for`. Un bucle `for` es un bucle que se especifica para ejecutarse una cierta cantidad de veces.\n",
    "\n",
    "A continuación se muestra un programa en C para demostrar un bucle `for`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5acd48ce",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "// Código principal\n",
    "int main()\n",
    "{\n",
    "  for (int i = 0; i < 5; i++)\n",
    "  {\n",
    "    printf(\"%d \", i);\n",
    "  }\n",
    "  return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0097b5f3",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "0 1 2 3 4\n",
    "```\n",
    "\n",
    "- **`goto`:** La instrucción `goto` se utiliza para transferir el control del programa a la etiqueta dada. Se utiliza para saltar de un lugar a otro dentro de una función.\n",
    "\n",
    "**Ejemplo:**\n",
    "\n",
    "```c\n",
    "goto etiqueta;\n",
    "// código\n",
    "etiqueta:\n",
    "```\n",
    "\n",
    "A continuación se muestra un programa en C para demostrar la palabra clave `goto`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0dcd3c05",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "// Función para imprimir números del 1 al 10\n",
    "void printNumbers() {\n",
    "    int n = 1;\n",
    "\n",
    "etiqueta:\n",
    "    printf(\"%d \", n);\n",
    "    n++;\n",
    "    if (n <= 10) goto etiqueta;\n",
    "}\n",
    "\n",
    "// Código principal\n",
    "int main(){\n",
    "    printNumbers();\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95d3fbed",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "1 2 3 4 5 6 7 8 9 10\n",
    "```\n",
    "\n",
    "- **`int`:** La palabra clave `int` se utiliza en una declaración de tipo para dar a una variable un tipo entero. En C, la variable entera debe tener un rango de al menos -32768 a +32767.\n",
    "\n",
    "**Ejemplo:**\n",
    "\n",
    "```c\n",
    "int x = 10;\n",
    "```\n",
    "\n",
    "A continuación se muestra un programa en C para demostrar la palabra clave `int`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acedaf4c",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "void suma() {\n",
    "    int a = 10, b = 20;\n",
    "    int suma;\n",
    "    suma = a + b;\n",
    "    printf(\"%d\", suma);\n",
    "}\n",
    "\n",
    "// Código principal\n",
    "int main() {\n",
    "    suma();\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "027e957c",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "30\n",
    "```\n",
    "\n",
    "- **`short`, `long`, `signed`, y `unsigned`:** Los diferentes tipos de datos también tienen diferentes rangos hasta los cuales pueden almacenar números. Estos rangos pueden variar de un compilador a otro. A continuación se muestra una lista de rangos junto con el requerimiento de memoria y los especificadores de formato en el compilador GCC de 32 bits.\n",
    "\n",
    "| Tipo de Dato | Memoria (bytes) | Rango | Especificador de Formato |\n",
    "|--------------|-----------------|-------|--------------------------|\n",
    "| short int    | 2               | -32,768 a 32,767 | %hd |\n",
    "| unsigned short int | 2         | 0 a 65,535 | %hu |\n",
    "| unsigned int | 4               | 0 a 4,294,967,295 | %u |\n",
    "| long int     | 4               | -2,147,483,648 a 2,147,483,647 | %ld |\n",
    "| unsigned long int | 4          | 0 a 4,294,967,295 | %lu |\n",
    "| long long int | 8              | -(2^63) a (2^63)-1 | %lld |\n",
    "| unsigned long long int | 8     | 0 a 18,446,744,073,709,551,615 | %llu |\n",
    "| signed char  | 1               | -128 a 127 | %c |\n",
    "| unsigned char | 1              | 0 a 255 | %c |\n",
    "| long double  | 16              | 3.4E-4932 a 1.1E+4932 | %Lf |\n",
    "\n",
    "A continuación se muestra un programa en C para demostrar las palabras clave `short`, `long`, `signed` y `unsigned`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78aecf6b",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "// Código principal\n",
    "int main() {\n",
    "  // entero corto\n",
    "  short int a = 12345;\n",
    "  \n",
    "  // entero con signo\n",
    "  signed int b = -34;\n",
    "  \n",
    "  // entero sin signo\n",
    "  unsigned int c = 12;\n",
    "  \n",
    "  // L o l se usa para enteros largos en C.\n",
    "  long int d = 99998L;\n",
    "  \n",
    "  printf(\"Valor entero con tipo short int: %hd\", a);\n",
    "  printf(\"\\nValor entero con tipo signed int: %d\", b);\n",
    "  printf(\"\\nValor entero con tipo unsigned int: %u\", c);\n",
    "  printf(\"\\nValor entero con tipo long int: %ld\", d);\n",
    "  return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "034303fd",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "Valor entero con tipo short int: 12345\n",
    "Valor entero con tipo signed int: -34\n",
    "Valor entero con tipo unsigned int: 12\n",
    "Valor entero con tipo long int: 99998\n",
    "```\n",
    "\n",
    "- **`return`:** La instrucción `return` devuelve un valor al lugar desde donde se llamó a la función.\n",
    "\n",
    "**Ejemplo:**\n",
    "\n",
    "```c\n",
    "return x;\n",
    "```\n",
    "\n",
    "A continuación se muestra un programa en C para demostrar la palabra clave `return`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "653b2d1b",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int suma(int x, int y) {\n",
    "  int suma;\n",
    "  suma = x + y;\n",
    "  return suma;\n",
    "}\n",
    "\n",
    "// Código principal\n",
    "int main() {\n",
    "  int num1 = 10;\n",
    "  int num2 = 20;\n",
    "  printf(\"Suma: %d\",\n",
    "          suma(num1, num2));\n",
    "  return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d6d42c4",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "Suma: 30\n",
    "```\n",
    "\n",
    "- **`sizeof`:** es una palabra clave que obtiene el tamaño de una expresión (variables, arreglos, punteros, etc.) en bytes.\n",
    "\n",
    "**Ejemplo:**\n",
    "\n",
    "```c\n",
    "sizeof(char);\n",
    "sizeof(int);\n",
    "sizeof(float);\n",
    "```\n",
    "\n",
    "A continuación se muestra un programa en C para demostrar la palabra clave `sizeof`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c8c2af4",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "// Código principal\n",
    "int main() {\n",
    "  int x = 10;\n",
    "  printf(\"%d\", sizeof(x));\n",
    "  return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cc08fc3",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "4\n",
    "```\n",
    "\n",
    "- **`register`:** Las variables de registro le indican al compilador que almacene variables en el registro de la CPU en lugar de en la memoria. Las variables que se usan con frecuencia se mantienen en los registros de la CPU para un acceso más rápido.\n",
    "\n",
    "**Ejemplo:**\n",
    "\n",
    "```c\n",
    "register char c = 's';\n",
    "```\n",
    "\n",
    "- **`static`:** La palabra clave `static` se utiliza para crear variables estáticas. Una variable estática no está limitada por un alcance y puede ser utilizada en todo el programa. Su valor se preserva incluso después de que su alcance ha terminado.\n",
    "\n",
    "**Ejemplo:**\n",
    "\n",
    "```c\n",
    "static int num;\n",
    "```\n",
    "\n",
    "- **`struct`:** La palabra clave `struct` en el lenguaje de programación C se utiliza para declarar una estructura. Una estructura es una lista de variables (que pueden ser de diferentes tipos de datos) que se agrupan bajo un solo tipo de datos.\n",
    "\n",
    "**Ejemplo:**\n",
    "\n",
    "```c\n",
    "struct Geek {\n",
    "    char name[50];\n",
    "    int num;\n",
    "    double var;\n",
    "};\n",
    "```\n",
    "\n",
    "A continuación se muestra un programa en C para demostrar la palabra clave `struct`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c45efd9",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "#include <string.h>\n",
    "\n",
    "struct Books {\n",
    "  char  title[50];\n",
    "  char  author[50];\n",
    "};\n",
    "\n",
    "// Código principal\n",
    "int main( ) {\n",
    "  // Declarar Book1 de tipo Book\n",
    "  struct Books book1;        \n",
    "   \n",
    " // especificación del libro 1\n",
    " strcpy(book1.title, \"Programación en C++\");\n",
    " strcpy(book1.author, \"Bjarne Stroustrup\");\n",
    "\n",
    " // Imprimir detalles del libro\n",
    " printf(\"Título del libro 1: %s\\n\", book1.title);\n",
    " printf(\"Autor del libro 1: %s\\n\", book1.author);\n",
    " return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5623432",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "Título del libro 1: Programación en C++\n",
    "Autor del libro 1: Bjarne Stroustrup\n",
    "```\n",
    "\n",
    "- **`typedef`:** La palabra clave `typedef` en el lenguaje de programación C se utiliza para definir un tipo de datos con un nuevo nombre en el programa. La palabra clave `typedef` se utiliza para hacer que nuestro código sea más legible.\n",
    "\n",
    "**Ejemplo:**\n",
    "\n",
    "```c\n",
    "typedef long num;\n",
    "```\n",
    "\n",
    "En este ejemplo, hemos cambiado el nombre del tipo de datos `long` a `num`.\n",
    "\n",
    "- **`union`:** La `union` es un tipo de datos definido por el usuario. Todos los miembros de datos que se declaran bajo la palabra clave `union` comparten la misma ubicación de memoria.\n",
    "\n",
    "**Ejemplo:**\n",
    "\n",
    "```c\n",
    "union datos {\n",
    "    int x;\n",
    "    char s;\n",
    "} obj;\n",
    "```\n",
    "\n",
    "A continuación se muestra un programa en C para la palabra clave `union`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44928dd0",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "union estudiante {  \n",
    "  int edad;  \n",
    "  char calificacion;   \n",
    "} e;  \n",
    "\n",
    "// Código principal\n",
    "int main() {  \n",
    "  e.edad = 15;  \n",
    "  e.calificacion = 56;\n",
    "  printf(\"edad = %d\", e.edad);  \n",
    "  printf(\"\\ncalificación = %d\", e.calificacion);  \n",
    "}  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4d09b3b-9808-408f-8210-7cdb264cb05b",
   "metadata": {
    "id": "d4d09b3b-9808-408f-8210-7cdb264cb05b"
   },
   "source": [
    "**Salida:**\n",
    "```\n",
    "edad = 56\n",
    "calificación = 56\n",
    "```\n",
    "\n",
    "- **`void`:** La palabra clave `void` significa \"nada\", es decir, valor nulo. Cuando se utiliza `void` como tipo de retorno de una función, se especifica que no tiene valor de retorno.\n",
    "\n",
    "**Ejemplo:**\n",
    "\n",
    "```c\n",
    "void fun() {\n",
    "    // programa\n",
    "}\n",
    "```\n",
    "\n",
    "- **`volatile`:** La palabra clave `volatile` se utiliza para crear objetos volátiles. Los objetos que se declaran como `volatile` se omiten de la optimización, ya que sus valores pueden cambiar por código fuera del alcance del código actual en cualquier momento.\n",
    "\n",
    "**Ejemplo:**\n",
    "\n",
    "```c\n",
    "const volatile calificaciones = 98;\n",
    "```\n",
    "\n",
    "Las calificaciones se declaran como constantes, por lo que no pueden ser cambiadas por el programa. Pero el hardware puede cambiarlas, ya que son objetos volátiles.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45c152a3-e20f-4312-b288-c62addf9a65f",
   "metadata": {
    "id": "45c152a3-e20f-4312-b288-c62addf9a65f"
   },
   "source": [
    "### **Variables en C**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4D3fgvrRlgVL",
   "metadata": {
    "id": "4D3fgvrRlgVL"
   },
   "source": [
    "Las variables en C son nombres asociados a ubicaciones de memoria que almacenan datos de diferentes tipos. Son fundamentales en cualquier programa, permitiendo almacenar, recuperar y manipular datos de manera eficiente. A continuación, se presentan los aspectos más importantes sobre las variables en C, dirigidos a alguien que ya tiene experiencia en programación, pero no en este lenguaje.\n",
    "\n",
    "1. **Declaración, Definición e Inicialización de Variables**\n",
    "- **Declaración:** Informa al compilador sobre la existencia de una variable con un nombre y tipo de datos específicos, pero no asigna memoria ni un valor. Ejemplo: `int var;`\n",
    "- **Definición:** Asigna memoria para la variable y le puede asignar un valor inicial (si se hace al mismo tiempo que la declaración). Ejemplo: `int var = 10;`\n",
    "- **Inicialización:** Asigna un valor inicial a la variable durante su declaración. Ejemplo: `int var = 10;`\n",
    "  \n",
    "  **Diferencia:** La inicialización ocurre cuando se declara una variable y se le asigna un valor inicial. La asignación, en cambio, se refiere a cambiar el valor de una variable ya declarada. Ejemplo:\n",
    "  \n",
    "  ```c\n",
    "  int a = 10;  // Inicialización\n",
    "  a = 20;      // Asignación\n",
    "  ```\n",
    "\n",
    "2. **Tipos de Variables en C**\n",
    "- **Variables Locales:** Declaradas dentro de una función o bloque, solo accesibles dentro de ese ámbito.\n",
    "  ```c\n",
    "  void funcion() {\n",
    "      int x = 10; // variable local\n",
    "  }\n",
    "  ```\n",
    "- **Variables Globales:** Declaradas fuera de funciones, accesibles en cualquier parte del programa.\n",
    "  ```c\n",
    "  int x = 20; // variable global\n",
    "  ```\n",
    "\n",
    "- **Variables Estáticas:** Definidas con la palabra clave `static`, conservan su valor entre llamadas a la función.\n",
    "  ```c\n",
    "  static int y = 30; // variable estática\n",
    "  ```\n",
    "\n",
    "- **Variables Automáticas:** Son variables locales por defecto, pueden declararse explícitamente con la palabra clave `auto`.\n",
    "  ```c\n",
    "  auto int y = 20; // variable automática\n",
    "  ```\n",
    "\n",
    "- **Variables Externas:** Compartidas entre múltiples archivos C, se declaran con la palabra clave `extern`.\n",
    "  ```c\n",
    "  extern int x = 10; // variable externa\n",
    "  ```\n",
    "\n",
    "- **Variables de Registro:** Almacenadas en registros de la CPU para acceso rápido, declaradas con la palabra clave `register`.\n",
    "  ```c\n",
    "  register int var = 22; // variable de registro\n",
    "  ```\n",
    "\n",
    "3. **Variables Constantes**\n",
    "Las variables constantes son variables de solo lectura que no pueden modificarse una vez definidas. Se declaran con la palabra clave `const`.\n",
    "```c\n",
    "const int constante = 20;\n",
    "```\n",
    "\n",
    "4. **Ejemplos Prácticos**\n",
    "- **Declaración, Definición e Inicialización:**\n",
    "  ```c\n",
    "  int defined_var;\n",
    "  defined_var = 12;\n",
    "  int ini_var = 25;\n",
    "  ```\n",
    "\n",
    "- **Variables Locales y Globales:**\n",
    "  ```c\n",
    "  int x = 20; // global\n",
    "\n",
    "  void funcion() {\n",
    "      int y = 10; // local\n",
    "  }\n",
    "  ```\n",
    "\n",
    "- **Variables Estáticas:**\n",
    "  ```c\n",
    "  void funcion() {\n",
    "      static int y = 30;\n",
    "      y += 10;\n",
    "  }\n",
    "  ```\n",
    "\n",
    "5. **Reglas para Nombres de Variables**\n",
    "- Los nombres de las variables deben contener solo letras, dígitos y guion bajo (`_`).\n",
    "- Deben comenzar con una letra o guion bajo.\n",
    "- No pueden contener espacios en blanco ni ser palabras reservadas.\n",
    "\n",
    "Este resumen cubre los aspectos fundamentales de las variables en C, con un enfoque práctico y orientado a quienes ya tienen experiencia en programación, pero buscan familiarizarse con los conceptos específicos de C."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "rzJo9N1Yntwi",
   "metadata": {
    "id": "rzJo9N1Yntwi"
   },
   "source": [
    "### **Resumen sobre Constantes en C**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a3ce7c5",
   "metadata": {},
   "source": [
    "En el lenguaje de programación C, las constantes son variables de solo lectura cuyo valor no puede modificarse después de haber sido declaradas. Son fundamentales cuando se necesitan valores fijos a lo largo de la ejecución de un programa. A continuación, se detallan los aspectos más importantes sobre las constantes en C, dirigidos a personas con experiencia en programación, pero que no tienen conocimientos específicos en este lenguaje.\n",
    "\n",
    "### 1. **Definición de Constantes**\n",
    "Una constante en C es una variable cuyo valor no se puede cambiar una vez que ha sido asignado. Se definen utilizando la palabra clave `const` y deben ser inicializadas en el momento de su declaración.\n",
    "\n",
    "**Sintaxis:**\n",
    "```c\n",
    "const tipo_de_dato nombre_variable = valor;\n",
    "```\n",
    "\n",
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38f2d1f6",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "int main() {\n",
    "    const int int_const = 25;       // constante entera\n",
    "    const char char_const = 'A';    // constante de carácter\n",
    "    const float float_const = 15.66; // constante flotante\n",
    "\n",
    "    printf(\"Valor de la constante entera: %d\\n\", int_const);\n",
    "    printf(\"Valor de la constante de carácter: %c\\n\", char_const);\n",
    "    printf(\"Valor de la constante flotante: %f\", float_const);\n",
    "\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f3bec33",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "Valor de la constante entera: 25\n",
    "Valor de la constante de carácter: A\n",
    "Valor de la constante flotante: 15.660000\n",
    "```\n",
    "\n",
    "**Importante:** Las constantes deben ser inicializadas al momento de su declaración, de lo contrario, almacenarán un valor basura y no se podrán modificar.\n",
    "\n",
    "#### 2. **Tipos de Constantes en C**\n",
    "Las constantes pueden ser de varios tipos, similares a los tipos de datos de las variables en C:\n",
    "\n",
    "- **Constante Entera:** Almacena valores enteros.\n",
    "- **Constante de Carácter:** Almacena un solo carácter.\n",
    "- **Constante de Punto Flotante:** Almacena valores decimales.\n",
    "- **Constante de Doble Precisión:** Almacena valores decimales con mayor precisión.\n",
    "- **Constante de Arreglo:** Almacena una serie de valores.\n",
    "- **Constante de Estructura:** Almacena un grupo de variables bajo un solo nombre.\n",
    "\n",
    "Para definir cualquier tipo de constante, simplemente se añade la palabra clave `const` al inicio de la declaración.\n",
    "\n",
    "#### 3. **Propiedades de las Constantes en C**\n",
    "- **Inicialización con Declaración:** Las constantes deben ser inicializadas en el momento de su declaración.\n",
    "- **Inmutabilidad:** Una vez definida, el valor de una constante no puede ser modificado durante la ejecución del programa.\n",
    "\n",
    "**Ejemplo de Inmutabilidad:**\n",
    "El siguiente código intentará modificar una constante después de su declaración, lo cual generará un error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18a7b0fc",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "int main() {\n",
    "    const int var = 10;\n",
    "    var = 20;  // Error: no se puede asignar un valor a una constante\n",
    "\n",
    "    printf(\"Valor de var: %d\", var);\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "262249cf",
   "metadata": {},
   "source": [
    "**Salida:**\n",
    "```\n",
    "error: assignment of read-only variable 'var'\n",
    "```\n",
    "\n",
    "#### 4. **Diferencia entre Constantes y Literales**\n",
    "- **Constantes:** Son variables que, una vez declaradas, no se pueden modificar. Se definen usando la palabra clave `const`.\n",
    "- **Literals:** Son valores fijos que se asignan directamente a las variables o constantes. Por ejemplo, `24`, `15.5`, `'a'`, `\"Geeks\"`, etc.\n",
    "\n",
    "#### 5. **Definición de Constantes usando `#define`**\n",
    "Las constantes también se pueden definir utilizando la directiva del preprocesador `#define`, la cual crea macros que funcionan como constantes. Sin embargo, esta técnica no es preferida, ya que puede introducir errores y hacer el código difícil de mantener.\n",
    "\n",
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12841c42",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "#define pi 3.14\n",
    "\n",
    "int main() {\n",
    "    printf(\"El valor de pi: %.2f\", pi);\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lrpg1Mj_nt7-",
   "metadata": {
    "id": "lrpg1Mj_nt7-"
   },
   "source": [
    "**Salida:**\n",
    "```\n",
    "El valor de pi: 3.14\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "EoP6313Sp3Yl",
   "metadata": {
    "id": "EoP6313Sp3Yl"
   },
   "source": [
    "### **Calificador `const` en C**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04e01030",
   "metadata": {},
   "source": [
    "En el lenguaje de programación C, el calificador `const` se utiliza para declarar que una variable no debe cambiar su valor después de ser inicializada. Este calificador se aplica en varios contextos para asegurar que ciertas variables permanezcan inmutables, lo que contribuye a la claridad y seguridad del código.\n",
    "\n",
    "#### 1. **Variables Constantes**\n",
    "Una variable constante se define utilizando `const`, lo que indica que su valor no puede modificarse después de la inicialización.\n",
    "\n",
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82b7b975",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "int main() {\n",
    "    const int var = 100;\n",
    "    var = 200; // Error de compilación\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50dba491",
   "metadata": {},
   "source": [
    "En este ejemplo, intentar modificar el valor de `var` genera un error, ya que es una constante.\n",
    "\n",
    "#### 2. **Puntero a Constante**\n",
    "Un puntero a una constante (`const int* ptr` o `int const* ptr`) permite cambiar la dirección a la que apunta el puntero, pero no el valor del objeto al que apunta.\n",
    "\n",
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f5d20cf",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "int main(void) {\n",
    "    int i = 10;\n",
    "    const int* ptr = &i;\n",
    "\n",
    "    *ptr = 100; // Error: no se puede modificar el valor apuntado\n",
    "    int j = 20;\n",
    "    ptr = &j;   // Válido: se puede cambiar a qué variable apunta el puntero\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a83d46f0",
   "metadata": {},
   "source": [
    "En este caso, `ptr` puede apuntar a diferentes variables, pero no se puede cambiar el valor de la variable a la que apunta.\n",
    "\n",
    "#### 3. **Puntero Constante a Variable**\n",
    "Un puntero constante a una variable (`int* const ptr`) es un puntero cuyo valor no puede cambiar después de la inicialización, aunque se puede modificar el valor de la variable a la que apunta.\n",
    "\n",
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1426d3cc",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "int main(void) {\n",
    "    int i = 10;\n",
    "    int* const ptr = &i;\n",
    "\n",
    "    *ptr = 100; // Válido: se puede cambiar el valor apuntado\n",
    "    int j = 20;\n",
    "    ptr = &j;   // Error: no se puede cambiar el puntero para que apunte a otra variable\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b90abb9c",
   "metadata": {},
   "source": [
    "Aquí, `ptr` siempre apuntará a la misma dirección de memoria (la variable `i`), pero el valor de `i` puede cambiarse a través del puntero.\n",
    "\n",
    "#### 4. **Puntero Constante a Constante**\n",
    "Un puntero constante a una constante (`const int* const ptr`) no permite cambiar ni el valor apuntado ni la dirección a la que apunta el puntero.\n",
    "\n",
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c121a975",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "int main(void) {\n",
    "    int i = 10;\n",
    "    const int* const ptr = &i;\n",
    "\n",
    "    *ptr = 100; // Error: no se puede modificar el valor apuntado\n",
    "    int j = 20;\n",
    "    ptr = &j;   // Error: no se puede cambiar el puntero para que apunte a otra variable\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fgdKOKhip6zV",
   "metadata": {
    "id": "fgdKOKhip6zV"
   },
   "source": [
    "En este ejemplo, `ptr` no puede ser reasignado a otra variable ni puede modificar el valor de `i`.\n",
    "\n",
    "#### 5. **Ventajas del Calificador `const`**\n",
    "- **Legibilidad:** Indica claramente que el valor de una variable no debe cambiar, lo que facilita la comprensión y mantenimiento del código.\n",
    "- **Seguridad de Tipo:** Evita que los valores se modifiquen accidentalmente, reduciendo el riesgo de errores.\n",
    "- **Optimización:** Los compiladores pueden optimizar mejor las variables `const` al saber que su valor no cambia durante la ejecución del programa.\n",
    "- **Uso Eficiente de la Memoria:** Al evitar copias innecesarias de valores, se mejora el uso de la memoria y el rendimiento.\n",
    "- **Compatibilidad:** Facilita la integración con bibliotecas y APIs que utilizan variables `const`.\n",
    "- **Confiabilidad:** Asegura que los valores no se modifiquen de manera inesperada, mejorando la confiabilidad del código.\n",
    "\n",
    "#### 6. **Resumen de Tipos y Comportamiento**\n",
    "\n",
    "| Tipo                          | Declaración            | Cambio del Valor Apuntado (*ptr = 100) | Cambio de Dirección (ptr = &a) |\n",
    "|-------------------------------|------------------------|---------------------------------------|--------------------------------|\n",
    "| Puntero a Variable            | `int* ptr`             | Sí                                    | Sí                             |\n",
    "| Puntero a Constante           | `const int* ptr`       | No                                    | Sí                             |\n",
    "| Puntero Constante a Variable  | `int* const ptr`       | Sí                                    | No                             |\n",
    "| Puntero Constante a Constante | `const int* const ptr` | No                                    | No                             |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce2e4161",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}