Concepto de palabra clave estática desde la perspectiva de C incrustado

La palabra clave 'estático' en C tiene dos significados fundamentalmente diferentes.

alcance limitante

En este contexto, 'static' se empareja con 'extern' para controlar el alcance de una variable o nombre de función. Estático hace que el nombre de la variable o función esté disponible solo dentro de una sola unidad de compilación y solo disponible para el código que existe después de la declaración/definición dentro del texto de la unidad de compilación.

Esta limitación en sí misma solo significa algo si y solo si tiene más de una unidad de compilación en su proyecto. Si solo tiene una unidad de compilación, entonces todavía hace cosas, pero esos efectos son en su mayoría inútiles (a menos que le guste profundizar en los archivos de objetos para leer lo que generó el compilador).

Como se señaló, esta palabra clave en este contexto se empareja con la palabra clave 'extern', que hace lo contrario, al hacer que el nombre de la variable o función se pueda vincular con el mismo nombre que se encuentra en otras unidades de compilación. Por lo tanto, puede considerar que 'estático' requiere que la variable o el nombre se encuentre dentro de la unidad de compilación actual, mientras que 'externo' permite la vinculación de unidades de compilación cruzada.

Vida útil estática

El tiempo de vida estático significa que la variable existe a lo largo de la duración del programa (cualquiera que sea). Cuando usa 'estático' para declarar/definir una variable dentro de una función, significa que la variable se crea en algún momento antes de su primer uso ( lo que significa que, cada vez que lo experimenté, la variable se crea antes de que se inicie main() y no se destruye después. Ni siquiera cuando se completa la ejecución de la función y regresa a su llamador. Y al igual que las variables estáticas de por vida declaradas fuera de las funciones, se inicializan en el mismo momento, antes de que comience main(), a un cero semántico (si no se proporciona inicialización) o a un valor explícito especificado, si se proporciona.

Esto es diferente de las variables de función de tipo 'auto', que se crean nuevas (o, como si fueran nuevas) cada vez que se ingresa la función y luego se destruyen (o, como si fueran destruidas) cuando la función sale.

A diferencia del impacto de aplicar 'estática' en una definición de variable fuera de una función, que afecta directamente su alcance, declarar una variable de función (dentro del cuerpo de una función, obviamente) como 'estática' no tiene impacto en su alcance . El alcance está determinado por el hecho de que se definió dentro de un cuerpo de función. Las variables estáticas de por vida definidas dentro de las funciones tienen el mismo alcance que otras variables 'automáticas' definidas dentro de los cuerpos de las funciones: alcance de la función.

Resumen

Entonces, la palabra clave 'estática' tiene diferentes contextos con lo que equivale a "significados muy diferentes". La razón por la que se usó de dos maneras, como esta, fue para evitar usar otra palabra clave. (Hubo una larga discusión al respecto). Se consideró que los programadores podían tolerar el uso y el valor de evitar otra palabra clave en el lenguaje era más importante (que los argumentos de otra manera).

(Todas las variables declaradas fuera de las funciones tienen una duración estática y no necesitan la palabra clave 'estático' para que eso sea cierto. Así que esto liberó la palabra clave que se usará allí para significar algo completamente diferente: 'visible solo en una sola compilación unidad'. Es una especie de truco.)

Nota específica

carácter estático volátil sin firmar PORTB @ 0x06;

La palabra 'estático' aquí debe interpretarse en el sentido de que el enlazador no intentará hacer coincidir varias apariciones de PORTB que se pueden encontrar en más de una unidad de compilación (suponiendo que su código tenga más de una).

Utiliza una sintaxis especial (no portátil) para especificar la "ubicación" (o el valor numérico de la etiqueta, que suele ser una dirección) de PORTB. Entonces, el enlazador recibe la dirección y no necesita encontrar una para ella. Si tuviera dos unidades de compilación usando esta línea, cada una terminaría apuntando al mismo lugar de todos modos. Así que no hay necesidad de etiquetarlo como 'externo' aquí.

Si hubieran usado 'externo', podría plantear un problema. El enlazador entonces podría ver (e intentaría hacer coincidir) múltiples referencias a PORTB encontradas en múltiples compilaciones. Si todos ellos especifican una dirección como esta, y las direcciones NO son las mismas por alguna razón [¿error?], entonces, ¿qué se supone que debe hacer? ¿Quejarse? ¿O? (Técnicamente, con 'externo', la regla general sería que solo UNA unidad de compilación especificaría el valor y las otras no).

Simplemente es más fácil etiquetarlo como 'estático', evitando que el enlazador se preocupe por los conflictos, y simplemente culpe a quien haya cambiado la dirección a algo que no debería ser por cualquier error por direcciones no coincidentes.

De cualquier manera, la variable se trata como si tuviera una 'vida útil estática'. (Y 'volátil'.)

Una declaración no es una definición , pero todas las definiciones son declaraciones.

En C, una definición crea un objeto. También lo declara. Pero una declaración por lo general (vea la nota de viñeta a continuación) no crea un objeto.

Las siguientes son definiciones y declaraciones:

static int a;
static int a = 7;
extern int b = 5;
extern int f() { return 10; }

Las siguientes no son definiciones, sino solo declaraciones:

extern int b;
extern int f();

Tenga en cuenta que las declaraciones no crean un objeto real. Solo declaran los detalles al respecto, que el compilador puede usar para ayudar a generar el código correcto y proporcionar mensajes de advertencia y error, según corresponda.

• Arriba, digo "generalmente", deliberadamente. En algunos casos, una declaración puede crear un objeto y, por lo tanto, el enlazador (nunca el compilador) la promueve a una definición. Por lo tanto, incluso en este raro caso, el compilador de C aún piensa que la declaración es solo una declaración. Es la fase del enlazador la que realiza las promociones necesarias de alguna declaración. Tenga esto en cuenta cuidadosamente.

  En los ejemplos anteriores, si resulta que solo hay declaraciones para un "extern int b;" en todas las unidades de compilación enlazadas, el enlazador tiene la responsabilidad de crear una definición. Tenga en cuenta que este es un evento de tiempo de enlace. El compilador es completamente inconsciente durante la compilación. Sólo puede determinarse en el momento del enlace, si se puede promover una declaración de este tipo.

  El compilador es consciente de que "static int a;" el enlazador no puede promoverlo en tiempo de enlace, por lo que en realidad es una definición en tiempo de compilación .

staticLos correos electrónicos no son visibles fuera de la unidad de compilación actual o "unidad de traducción". Esto no es lo mismo que el mismo archivo .

Tenga en cuenta que incluye el archivo de encabezado en cualquier archivo de origen en el que pueda necesitar las variables declaradas en el encabezado. Esta inclusión hace que el archivo de encabezado sea parte de la unidad de traducción actual y (una instancia de) la variable visible en su interior.

Intentaré resumir los comentarios y la respuesta de @JimmyB con un ejemplo explicativo:

Supongamos que este conjunto de archivos:

prueba_estática.c:

#include <stdio.h>
#if USE_STATIC == 1
    #include "static.h"
#else
    #include "no_static.h"
#endif

void var_add_one();

void main(){

    say_hello();
    printf("var is %d\n", var);
    var_add_one();
    printf("now var is %d\n", var);
}

estática.h:

static int var=64;
static void say_hello(){
    printf("Hello!!!\n");
};

no_static.h:

int var=64;
void say_hello(){
    printf("Hello!!!\n");
};

static_src.c:

#include <stdio.h>

#if USE_STATIC == 1
    #include "static.h"
#else
    #include "no_static.h"
#endif

void var_add_one(){
    var = var + 1;
    printf("Added 1 to var: %d\n", var);
    say_hello();
}

Puede compilar y ejecutar el código usando gcc -o static_test static_src.c static_test.c -DUSE_STATIC=1; ./static_testel encabezado estático o gcc -o static_test static_src.c static_test.c -DUSE_STATIC=0; ./static_testel encabezado no estático.

Tenga en cuenta que aquí hay dos unidades de compilación: static_src y static_test. Cuando utilice la versión estática del encabezado ( ), estará disponible -DUSE_STATIC=1una versión de vary para cada unidad de compilación, es decir, ambas unidades pueden usarlas, pero verifique que aunque la función incrementa su variable, cuando la función principal imprime su variable , todavía es 64:say_hellovar_add_one() var var

$ gcc -o static_test static_src.c static_test.c -DUSE_STATIC=1; ./static_test                                                                                                                       14:33:12⌚
Hello!!!
var is 64
Added 1 to var: 65
Hello!!!
now var is 64

Ahora, si intenta compilar y ejecutar el código, utilizando una versión no estática ( -DUSE_STATIC=0), arrojará un error de enlace debido a la definición de variable duplicada:

$ gcc -o static_test static_src.c static_test.c -DUSE_STATIC=0; ./static_test                                                                                                                       14:35:30⌚
/tmp/ccLBy1s7.o:(.data+0x0): multiple definition of `var'
/tmp/ccV6izKJ.o:(.data+0x0): first defined here
/tmp/ccLBy1s7.o: In function `say_hello':
static_test.c:(.text+0x0): multiple definition of `say_hello'
/tmp/ccV6izKJ.o:static_src.c:(.text+0x0): first defined here
collect2: error: ld returned 1 exit status
zsh: no such file or directory: ./static_test

Espero que esto pueda ayudarte a aclarar este asunto.

#include pic.haproximadamente significa "copiar el contenido de pic.h en el archivo actual". Como resultado, cada archivo que incluye pic.hobtiene su propia definición local de PORTB.

Tal vez se pregunte por qué no existe una única definición global de PORTB. La razón es bastante simple: solo puede definir una variable global en un archivo C, por lo que si desea usarla PORTBen varios archivos en su proyecto, necesitará pic.huna declaración de PORTBy pic.csu definición . Permitir que cada archivo C defina su propia copia PORTBfacilita la creación de código, ya que no tiene que incluir en su proyecto archivos que no escribió.

Un beneficio adicional de las variables estáticas frente a las globales es que obtiene menos conflictos de nombres. El archivo AC que no usa ninguna característica de hardware de MCU (y por lo tanto no incluye pic.h) puede usar el nombre PORTBpara su propio propósito. No es que sea una buena idea hacerlo a propósito, pero cuando desarrolla, por ejemplo, una biblioteca matemática independiente de MCU, se sorprenderá de lo fácil que es reutilizar accidentalmente un nombre que usa una de las MCU.

Ya hay algunas buenas respuestas, pero creo que la causa de la confusión debe abordarse de manera simple y directa:

La declaración PORTB no es C estándar. Es una extensión del lenguaje de programación C que solo funciona con el compilador PIC. La extensión es necesaria porque los PIC no se diseñaron para admitir C.

El uso de la staticpalabra clave aquí es confuso porque nunca se usaría staticde esa manera en código normal. Para una variable global, usaría externen el encabezado, no static. Pero PORTB no es una variable normal . Es un truco que le dice al compilador que use instrucciones de ensamblaje especiales para registrar IO. Declarar PORTB staticayuda a engañar al compilador para que haga lo correcto.

Cuando se usa en el ámbito del archivo, staticlimita el ámbito de la variable o función a ese archivo. "Archivo" significa el archivo C y cualquier cosa copiada en él por el preprocesador. Cuando usa #include, está copiando código en su archivo C. Es por eso que usar staticun encabezado no tiene sentido: en lugar de una variable global, cada archivo que #incluye el encabezado obtendría una copia separada de la variable.

Contrariamente a la creencia popular, staticsiempre significa lo mismo: asignación estática con alcance limitado. Esto es lo que sucede con las variables antes y después de ser declaradas static:

+------------------------+-------------------+--------------------+
| Variable type/location |    Allocation     |       Scope        |
+------------------------+-------------------+--------------------+
| Normal in file         | static            | global             |
| Normal in function     | automatic (stack) | limited (function) |
| Static in file         | static            | limited (file)     |
| Static in function     | static            | limited (function) |
+------------------------+-------------------+--------------------+

Lo que lo hace confuso es que el comportamiento predeterminado de las variables depende de dónde estén definidas.

La razón por la que el archivo principal puede ver la definición de puerto "estático" es por la directiva #include. Esa directiva es equivalente a insertar el archivo de encabezado completo en su código fuente en la misma línea que la directiva misma.

El compilador microchip XC8 trata los archivos .c y .h exactamente de la misma manera, por lo que puede colocar sus definiciones de variables en cualquiera de ellos.

Normalmente, un archivo de encabezado contiene una referencia "externa" a las variables que se definen en otro lugar (generalmente un archivo .c).

Las variables de puerto debían especificarse en direcciones de memoria específicas que coincidieran con el hardware real. Entonces, una definición real (no externa) necesitaba existir en alguna parte.

Solo puedo adivinar por qué la corporación Microchip eligió poner las definiciones reales en el archivo .h. Una suposición probable es que solo querían un archivo (.h) en lugar de 2 (.h y .c) (para facilitar las cosas al usuario).

Pero si coloca las definiciones de variables reales en un archivo de encabezado y luego incluye ese encabezado en varios archivos de origen, el enlazador se quejará de que las variables se definen varias veces.

La solución es declarar las variables como estáticas, luego cada definición se trata como local para ese archivo de objeto y el enlazador no se quejará.