idiomatisches C für konstante Doppelzeiger

Mir ist bewusst, dass Sie in C beispielsweise nicht implizit konvertieren können char** zu const char** (vgl C-FAQSO Frage 1, SO Frage 2).

Auf der anderen Seite, wenn ich eine Funktion sehe, die so deklariert ist:

void foo(char** ppData);

Ich muss davon ausgehen, dass die Funktion die übergebenen Daten ändern kann. Wenn ich also eine Funktion schreibe, wird dies der Fall sein nicht Ändern Sie die Daten, ist es meiner Meinung nach besser zu erklären:

void foo(const char** ppData);

oder auch:

void foo(const char * const * ppData);

Doch das bringt die Nutzer der Funktion in eine missliche Lage. Vielleicht haben Sie:

int main(int argc, char** argv)
{
    foo(argv); // Oh no, compiler error (or warning)
    ...
}

Und um meine Funktion sauber aufzurufen, müssten sie eine Umwandlung einfügen.

Ich habe hauptsächlich einen C++-Hintergrund, wo dies aufgrund der ausführlicheren const-Regeln von C++ weniger ein Problem darstellt.

Was ist die idiomatische Lösung in C?

1. Deklarieren Sie foo als a nehmend char**, und dokumentieren Sie einfach die Tatsache, dass es seine Eingaben nicht ändert? Das scheint ein bisschen eklig zu sein, insb. da es Benutzer bestraft, die eine haben könnten const char** dass sie es bestehen wollen (jetzt müssen sie werfen ein Weg Konstanz)

2. Zwingen Sie Benutzer, ihre Eingaben zu übertragen, und fügen Sie Konstanz hinzu.

3. Etwas anderes?

Obwohl Sie bereits eine Antwort akzeptiert haben, möchte ich 3) nämlich Makros wählen. Sie können diese so schreiben, dass der Benutzer Ihrer Funktion nur einen Aufruf schreibt foo(x); wo x sein kann const-qualifiziert oder nicht. Die Idee wäre, ein Makro zu haben CASTIT die die Umwandlung durchführt und prüft, ob das Argument einen gültigen Typ hat, und eine andere, die die Benutzeroberfläche ist:

void totoFunc(char const*const* x);    
#define CASTIT(T, X) (                 \
   (void)sizeof((T const*){ (X)[0] }), \
   (T const*const*)(X)                 \
)
#define toto(X) totoFunc(CASTIT(char, X))

int main(void) {
   char      *     * a0 = 0;
   char const*     * b0 = 0;
   char      *const* c0 = 0;
   char const*const* d0 = 0;
   int       *     * a1 = 0;
   int  const*     * b1 = 0;
   int       *const* c1 = 0;
   int  const*const* d1 = 0;

   toto(a0);
   toto(b0);
   toto(c0);
   toto(d0);
   toto(a1); // warning: initialization from incompatible pointer type
   toto(b1); // warning: initialization from incompatible pointer type
   toto(c1); // warning: initialization from incompatible pointer type
   toto(d1); // warning: initialization from incompatible pointer type
}

Das CASTIT Makro sieht ein bisschen kompliziert aus, aber alles, was es tut, ist zuerst zu prüfen, ob X[0] zuordnungskompatibel ist char const*. Dafür wird ein zusammengesetztes Literal verwendet. Diese ist dann in a versteckt sizeof um sicherzustellen, dass das zusammengesetzte Literal niemals erstellt wird und auch das X wird durch diesen Test nicht bewertet.

Dann folgt ein einfacher Wurf, der allein aber zu gefährlich wäre.

Wie Sie an den Beispielen in der sehen können main dies erkennt genau die fehlerhaften Fälle.

Vieles davon ist mit Makros möglich. Ich habe kürzlich ein kompliziertes Beispiel gekocht mit const-qualifizierte Arrays.

2 ist besser als 1. 1 ist jedoch ziemlich üblich, da große Mengen an C-Code const überhaupt nicht verwenden. Wenn Sie also neuen Code für ein neues System schreiben, verwenden Sie 2. Wenn Sie Wartungscode für ein vorhandenes System schreiben, bei dem const eine Seltenheit ist, verwenden Sie 1.

Gehen Sie mit Option 2. Option 1 hat den von Ihnen erwähnten Nachteil und ist weniger typsicher.

Wenn ich eine Funktion gesehen habe, die a braucht char ** Argument und ich habe ein char *const * oder ähnliches, ich würde eine Kopie machen und das weitergeben, nur für den Fall.

Moderne (C11+) Art der Verwendung _Generic um die Typsicherheit und Funktionszeiger beizubehalten:

// joins an array of words into a new string;
// mutates neither *words nor **words
char *join_words (const char *const words[])
{
// ...
}

#define join_words(words) join_words(_Generic((words),\
          char ** : (const char *const *)(words),\
    char *const * : (const char *const *)(words),\
          default : (words)\
))

// usage :
int main (void)
{
    const char *const words_1[] = {"foo", "bar", NULL};
    char *const words_2[] =       {"foo", "bar", NULL};
    const char *words_3[] =       {"foo", "bar", NULL};
    char *words_4[] =             {"foo", "bar", NULL};

// none of the calls generate warnings:
    join_words(words_1);
    join_words(words_2);
    join_words(words_3);
    join_words(words_4);

// type-checking is preserved:
    const int *const numbers[] = { (int[]){1, 2}, (int[]){3, 4}, NULL };
    join_words(numbers);
// warning: incompatible pointer types passing
// 'const int *const [2]' to parameter of type 'const char *const *'

// since the macro is defined after the function's declaration and has the same name,
// we can also get a pointer to the function
    char *(*funcptr) (const char *const *) = join_words;
}