Projet C évitant les conflits de nommage

J'ai du mal à trouver des conseils pragmatiques du monde réel sur les conventions de dénomination des fonctions pour un projet de bibliothèque C de taille moyenne. Mon projet de bibliothèque est séparé en quelques modules et sous-modules avec leurs propres en-têtes, et suit vaguement un style OO (toutes les fonctions prennent une certaine structure comme premier argument, pas de globaux, etc.). Il a posé notre quelque chose comme:

MyLib
  - Foo
    - foo.h
    - foo_internal.h
    - some_foo_action.c
    - another_foo_action.c
    - Baz
      - baz.h
      - some_baz_action.c
  - Bar
    - bar.h
    - bar_internal.h
    - some_bar_action.c

Généralement, les fonctions sont beaucoup trop volumineuses pour (par exemple) rester some_foo_actionet another_foo_actiondans un foo.cfichier d'implémentation, rendre la plupart des fonctions statiques et l'appeler un jour.

Je peux gérer le retrait de mes symboles internes ("module privé") lors de la construction de la bibliothèque pour éviter les conflits pour mes utilisateurs avec leurs programmes clients, mais la question est de savoir comment nommer les symboles dans ma bibliothèque? Jusqu'à présent, je fais:

struct MyLibFoo;
void MyLibFooSomeAction(MyLibFoo *foo, ...);

struct MyLibBar;
void MyLibBarAnAction(MyLibBar *bar, ...);

// Submodule
struct MyLibFooBaz;
void MyLibFooBazAnotherAction(MyLibFooBaz *baz, ...);

Mais je me retrouve avec des noms de symboles longs et fous (beaucoup plus longs que les exemples). Si je ne préfixe pas les noms avec un "faux espace de noms", les symboles internes des modules sont tous en conflit.

Remarque: je ne me soucie pas du cas camelcase / Pascal, etc., juste des noms eux-mêmes.

Le préfixe (enfin l'apposition) est vraiment la seule option. Certains modèles que vous verrez sont <library>_<name>(par exemple, OpenGL, runtime ObjC), <module/class>_<name>(par exemple des parties de Linux), <library>_<module/class>_<name>(par exemple, GTK +). Votre plan est parfaitement raisonnable.

Les noms longs ne sont pas nécessairement mauvais s'ils sont prévisibles. Le fait que vous vous retrouvez avec des noms longs et des fonctions folles qui sont trop gros pour rester avec des fonctions connexes dans un seul fichier source soulève des préoccupations différentes. Avez-vous des exemples plus concrets?

La convention habituelle pour les bibliothèques C est d'utiliser le nom de la bibliothèque comme préfixe pour les noms utilisables en externe, par exemple

struct MyLibFoo;
void MyLibAFooAction(...);

Pour les noms internes à la bibliothèque qui doivent toujours être accessibles dans plusieurs unités de la bibliothèque, il n'y a pas de convention stricte, mais j'utiliserais un préfixe du nom de la bibliothèque et une indication qu'il s'agit d'une fonction interne. Par exemple:

struct MyLibInternalFooBaz;
void MyLibInternalFooBazAction();

Je suis d'accord que cela peut conduire à des noms assez longs et difficiles à taper, mais malheureusement c'est le prix à payer pour ne pas avoir de mécanisme comme les espaces de noms C ++. Pour réduire la longueur des noms, au prix d'une certaine clarté, vous pouvez choisir d'utiliser des abréviations dans vos noms, mais vous devez peser soigneusement les avantages et les inconvénients.

Si vous voulez éviter les longs préfixes, vous pouvez abréger les noms de bibliothèques comme ce que fait Apple dans iOS et OS X:

• NSString est une chaîne issue des racines NextStep du système d'exploitation
• CALayer est une couche Core Animation

Qu'en est-il d'avoir une variable de structure globale préremplie de pointeurs de fonction?

lib.h

#pragma once

typedef struct
{
    void (*doFoo)(int x);
    const char *(*doBar)(void *p);
} YourApi;

extern const YourApi yourApi;

lib.c:

#include "lib.h"

#include <stdio.h>

static void doFoo(int x)
{
    printf("Doing foo %d\n", x);
}

static const char *doBar(void *p)
{
    printf("Doing bar: %p\n", p);
    return "Hello";
}

const YourApi yourApi = {
    doFoo,
    doBar};

Harnais:

#include "lib.h"

int main()
{
    yourApi.doFoo(42);
    yourApi.doBar("asd");
}

Le mot-clé statique limite la portée à l'unité de traduction afin qu'elle n'entre pas en collision avec d'autres.

L'utilisateur peut ensuite le raccourcir en utilisant un pointeur comme YourApi *ya = &yourApi, puis en utilisant ya->doFoo(...).

Il fournit également un bon moyen de simuler votre bibliothèque pour les tests.