Kann GCC mich warnen, die Felder einer Const-Struktur in C99 zu modifizieren?

Question

Ich stolperte über ein kleines Problem, während ich versuchte, const-korrekten Code zu machen.

Ich hätte gerne eine Funktion geschrieben, die einen Zeiger auf eine const-Struktur nimmt, um dem Compiler zu sagen "Bitte sagen Sie mir, wenn ich die Struktur modifiziere, weil ich wirklich nicht will".

Es kam plötzlich zu meinem Kopf, dass die Compiler mir, dies tun können:

struct A 
{ 
    char *ptrChar; 
}; 

void f(const struct A *ptrA) 
{ 
    ptrA->ptrChar[0] = 'A'; // NOT DESIRED!! 
} 

was verständlich ist, da tatsächlich was konst der Zeiger selbst ist, aber nicht der Typ, es verweist. Ich möchte, dass der Compiler mir sagt, dass ich etwas mache, was ich nicht tun möchte, wenn das überhaupt möglich ist.

Ich habe gcc als meinen Compiler verwendet. Obwohl ich weiß, dass der obige Code legal sein sollte, überprüfte ich trotzdem, ob es trotzdem eine Warnung geben würde, aber nichts kam. Meine Befehlszeile war:

gcc -std=c99 -Wall -Wextra -pedantic test.c 

Ist es möglich, um dieses Problem zu umgehen? Kein

Answer 1

Eine Möglichkeit, dies zu umgehen, besteht darin, bei Bedarf zwei verschiedene Typen für dasselbe Objekt zu verwenden: einen Lese-/Schreib-Typ und einen schreibgeschützten Typ.

typedef struct 
{ 
    char *ptrChar; 
} A_rw; 

typedef struct 
{ 
    const char* ptrChar; 
} A_ro; 


typedef union 
{ 
    A_rw rw; 
    A_ro ro; 
} A; 

Wenn eine Funktion, das Objekt ändern muss, nimmt sie den Schreib-Lese-Typen als Parameter, sonst nimmt es den Nur-Lese-Typen.

void modify (A_rw* a) 
{ 
    a->ptrChar[0] = 'A'; 
} 

void print (const A_ro* a) 
{ 
    puts(a->ptrChar); 
} 

den Anrufer-Schnittstelle, um ziemlich hoch und es konsistent machen, können Sie Wrapper-Funktionen wie die öffentliche Schnittstelle zu Ihrem ADT verwenden können:

inline void A_modify (A* a) 
{ 
    modify(&a->rw); 
} 

inline void A_print (const A* a) 
{ 
    print(&a->ro); 
} 

Mit dieser Methode kann A nun als undurchsichtige Art umgesetzt werden , um die Implementierung für den Aufrufer zu verbergen.

Answer 2

, wenn Sie die Struktur Definition zu ändern:

struct A 
{ 
    const char *ptrChar; 
}; 

Eine weitere gewundene Lösung, die die alte Struktur Definition intakt hält, ist eine neue Struktur mit identischen Elementen zu definieren, deren diesbezüglicher Zeiger Mitglieder werden auf: zeigt auf const type. Dann wird die Funktion, die Sie aufrufen, geändert, um die neue Struktur zu übernehmen. Es wird eine Wrapperfunktion definiert, die die alte Struktur übernimmt, ein Element nach Element in die neue Struktur kopiert und an die Funktion übergibt.

Answer 3

Dies ist ein Beispiel für die Implementierung im Vergleich zur Schnittstelle oder "Information Hiding" - oder besser gesagt: nicht verstecken ;-) - Problem. In C++ hätte man einfach den Zeiger privat und definiert geeignete öffentliche const-Accessoren. Oder man würde eine abstrakte Klasse - eine "Schnittstelle" - mit dem Accessor definieren. Die eigentliche Struktur würde das umsetzen. Benutzer, die keine Strukturinstanzen erstellen müssen, müssen nur die Schnittstelle sehen.

