HPC05_C_Intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "85e612fc-0d1e-4b56-8eff-80860d43ed70",
   "metadata": {
    "id": "85e612fc-0d1e-4b56-8eff-80860d43ed70"
   },
   "source": [
    "<h1 align=\"center\">Computación de Alto Desempeño</h1>\n",
    "<h1 align=\"center\">Introducción al lenguaje C</h1>\n",
    "<h1 align=\"center\">2024</h1>\n",
    "<h1 align=\"center\">MEDELLÍN - COLOMBIA </h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d79d6ad7-4374-43ac-bc30-750980733c8d",
   "metadata": {
    "id": "d79d6ad7-4374-43ac-bc30-750980733c8d"
   },
   "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/HPC05_C_Intro.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": "0642f5a8-e4d9-4cd4-a9b4-6195c5c235ea",
   "metadata": {
    "id": "0642f5a8-e4d9-4cd4-a9b4-6195c5c235ea"
   },
   "source": [
    "## Introducción"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79712233-8209-4f79-a495-af5622b97df3",
   "metadata": {
    "id": "79712233-8209-4f79-a495-af5622b97df3"
   },
   "source": [
    "### ¿Por Qué Aprender C?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff41ebe1-f80c-44ca-8d44-41d6c6e69684",
   "metadata": {
    "id": "ff41ebe1-f80c-44ca-8d44-41d6c6e69684"
   },
   "source": [
    "El lenguaje de programación C es uno de los más populares y fundamentales en el mundo de la informática. Es indispensable para los estudiantes de ingeniería de software. C es conocido como la \"madre de todos los lenguajes de programación modernos\", por lo que aprender C te facilitará el aprendizaje de otros lenguajes como Java, C++, C#, Python, entre otros. El lenguaje C es más rápido que otros lenguajes de programación como Java y Python. Además, permite manejar la programación a nivel bajo y se puede compilar en una amplia variedad de plataformas.\n",
    "\n",
    "**Algunas de las principales ventajas del lenguaje C:**\n",
    "\n",
    "- **Fácil de aprender:** Su sintaxis es sencilla y directa, lo que facilita su comprensión.\n",
    "- **Lenguaje versátil:** Puede ser utilizado tanto en el desarrollo de aplicaciones como en tecnologías específicas.\n",
    "- **Lenguaje de programación de nivel medio:** Combina características de lenguajes de bajo y alto nivel, ofreciendo un control detallado del hardware y una estructura lógica.\n",
    "- **Lenguaje de programación estructurado:** Promueve una programación ordenada y modular, facilitando la comprensión y mantenimiento del código.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f99207e-a2ed-4f56-9a6d-bbf7e3f7abb7",
   "metadata": {
    "id": "5f99207e-a2ed-4f56-9a6d-bbf7e3f7abb7"
   },
   "source": [
    "### Compilador de C"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e2bdef6-1702-4a07-917a-4f2c1f87ef68",
   "metadata": {
    "id": "6e2bdef6-1702-4a07-917a-4f2c1f87ef68"
   },
   "source": [
    "Un compilador de C es un software que traduce el código escrito en C, legible por humanos, en código máquina o en un código intermedio que puede ser ejecutado por la unidad central de procesamiento (CPU) de una computadora.\n",
    "\n",
    "Existen muchos compiladores de C disponibles en el mercado, entre ellos:\n",
    "\n",
    "- **GNU Compiler Collection ([GCC](https://gcc.gnu.org/))**\n",
    "- **[Microsoft Visual C++ Compiler](https://visualstudio.microsoft.com/vs/features/cplusplus/)**\n",
    "- **[Clang](https://clang.llvm.org/)**\n",
    "- **[Intel C++ Compiler](https://www.intel.com/content/www/us/en/developer/tools/oneapi/dpc-compiler.html)**\n",
    "- **TinyCC ([TCC](https://bellard.org/tcc/))**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1325942-22ba-4e0a-bc81-73f2aff27128",
   "metadata": {
    "id": "d1325942-22ba-4e0a-bc81-73f2aff27128"
   },
   "source": [
    "### ¿GCC o G++?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56f74df1-291e-49e8-ba8c-ab4d8d75b912",
   "metadata": {
    "id": "56f74df1-291e-49e8-ba8c-ab4d8d75b912"
   },
   "source": [
    "La diferencia principal entre **GCC** (GNU Compiler Collection) y **G++** radica en los lenguajes que compilan y en el manejo de ciertos aspectos del código que están relacionados con estos lenguajes:  \n",
    "\n",
    "**GCC (GNU Compiler Collection):**\n",
    "- **Lenguajes:** GCC es una colección de compiladores para varios lenguajes de programación, incluyendo C, C++, Objective-C, Fortran, Ada, Go, y otros. Sin embargo, cuando hablamos de GCC en el contexto de C y C++, generalmente nos referimos al compilador de C.\n",
    "- **Compilación de C:** Cuando usas GCC para compilar un archivo `.c`, este compila el código como un programa de C estándar, sin soporte adicional para las características específicas de C++, como la programación orientada a objetos o las sobrecargas de funciones.\n",
    "- **Archivo Fuente:** Los archivos de C generalmente tienen la extensión `.c`.\n",
    "\n",
    "**G++:**\n",
    "- **Lenguajes:** G++ es la parte de GCC que específicamente compila programas en C++. Es un \"driver\" de GCC que configura el compilador para tratar el código como C++.\n",
    "- **Compilación de C++:** G++ compila el código como un programa de C++, lo que significa que admite características avanzadas de C++, como la programación orientada a objetos, plantillas (templates), sobrecarga de funciones y operadores, excepciones, entre otros.\n",
    "- **Archivo Fuente:** Los archivos de C++ generalmente tienen la extensión `.cpp`, `.cc`, `.cxx`, o `.C`.\n",
    "- **Biblioteca Estándar de C++:** Al usar G++, automáticamente se enlaza la biblioteca estándar de C++ (libstdc++) en la etapa de enlace, lo que no ocurre si solo usas GCC para compilar un archivo de C++.\n",
    "\n",
    "### Resumen:\n",
    "- **GCC** se usa principalmente para compilar programas en C y otros lenguajes, y no enlaza automáticamente con la biblioteca estándar de C++.\n",
    "- **G++** es específicamente para compilar programas en C++ y sí enlaza automáticamente con la biblioteca estándar de C++.\n",
    "\n",
    "En resumen, si estás trabajando con código C, debes usar **GCC**. Si estás trabajando con código C++, debes usar **G++** para asegurarte de que el compilador maneje adecuadamente todas las características del lenguaje C++."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "202ed9c1-10d1-49ef-8d83-29bb94d07777",
   "metadata": {
    "id": "202ed9c1-10d1-49ef-8d83-29bb94d07777"
   },
   "source": [
    "### Características del Lenguaje C"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcf613c0-837b-4a7e-be78-ad331c630582",
   "metadata": {
    "id": "bcf613c0-837b-4a7e-be78-ad331c630582"
   },
   "source": [
    "El lenguaje C tiene varias características clave que demuestran su capacidad y poder:\n",
    "\n",
    "- **Simplicidad y Eficiencia:** La sintaxis simple y el enfoque estructurado hacen que el lenguaje C sea fácil de aprender.\n",
    "\n",
    "- **Velocidad:** C es uno de los lenguajes de programación más rápidos porque es un lenguaje estático, lo que lo hace más rápido que los lenguajes dinámicos como Java y Python. Además, C se basa en un compilador, lo que permite una compilación y ejecución de código más rápidas.\n",
    "\n",
    "- **Portabilidad:** C ofrece la capacidad de escribir código una vez y ejecutarlo en cualquier computadora, mostrando así la naturaleza independiente de la máquina del lenguaje C.\n",
    "\n",
    "- **Gestión de Memoria:** C proporciona herramientas de gestión de memoria de bajo nivel utilizando punteros y funciones como `realloc()`, `free()`, entre otras.\n",
    "\n",
    "- **Punteros:** C incluye el concepto de punteros, lo que permite acceder directamente a la memoria y manipularla. Los punteros pueden inicializarse como arreglos, variables, etc.\n",
    "\n",
    "- **Lenguaje Estructurado:** C permite la programación estructurada, permitiendo dividir el código en diferentes partes mediante funciones, que pueden almacenarse como bibliotecas reutilizables.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcf74b0a-3419-43d0-ad24-bd9263c1a260",
   "metadata": {
    "id": "fcf74b0a-3419-43d0-ad24-bd9263c1a260"
   },
   "source": [
    "### **Aplicaciones del Lenguaje C**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69bd67ed-5166-43bb-97a4-ee2be6e09b20",
   "metadata": {
    "id": "69bd67ed-5166-43bb-97a4-ee2be6e09b20"
   },
   "source": [
    "C ha sido utilizado en programas para la creación de sistemas operativos. Se conocía como un lenguaje de desarrollo de sistemas porque el código escrito en C se ejecuta tan rápido como el código escrito en lenguaje ensamblador.\n",
    "\n",
    "El uso de C incluye:\n",
    "\n",
    "- Sistemas Operativos\n",
    "- Compiladores de Lenguajes\n",
    "- Ensambladores\n",
    "- Editores de Texto\n",
    "- Spoolers de Impresión\n",
    "- Controladores de Red\n",
    "- Programas Modernos\n",
    "- Bases de Datos\n",
    "- Intérpretes de Lenguajes\n",
    "- Utilidades\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08112363-6c94-4f5d-bfe3-b0d2b4364319",
   "metadata": {
    "id": "08112363-6c94-4f5d-bfe3-b0d2b4364319"
   },
   "source": [
    "### **Diferencia entre C y C++**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9224fbe-cba5-4279-94f1-ee6c02ff2ae7",
   "metadata": {
    "id": "b9224fbe-cba5-4279-94f1-ee6c02ff2ae7"
   },
   "source": [
    "  | C | C++ |\n",
    "  |---|-----|\n",
    "  | C es un lenguaje de programación procedural. | C++ es un lenguaje de programación tanto procedural como orientado a objetos. |\n",
    "  | No soporta sobrecarga de funciones. | Soporta sobrecarga de funciones. |\n",
    "  | No soporta sobrecarga de operadores. | Soporta sobrecarga de operadores. |\n",
    "  | C no soporta ocultación de datos, lo que puede generar problemas de seguridad. | En C++, la encapsulación de datos permite la ocultación de datos, mejorando la seguridad. |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71b24250-2ed1-40c5-ae4d-8961a16a9e74",
   "metadata": {
    "id": "71b24250-2ed1-40c5-ae4d-8961a16a9e74"
   },
   "source": [
    "### **Estructura de un Programa en C**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c953bfc5",
   "metadata": {},
   "source": [
    "Por \"estructura\", se entiende que cualquier programa debe seguir esta organización específica. Escribir un programa en C de otra manera conducirá a un error de compilación. La estructura de un programa en C es la siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "249bb12b",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "int main(void){\n",
    "    printf(\"Hello world\");\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c32aadf5",
   "metadata": {},
   "source": [
    "### **Componentes de un Programa en C:**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e68e58d8-f446-4ed6-b4b3-7123633648b2",
   "metadata": {
    "id": "e68e58d8-f446-4ed6-b4b3-7123633648b2"
   },
   "source": [
    "- **Inclusión de Archivos de Cabecera – Línea 1 `#include <stdio.h>`**\n",
    "   El primer y más importante componente es la inclusión de los archivos de cabecera en un programa en C. Un archivo de cabecera es un archivo con extensión `.h` que contiene declaraciones de funciones en C y definiciones de macros para ser compartidas entre varios archivos fuente. Todas las líneas que comienzan con `#` son procesadas por un preprocesador, un programa que es invocado por el compilador. En el ejemplo anterior, el preprocesador copia el código preprocesado de `stdio.h` a nuestro archivo. Los archivos `.h` se denominan archivos de cabecera en C.\n",
    "\n",
    "   **Algunos de los archivos de cabecera en C:**\n",
    "   - `stddef.h`: Define varios tipos y macros útiles.\n",
    "   - `stdint.h`: Define tipos de enteros con un ancho exacto.\n",
    "   - `stdio.h`: Define funciones básicas de entrada y salida.\n",
    "   - `stdlib.h`: Define funciones de conversión numérica, generador de números pseudoaleatorios y asignación de memoria.\n",
    "   - `string.h`: Define funciones de manipulación de cadenas.\n",
    "   - `math.h`: Define funciones matemáticas comunes.\n",
    "\n",
    "- **Declaración del Método Principal – Línea 2 `int main()`**\n",
    "   La siguiente parte de un programa en C es la declaración de la función `main()`. Es el punto de entrada de un programa en C y la ejecución generalmente comienza con la primera línea de `main()`. Los paréntesis vacíos indican que `main` no recibe ningún parámetro. El `int` que precede a `main` indica el tipo de valor que retorna `main()`. El valor devuelto por `main` indica el estado de terminación del programa.\n",
    "\n",
    "- **Cuerpo del Método Principal – Línea 3 a Línea 6 `delimitado por {}`**\n",
    "   El cuerpo de una función en un programa en C se refiere a las instrucciones que forman parte de esa función. Puede incluir manipulaciones, búsquedas, ordenamientos, impresión, etc. Un par de llaves `{}` define el cuerpo de una función. Todas las funciones deben comenzar y terminar con llaves.\n",
    "\n",
    "- **Instrucción – Línea 4 `printf(\"Hola, Mundo\");`**\n",
    "   Las instrucciones son las órdenes dadas al compilador. En C, una instrucción siempre termina con un punto y coma `;`. En este caso particular, usamos la función `printf()` para indicar al compilador que muestre el texto \"Hola, Mundo\" en la pantalla.\n",
    "\n",
    "- **Instrucción de Retorno – Línea 5 `return 0;`**\n",
    "   La última parte de cualquier función en C es la instrucción de retorno. Esta instrucción se refiere a los valores que devuelve una función. La instrucción de retorno y el valor de retorno dependen del tipo de retorno de la función. En nuestro programa, la instrucción de retorno devuelve el valor desde `main()`. Este valor puede ser utilizado por el sistema operativo para conocer el estado de terminación de tu programa. El valor `0` generalmente significa que la terminación fue exitosa.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "537e2674-8a57-47ae-8f11-8641bc9b19e5",
   "metadata": {
    "id": "537e2674-8a57-47ae-8f11-8641bc9b19e5"
   },
   "source": [
    "### Proceso de Compilación y Ejecución de un Código en C con gcc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d95c8a1",
   "metadata": {},
   "source": [
    "Para comprender cómo un programa en C pasa de ser código fuente a un programa ejecutable, es importante conocer los pasos involucrados en el proceso de compilación y ejecución. Tomemos como ejemplo un archivo de código fuente llamado `my_code.c`. A continuación, se explica el proceso utilizando el compilador GNU `gcc`\n",
    "\n",
    "**1. Escribir el Código Fuente** El primer paso es escribir el código fuente en un archivo con la extensión `.c`. Este archivo contiene las instrucciones escritas en el lenguaje de programación C. Un ejemplo simple de código fuente podría ser:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16f331ac",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "#include <stdio.h>\n",
    "\n",
    "int main() {\n",
    "    printf(\"Hola, Mundo\\n\");\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2901ad19-0dd5-4ab5-9b6c-b2a8b0b831d7",
   "metadata": {
    "id": "2901ad19-0dd5-4ab5-9b6c-b2a8b0b831d7"
   },
   "source": [
    "Este código simplemente imprime \"Hola, Mundo\" en la consola.\n",
    "\n",
    "**2. Preprocesamiento**\n",
    "\n",
    "Antes de que el código C sea compilado, pasa por una fase de **preprocesamiento**. Durante esta fase, el preprocesador expande las macros y sustituye las directivas de preprocesador como `#include`, `#define`, etc. Por ejemplo, cuando el preprocesador encuentra `#include <stdio.h>`, reemplaza esta línea con el contenido del archivo `stdio.h`, que incluye las declaraciones necesarias para las funciones de entrada y salida.\n",
    "\n",
    "Para ejecutar solo la fase de preprocesamiento y ver el resultado, puedes usar el comando:\n",
    "\n",
    "```bash\n",
    "gcc -E my_code.c -o my_code.i\n",
    "```\n",
    "\n",
    "El archivo `my_code.i` contendrá el código fuente de preprocesamiento.\n",
    "\n",
    "**3. Compilación**\n",
    "\n",
    "Una vez que el código ha sido preprocesado, el siguiente paso es la **compilación**. En esta fase, el compilador convierte el código fuente en C en un código objeto, que es un código en lenguaje máquina específico para la arquitectura del sistema, pero aún no es un programa ejecutable completo.\n",
    "\n",
    "El comando para compilar el código fuente en un archivo objeto es:\n",
    "\n",
    "```bash\n",
    "gcc -c my_code.c -o my_code.o\n",
    "```\n",
    "\n",
    "El archivo `my_code.o` es el resultado de la compilación y contiene el código objeto.\n",
    "\n",
    "**4. Enlazado**\n",
    "\n",
    "Después de la compilación, el archivo objeto debe ser **enlazado** con otros archivos objeto y bibliotecas necesarias para formar un programa ejecutable. Durante el proceso de enlazado, todas las referencias a funciones y variables se resuelven, y el enlazador genera un archivo ejecutable que puede ser ejecutado directamente por el sistema operativo.\n",
    "\n",
    "Para enlazar el archivo objeto y generar el ejecutable, se utiliza el siguiente comando:\n",
    "\n",
    "```bash\n",
    "gcc my_code.o -o my_code\n",
    "```\n",
    "\n",
    "aquí, `my_code` es el archivo ejecutable generado.\n",
    "\n",
    "**5. Ejecución**\n",
    "\n",
    "Finalmente, una vez que se ha generado el archivo ejecutable, se puede ejecutar el programa desde la línea de comandos:\n",
    "```bash\n",
    "./my_cod\n",
    "```\n",
    "\n",
    "Este comando ejecutará el programa y, en este caso, mostrará \"Hola, Mundo\" en la consola.\n",
    "\n",
    "**Resumen del Proceso**\n",
    "\n",
    "1. **Escribir el Código Fuente:** Creas un archivo `.c` con el código en C.\n",
    "2. **Preprocesamiento:** El preprocesador expande macros y directivas de preprocesador.\n",
    "3. **Compilación:** El compilador convierte el código fuente en un archivo objeto (`.o`).\n",
    "4. **Enlazado:** El enlazador une los archivos objeto y bibliotecas para crear un ejecutable.\n",
    "5. **Ejecución:** El ejecutable se ejecuta en el sistema operativo.\n",
    "\n",
    "Este proceso es fundamental para convertir un programa escrito en un lenguaje de alto nivel, como C, en un programa que puede ser ejecutado por la computadora. como C, en un programa que puede ser ejecutado por la computadora."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c96da63-68b2-4ffd-8676-32a542353642",
   "metadata": {
    "id": "0c96da63-68b2-4ffd-8676-32a542353642"
   },
   "source": [
    "### Compilación con g++"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85f03a74",
   "metadata": {},
   "source": [
    "El comando `g++` es la invocación del compilador GNU C++ que se utiliza para el preprocesamiento, compilación, ensamblado y enlazado del código fuente para generar un archivo ejecutable. Las diferentes \"opciones\" del comando `g++` nos permiten detener este proceso en etapas intermedias.\n",
    "\n",
    "**Verificar la versión del compilador g++:**\n",
    "\n",
    "Para comprobar la versión del compilador `g++`, puedes usar el siguiente comando:\n",
    "\n",
    "```bash\n",
    "g++ --version\n",
    "```\n",
    "\n",
    "**Compilar un archivo CPP para generar un archivo ejecutable:**\n",
    "\n",
    "El comando `g++ file_name` se utiliza para compilar y crear un archivo ejecutable llamado `a.out` (nombre de destino predeterminado).\n",
    "\n",
    "**Ejemplo:** Dado un programa simple \"Hola Mundo!\" en la salida estándar, con el nombre de archivo `hello.cpp`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0c51284",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "// archivo hello.cpp\n",
    "#include <iostream>\n",
    "int main()\n",
    "{\n",
    "   std::cout << \"Hola Mundo!\\n\";\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f66a675d",
   "metadata": {},
   "source": [
    "Para compilar el programa, usa el comando:\n",
    "\n",
    "```bash\n",
    "g++ hello.cpp\n",
    "```\n",
    "\n",
    "Esto compila y enlaza `hello.cpp` para producir un archivo ejecutable predeterminado llamado `a.out` en el directorio de trabajo actual. Para ejecutar este programa, escribe `./a.out`, donde `./` representa el directorio de trabajo actual y `a.out` es el archivo ejecutable.\n",
    "\n",
    "```bash\n",
    "./a.out\n",
    "```\n",
    "\n",
    "**Otras opciones de compilación:**\n",
    "\n",
    "- **Compilar sin ensamblar ni enlazar:**\n",
    "  \n",
    "  El comando `g++ -S file_name` solo compila el archivo sin ensamblar ni enlazar. Esto generará un archivo de código ensamblador con la extensión `.s`.\n",
    "\n",
    "  **Ejemplo:**\n",
    "  ```bash\n",
    "  g++ -S hello.cpp\n",
    "  ```\n",
    "\n",
    "- **Compilar y ensamblar sin enlazar:**\n",
    "  \n",
    "  El comando `g++ -c file_name` compila y ensambla el archivo, pero no enlaza el código objeto para producir un archivo ejecutable. Genera un archivo de código objeto con la extensión `.o`.\n",
    "\n",
    "  **Ejemplo:**\n",
    "  ```bash\n",
    "  g++ -c hello.cpp\n",
    "  ```\n",
    "\n",
    "- **Compilar y enlazar con un nombre de destino personalizado:**\n",
    "  \n",
    "  El comando `g++ -o target_name file_name` compila y enlaza el archivo fuente, generando un archivo ejecutable con el nombre de destino especificado.\n",
    "\n",
    "  **Ejemplo:**\n",
    "  ```bash\n",
    "  g++ -o main.exe hello.cpp\n",
    "  ```\n",
    "\n",
    "**Compilación y enlace de múltiples archivos:**\n",
    "\n",
    "Cuando se usa la opción `-c`, se invoca la etapa de compilación que traduce el código fuente a código objeto. Cuando se usa la opción `-o`, se enlaza el código objeto para crear el archivo ejecutable. Se puen pasar varios archivos juntos como argumentos.\n",
    "\n",
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5961c218",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "// archivo hello.cpp\n",
    "#include <\"helloWorld.h\">\n",
    "#include <iostream>\n",
    "int main()\n",
    "{\n",
    "    std::cout << \"Hello World\\n\";\n",
    "    helloWorld();\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "add2d969",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "// archivo helloWorld.cpp\n",
    "#include <iostream>\n",
    "void helloWorld()\n",
    "{\n",
    "    std::cout << \"Hello World\\n\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63aa7a17",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "// archivo helloWorld.h\n",
    "void helloWorld();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67775c24",
   "metadata": {},
   "source": [
    "Primero, compila y crea el objeto para los archivos `helloWorld.cpp` y `hello.cpp`:\n",
    "\n",
    "```bash\n",
    "g++ -c helloWorld.cpp hello.cpp\n",
    "```\n",
    "\n",
    "Esto generará los archivos objeto `helloWorld.o` y `hello.o`.\n",
    "\n",
    "Luego, en los códigos objeto para crear un archivo ejecutable `main.exe`:\n",
    "\n",
    "```bash\n",
    "g++ -o main.exe helloWorld.o hello.o\n",
    "```\n",
    "\n",
    "Finalmente, ejecuta el archivo ejecutable:\n",
    "\n",
    "```bash\n",
    "./main.exe\n",
    "```\n",
    "\n",
    "**Mostrar todos los mensajes de advertencia:**\n",
    "\n",
    "El comando `g++ -Wall file_name` muestra todos los mensajes de advertencia que se generan durante la compilación del archivo `file_name`.\n",
    "\n",
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10729bae",
   "metadata": {
    "vscode": {
     "languageId": "c"
    }
   },
   "outputs": [],
   "source": [
    "// archivo hello.cpp\n",
    "#include <iostream>\n",
    "int main()\n",
    "{\n",
    "    int i;\n",
    "    std::cout << \"Hello World\\n\";\n",
    "    return 0;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c154a962-da53-4700-8a85-ec4deb8828fa",
   "metadata": {
    "id": "c154a962-da53-4700-8a85-ec4deb8828fa"
   },
   "source": [
    "Compila el archivo y muestra las advertencias (si las hay):\n",
    "\n",
    "```bash\n",
    "g++ -Wall hello.cpp\n",
    "```\n",
    "\n",
    "**Extensiones de archivo para C++**\n",
    "\n",
    "Las extensiones de archivo para los archivos en C++ pueden ser `.cpp` o `.c++`. Aunque `.cpp` es la más utilizada."
   ]
  }
 ],
 "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
}