Saltar al contenido principal
LibreTexts Español

5.1: Tipos

  • Page ID
    82252
  • \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \) \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)\(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\) \(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\)\(\newcommand{\AA}{\unicode[.8,0]{x212B}}\)

    C tiene varias formas de almacenar o hacer referencia a variables. Estos afectan el comportamiento de las variables. Algunos de los más comunes son: auto, registro y estático.

    Las variables auto son variables declaradas dentro de funciones que no son estáticas o tipos de registro. Es decir, la palabra clave auto es la predeterminada. Normalmente, las variables auto se crean en la pila de la aplicación, aunque C no lo requiere. La pila es básicamente un pedazo de memoria que se asigna para el uso de la aplicación cuando se ejecuta por primera vez. Es un lugar para almacenamiento temporal, con valores que se colocan y se extraen de la pila en orden de entrada y último salida (como una pila de placas). A menos que inicialice una variable automática, no tiene idea de cuál es su valor cuando la usa por primera vez. Su valor pasa a ser lo que estaba en esa ubicación de memoria la vez anterior que se utilizó. Es importante entender que esto incluye llamadas posteriores a una función (es decir, su valor anterior no es “recordado” la próxima vez que llame a la función). Esto se debe a que cualquier llamada posterior a una función no tiene que producir las mismas ubicaciones de memoria para estas variables, ya que siempre terminas con el mismo plato cada vez que vas a la cafetería.

    Las variables de registro son similares a los tipos de auto en comportamiento, pero en lugar de usar el método de pila habitual, se usa un registro de CPU (si está disponible). La implementación exacta es específica de CPU y compilador. En algunos casos se ignora la palabra clave register y se usa un tipo automático simple. Los registros de CPU ofrecen un acceso más rápido que la memoria normal, por lo que las variables de registro se utilizan para crear una ejecución más rápida de Normalmente esto incluye contadores o punteros que se incrementan dentro de los bucles. Una declaración quisiera algo como esto:

    register int x;
    

    Las variables estáticas se utilizan cuando se necesita una variable que mantenga su valor entre llamadas a funciones. Entonces, si necesitamos una variable que “aparecerá como la dejamos” desde la última llamada, podríamos usar algo como esto:

    static char y;
    

    Hay una diferencia importante entre los tipos auto y estáticos con respecto a la inicialización. Si una variable auto se inicializa en una función así:

    char a=1;
    

    Entonces a se establece en 1 cada vez que se ingresa la función. Si haces la misma inicialización con una estática, como en:

    static char b=1;
    

    Entonces b se establece en 1 solo en la primera llamada. Las entradas posteriores en la función no incurrirían en la inicialización. Si se reinicializara, ¿cuál sería el sentido de tener un tipo estático? Esto se explica por el hecho de que una estática no suele utilizar el método de almacenamiento de pila, sino que se coloca en una ubicación de memoria fija. Nuevamente, C no requiere el uso de una pila, más bien, es una implementación típica.

    Dos modificadores útiles pero no muy comunes son volátiles y const. Una variable volátil es aquella a la que se puede acceder o modificar mediante otro proceso o tarea. Esto tiene algunos usos muy especiales (típicamente, para evitar que un compilador de optimización sea demasiado agresivo con optimizaciones, más sobre esto más adelante). El modificador const se utiliza para declarar constantes, es decir, variables que no deben cambiar de valor. En algunos casos esto se prefiere sobre usar #define ya que la comprobación de tipos ya está disponible (pero no puede usar las dos indistintamente).


    This page titled 5.1: Tipos is shared under a CC BY-NC-SA 4.0 license and was authored, remixed, and/or curated by James M. Fiore via source content that was edited to the style and standards of the LibreTexts platform; a detailed edit history is available upon request.