char * const?

Seikilos

Ich stehe gerade aufm Schlauch und zwar hab ich hier eine Methodendeklaration die diesen Parameter nimmt:

Foo::Foo(char * const);

Kann mir einer auf die Sprünge helfen? Es ist ja offensichtlich nicht "const char *"

Heißt das hier also dass die Pointer Adresse selbst const, aber das gepointete nicht ist?
(Ich frage, weil es eigentlich an dieser Stelle hier nicht vorkommen kann und darf)

Roger Wilco

Hier ist der Zeiger konstant. Nicht das Char selber, auf den der Zeiger zeigt.

http://www.parashift.com/c++-faq-lite/const-correctness.html#faq-18.5

Seikilos

Das ist aber nicht implizit durch eine Deklaration wie "char *" gegeben, oder? Wäre auch zu komisch

Richtig. Bei char * ist erst mal nix konstant.

Roger Wilco

char* - nix konstant, alles kann geändert werden
const char* - Zeiger auf einen konstanten char: Du darfst den Zeiger ändern, aber nicht den char selber
char* const - konstanter Zeiger auf ein char, welchen Du nach belieben ändern darfst
const char* const - Zeiger UND char sind konstant

const char& - Referenz auf ein ein konstantes char
char& const - obsolet, da eine Referenz immer konstant ist

Ergänzend:

char const* == const char*
char const& == const char&

Seikilos

Eine frage,wieso funktioniert das:

typedef char* string_;
#include <iostream> 

void foobar(string_ wayne)
{

  std::cout << wayne << std::endl;
}

int main()
{
  const string_ foo = "abc";
  foobar(foo);
}

Aber das nicht:

typedef char* string_;
#include <iostream> 

void foobar(char * wayne)
{

  std::cout << wayne << std::endl;
}

int main()
{
  const char * foo = "abc";
  foobar(foo);
}

Mein Compiler VC 7.1.
Ich habe erwartet, das beides nicht geht, seit wann juckt den compiler das mit dem const nicht, wenn ein typedef das "char *" wrappt?

Edit: und g++ macht hier eh was es will:
http://codepad.org/NcD9oIKb

unskilled

Das das unten nicht funktioniert sollte klar sein(const char* kann nicht in char* umgewandelt werden)...

so wäre es übrigens richtig:

#include <iostream>

typedef const char* const_string_;

void foobar(const_string_ wayne)
{
  std::cout << wayne << std::endl;
}

int main()
{
  const_string_ foo = "abc";
  foobar(foo);
}

edit: doch, es ist ja klar, dass das mit typedef compiliert ^^ eben, weil das const auf das typedef bezogen ist und nicht mehr auf das char*...

bb

Im oberen Fall entspricht:

typedef char *string_;

const string_ foo = "abc";

folgendem:

char * const foo = "abc";

Du hast mit typedef einen Typ vereinbart und im Code eine konstante Variable von diesem Typ.

Tachyon

Also erstmal: Ich bevorzuge folgende Schreibsweise:

char const * const a;

Das liest sich schön von hinten nach vorne:
a ist ein konstanter Zeiger auf konstante char .
Lässt man das eine oder andere const weg, so kann man auch aus dem Satz oben einfach das jeweilige "konstant" rausnehmen.
Zu der Frage, wieso die übergabe eines char * const geht:
Der Zeiger wird als Wert übegeben, also als Kopie.
Folgendes geht ja auch:

void f(int c);
int const a = 10;
int b = a; //b ist eine Kopie von a
f(a); //c in der Funktion ist eine Kopie von a

Das ist genau das Gleiche.

Tachyon schrieb:

void f(int c);
int const a = 10;
int b = a; //b ist eine Kopie von a
f(a); //c in der Funktion ist eine Kopie von a

Das ist genau das Gleiche.

TE hat offensichtlich erwartet, daß

typedef char *string_;
const string_ foo = "abc";

gleichbedeutend ist mit:

char const * foo = "abc";

Wie schon gesagt, entspricht es aber:

char * const foo = "abc";

Seikilos

Jepp is nun klar.

Aber merkwürdig, wenn der Präprozessor doch einfach nur ersetzt, wieso sieht es dann so unterschiedlich aus?

Tachyon

Seikilos schrieb:

Jepp is nun klar.

Aber merkwürdig, wenn der Präprozessor doch einfach nur ersetzt, wieso sieht es dann so unterschiedlich aus?

Wo ersetzt da der Präprozessor?

Seikilos

Das typedef?
Nicht?

Tachyon

Seikilos schrieb:

Das typedef?
Nicht?

Da hat der Präprozessor keine Aktien drin.

Seikilos

Aber ich krieg dann das typedef niemals mehr const ohne ein weiteres typedef?

Tachyon

Seikilos schrieb:

Aber ich krieg dann das typedef niemals mehr const ohne ein weiteres typedef?

Schau Dir mal die Iteratoren aus der STL an. Da gibt es zu jedem mutable Iterator auch immer eine const-Version.
Beispiel:

std::vector<T>::iterator
std::vector<T>::const_iterator

Für Deinen Pointer auf const typedef musst Du das ähnlich machen:

typedef T * MyTPointerType;
typedef T const * MyConstTPointerType;

Seikilos schrieb:

wenn der Präprozessor doch einfach nur ersetzt, wieso sieht es dann so unterschiedlich aus?

Das verwechselst Du mit #define