Compilerwarnung Pointertyp const char **
Lars Meier
seit einiger Zeit schon habe ich ein Verständnisproblem im Zusammenhang
mit const und Zeigern: Häufig schreibe ich Code zum Parsen von speziell
formatiertem Text. Dabei gibt es bestimmte Textblöcke die an mehreren
Stellen eingelesen werden. Deshalb werden diese Blöcke meist von einer
eigenen Funktion bearbeitet. Diese Funktionen erhalten dann meist die
aktuelle Leseposition im String als "char **", so dass diese die
Leseposition weitersetzen können. Dabei soll der Text nicht veränderlich
sein, ich würde also gerne den Parameter ein const verpassen. Doch wo
muss es stehen? Ich hätte eigentlich gedacht "const char **" wäre
richtig. Doch dann meckert der Compiler. Hier ein Beispiel:
void func1(const char *s)
{
}
void func2(const char **s)
{
++(*s);
}
int main()
{
char buffer[100];
char *s = 0;
s = &buffer[10];
func1(s); // alles Bestens
func2(&s); // hier ist laut Compiler der Zeigertyp inkompatibel
return 0;
}
Der gcc sagt dazu:
cp.c:18: warning: passing argument 1 of ‘func2’ from incompatible
pointer type
Wie muss der Code richtig aussehen?
Lars
Alexander Bartolich
> [...] Dabei soll der Text nicht verï¿œnderlich
> sein, ich wï¿œrde also gerne den Parameter ein const verpassen. Doch wo
> muss es stehen? Ich hï¿œtte eigentlich gedacht "const char **" wï¿œre
> richtig.
Das Schlï¿œsselwort "const" bezieht sich auf den links davor stehenden
Ausdruck, auï¿œer es steht nichts links davor, dann bezieht es sich auf
den rechts folgenden Ausdruck.
ￜconst char **ￜ ist also die Sonderform von ￜchar const **ￜ und gibt
an, dass der ￜcharￜ unverￜnderlich ist.
> [...]
> void func2(const char **s)
> {
> ++(*s);
> }
Diese Funktion verￜndert einen Zeiger vom Typ ￜchar const*ￜ, der an
der Adresse ￜ*sￜ liegt.
> int main()
> {
> char buffer[100];
> char *s = 0;
>
> s = &buffer[10];
> func1(s); // alles Bestens
> func2(&s); // hier ist laut Compiler der Zeigertyp inkompatibel
> return 0;
> }
Du ￜbergibst ￜfunc2ￜ allerdings die Adresse eines Zeigers vom Typ
ￜchar*ￜ. Das ist nicht gestattet. Das Motiv hinter dieser Einschrￜnk-
ung ist vermutlich, Systeme zu ermï¿œglichen, die unterschiedliche Bit-
muster fï¿œr const-Zeiger und non-const-Zeiger verwenden.
> Wie muss der Code richtig aussehen?
Rein grundsï¿œtzlich ist deine Logik fragwï¿œrdig.
Wenn man den Code so abï¿œndert:
const char* t = s;
func2(&t);
s = t;
bleibt immer noch ï¿œwarning: assignment discards qualifiers from pointer
target typeￜ ￜbrig. Verfolgt man den Ansatz konsequent weiter, wird
daraus:
const char* func2(const char *s)
{
return ++s;
}
[...]
s = func2(s);
--
Michael Schumacher
Wieso richtig? Er ist ja nicht flasch, bloß weil der Compiler eine
Warnung generiert hat (obwohl man die durchaus ernstnehmen sollte!).
Deklariere in main() "const char *s;" oder verwende dort den Aufruf
"func2 ((const char **) &s);" -- und der Compiler bleibt sprachlos.
Warum genau sich "const" und "nicht-const" nicht vertragen, kann Dir
Claus sicher in kapitelnumerierter Form aus der Bibel zitieren. ;-)
mike
Lars Meier
Schade, das ist ja eher unpraktisch. Ich hatte const bisher eher als
"Programmierhilfe" verstanden, die auf das Programm keinen Einfluￜ hat.
>
>> Wie muss der Code richtig aussehen?
>
> Rein grundsï¿œtzlich ist deine Logik fragwï¿œrdig.
In wiefern fragwï¿œrdig?
> Wenn man den Code so abï¿œndert:
>
> const char* t = s;
> func2(&t);
> s = t;
>
Mit zwei Zeigern zu hantieren finde nicht gerade ï¿œbersichtlich. Den
RW-Zeiger brauche ich nï¿œmlich manchmal schon.
> bleibt immer noch ï¿œwarning: assignment discards qualifiers from pointer
> target typeￜ ￜbrig. Verfolgt man den Ansatz konsequent weiter, wird
> daraus:
>
> const char* func2(const char *s)
> {
> return ++s;
> }
> [...]
> s = func2(s);
>
Genau das mï¿œchte ich aber nicht, weil meine Funktionen in der Regel eine
Information ï¿œber den Erfolg zurï¿œckgeben und das soll auch so bleiben,
weil ich das ï¿œbersichtlicher finde. Hinzu kommt, dass ich dann
unweigerlich bei der Zuweisung die schon erwï¿œhnte Warning bekomme. Die
kann ich zwar auch "Wegcasten" aber, wenn ich mir letzlich doch alles
zurechtcasten muss, dann kann ichs mit dem const auch ganz lassen.
Ich denke, genau das werde ich jetzt auch tun.
Danke fï¿œr die Tipps
Lars
Lars Meier
Nun ja, die Warnung wegzucasten kann ja nicht die Lösung sein. Es gibt
zwar manche Warnung, die man getrost ignorieren kann, doch bei dieser
bin ich mir nicht so sicher. Zumal ich sie sowohl vom gcc als auch vom
MS Visual Studio Compiler bekomme. Mit dem Cast könnte man so ziemlich
alles an die Funktion übergeben. Wenn Alexander richtig vermutet und die
Warnung auf einen möglichen Darstellungsunterschied zwischen const und
nicht-const-Pointern hinweisen soll, dann wäre dieser cast sogar gerade
falsch.
Markus König
> Michael Schumacher schrieb:
>>
>> Wieso richtig? Er ist ja nicht flasch, blo� weil der Compiler eine
>> Warnung generiert hat (obwohl man die durchaus ernstnehmen sollte!).
>> Deklariere in main() "const char *s;" oder verwende dort den Aufruf
>> "func2 ((const char **) &s);" -- und der Compiler bleibt sprachlos.
>>
>> Warum genau sich "const" und "nicht-const" nicht vertragen, kann Dir
>> Claus sicher in kapitelnumerierter Form aus der Bibel zitieren. ;-)
>>
>
> Nun ja, die Warnung wegzucasten kann ja nicht die L�sung sein. Es gibt
> zwar manche Warnung, die man getrost ignorieren kann, doch bei dieser
> bin ich mir nicht so sicher. Zumal ich sie sowohl vom gcc als auch vom
> MS Visual Studio Compiler bekomme. Mit dem Cast k�nnte man so ziemlich
> alles an die Funktion �bergeben. Wenn Alexander richtig vermutet und die
> Warnung auf einen m�glichen Darstellungsunterschied zwischen const und
> nicht-const-Pointern hinweisen soll, dann w�re dieser cast sogar gerade
> falsch.
Die Einschr�nkung hat nicht unbedingt etwas mit unterschiedlichen internen
Darstellungen zu tun, der Grund liegt tiefer.
K�nnte man einen "x**" an ein Objekt vom Typ "const x**" zuweisen, dann
k�nnte man const umgehen, ohne zu casten:
#include <stdio.h>
void mystery(const int *p)
{
int *q;
const int **pp = &q; /* pp zeigt auf q; zum Glueck ein Fehler! */
*pp = p; /* q zeigt auf *p */
*q = 2; /* veraendert *p! */
}
int main(void)
{
int x = 1;
mystery(&x);
printf("%d\n", x); /* 1 oder 2? */
return 0;
}
Michael Karcher
> Könnte man einen "x**" an ein Objekt vom Typ "const x**" zuweisen, dann
> könnte man const umgehen, ohne zu casten:
>
> #include <stdio.h>
>
> void mystery(const int *p)
> {
> int *q;
> const int **pp = &q; /* pp zeigt auf q; zum Glueck ein Fehler! */
> *pp = p; /* q zeigt auf *p */
> *q = 2; /* veraendert *p! */
> }
>
> int main(void)
> {
> int x = 1;
> mystery(&x);
> printf("%d\n", x); /* 1 oder 2? */
>
> return 0;
> }
C++ ist hier aber flexibler als C. In C++ würde die Zeile
const int * const * pp = &q;
funktionieren, da dann die Zeile "*pp = p" fehlschlagen würde.
In C89 (wenigstens mit gcc 4.4) schlägt die in C++ gültige Zeile
leider auch fehl.
Gruß,
Michael Karcher
Michael Schumacher
Die Compiler-Warnung ist berechtigt (mein Vorschlag, sie per Cast zu
verhindern, allerdings auch). Das hat nichts damit zu tun, daß const-
und veränderliche Objekte unterschiedlich dargestellt werden würden,
sondern damit, daß es zu "interessanten" Nebeneffekten kommen kann:
wenn "func2()" z.B. per "*s = &const_char_array[42];" den Zeiger auf
ein konstantes Zeichen setzt, könnte nach der Rückkehr "main()" mit
"*s = '\0';" ungestraft (jedenfalls, wenn keine HW-Protection existiert)
schreibend auf eine Konstante zugreifen -- daher die Warnung, und warum
sie erst ab doppelter Indirektion (pointer-to-pointer-to-const) auftritt,
läßt sich unter <http://c-faq.com/ansi/constmismatch.html> nachlesen.
Die einzig sinnvolle Möglichkeit, die Warnung zu umgehen, ist der Cast
beim Aufruf von "func2()" -- und zudem natürlich sicherzustellen, daß
deren Parameter "s" nicht "fremdzeigt". Die Alternativen (Warnungen
abschalten, oder das "const" von der Parameterdeklaration entfernen),
sind sicher nicht empfehlenswert.
mike
Lars Meier
Da stimmt nat�rlich. Guter Gedanke. An sowas hab ich nicht gedacht.
Lars Meier
Danke für die Tipps. Da wäre ich nicht drauf gekommen, dass man so const
umgehen kann.
Lars