In C könnte man das emulieren, indem man eine Funktion definiert, die einen Zeiger auf die Struktur als Parameter nimmt und einen Zeiger auf const char zurückgibt. Für Benutzer, die keine Instanzen dieser Strukturen erzeugen, könnte man sogar einen "Benutzerheader" bereitstellen, der die Implementierung der Struktur nicht leckt, sondern nur Manipulationsfunktionen definiert, die Zeiger aufnehmen (oder wie eine Fabrik zurückgeben). Dadurch bleibt die Struktur unvollständig (so dass nur Zeiger auf Instanzen verwendet werden können). Dieses Muster emuliert effektiv, was C++ hinter den Kulissen mit dem Zeiger this macht.

Answer 4

Dies ist ein bekanntes Problem der C-Sprache und nicht vermeidbar. Schließlich ändern Sie die Struktur nicht, Sie ändern ein separates Objekt durch einen nicht qualifizierten Zeiger, den Sie von der Struktur erhalten haben. const Semantik wurde ursprünglich um die Notwendigkeit entwickelt, Speicherbereiche als konstant zu markieren, die physikalisch nicht beschreibbar sind, nicht um irgendwelche Bedenken für defensive Programmierung.

Answer 5

Wenn Sie sich für die Verwendung von C11 entscheiden, können Sie ein generisches Makro implementieren, das entweder auf die konstante oder variable Version desselben Elements verweist (Sie sollten in Ihrer Struktur auch eine Union einfügen). So etwas wie dieses:

struct A 
{ 
    union { 
     char *m_ptrChar; 

     const char *m_cptrChar; 
    } ; 
}; 

#define ptrChar_m(a) _Generic(a, struct A *: a->m_ptrChar,  \ 
           const struct A *: a->m_cptrChar)//, \ 
           //struct A: a.m_ptrChar,  \ 
           //const struct A: a.m_cptrChar) 

void f(const struct A *ptrA) 
{ 
    ptrChar_m(ptrA) = 'A'; // NOT DESIRED!! 
} 

Die Union erstellt 2 Interpretation für ein einzelnes Mitglied.Die m_cptrChar ist ein Zeiger auf konstante Char und die m_ptrChar zu nicht konstant. Dann entscheidet das Makro, auf welches sich es bezieht, abhängig von der Art seines Parameters.

Das einzige Problem ist, dass das Makro ptrChar_m kann nur entweder mit einem Zeiger oder Objekt dieser Struktur und nicht die beiden arbeiten.

Answer 6

Wir könnten die Informationen hinter einigen "Accessor" Funktionen verbergen:

// header 
struct A;   // incomplete type 
char *getPtr(struct A *); 
const char *getCPtr(const struct A *); 

// implementation 
struct A { char *ptr }; 
char *getPtr(struct A *a) { return a->ptr; } 
const char *getCPtr(const struct A *a) { return a->ptr; } 

Answer 7

GCC Kann mir warnen über die Felder eines const struct in C99 zu modifizieren?

Sie ändern die Felder einer Const-Struktur nicht.

Ein Wert von Struktur A enthält einen Zeiger auf ein nicht-const Char. ptrA ist ein Zeiger auf eine const-Struktur A. Sie können also den Wert von struct A bei * ptrA nicht ändern. Sie können also den Zeiger nicht auf char (* ptrA) .Char aka ptrA-> ptrChar ändern. Aber Sie ändern den Wert von where ptrA-> ptrChar, also den Wert von * (ptrA-> Char) aka ptrA-> Char [0]. Die einzigen Nachteile hier sind struct As und du änderst keine Struktur A, also was genau ist "nicht erwünscht"?

Wenn Sie nicht möchten, dass bei Änderung des Wertes zu ermöglichen, wo ein Char Feldpunkte der Struktur A (über dieser Struktur A) dann verwenden

struct A 
{ 
    const char *ptrChar; // or char const *ptrChar; 
}; 

Aber vielleicht was Sie denken Sie tun in f ist so etwas wie

void f(const struct A *ptrA) 
{ 
    const char c = 'A'; 
    ptrA->ptrChar = &c; 
} 

Welche wird einen Fehler vom Compiler bekommen.