Existe-t-il un moyen, en C, de s'assurer qu'une fonction n'est appelée qu'une seule fois sans pthread_once?

Vous pouvez encapsuler votre fonction dans une autre fonction qui vérifie une variable statique et n'appelle func que si elle n'a pas été appelée auparavant en tant que -

static int func_internal() {
    ...
}

int func() {
    static int guard = 0;
    if (guard)
        return 0;
    guard = 1;
    return func();
}

Maintenant, exposer uniquement func aux autres modules.

Vous pouvez le faire avec un indicateur statique .

// main.c

int func()
{
  return 42;
}

int main( int argc, char* argv[] )
{
    static int initialized = 0;
    if(!initialized) {
        func();
        initialized = 1;
    }
}

La première fois que vous utilisez le code d'appel, l'indicateur initialisé est désactivé , donc la fonction sera exécutée. Pour tous les appels ultérieurs, l'indicateur est déjà défini et la fonction ne sera donc pas appelée.

Aucun moyen de tirer parti de l'initialisation des variables statiques

Votre tentative de tirer parti de l'initialisation des variables statiques ne fonctionnera pas. C autorise uniquement l'initialisation de la variable static avec des constantes, donc un appel de fonction est sorti.

Appel unique d'une fonction au démarrage du programme (ou chargement de la bibliothèque)

La raison pour laquelle vous voulez un appel unique n'est pas claire, mais si vous pouvez le faire au démarrage du programme, il existe une solution spécifique à GCC. Vous pouvez attribuer l'attribut constructor à la fonction.

void nothing_func(int *x);
void initial_func(int *x);
void (*func)(int *x) = initial_func;

void initial_func(int *x) {
    *x = 42;
    puts(__func__);
    func = nothing_func;
}

void nothing_func(int *x) {
    puts(__func__);
}

void foo(void) {
    static int x;
    func(&x);
    printf("%s: %d\n", __func__, x);
    ++x;
}

int main(void) {
    foo();
    foo();
}

Cette suggestion n'exécute pas votre demande spécifique:

Je suis intéressé par l'assurance à la compilation que func () n'est appelée qu'une seule fois à partir d'une portée de fonction appelante ...

Au lieu de cela, il garantit que la fonction est appelée exactement une fois lorsque le programme démarre (ou lorsque la bibliothèque dont elle fait partie est chargée).

Utilisez une variable statique comme garde

Si vous avez besoin de contrôler le moment où la fonction est appelée de la même manière que l'initialisation d'une variable statique locale à une fonction est initialisée, vous pouvez utiliser une variable statique pour savoir si votre fonction one shot a déjà été appelée avec sa propre variable statique. D'autres réponses ont déjà décrit comment y parvenir, mais par souci d'exhaustivité:

void caller_of_func()
{
    static bool func_already_called;
    if (!func_already_called) {
        func();
        func_already_called = true;
    }
    /*...*/
}

Utilisez un pointeur de fonction!

Une autre façon d'atteindre votre objectif serait de appeler la fonction via un pointeur de fonction. L'appel initial de la fonction ferait le vrai travail, puis basculerait le pointeur de la fonction pour qu'il pointe vers une fonction qui ne fait rien.

#include <stdio.h>

__attribute__((constructor)) 
void func()
{
  puts(__func__);
}

int main () {}