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)

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

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&

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

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

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.

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.

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";

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

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?

Das typedef?
Nicht?

Da hat der Präprozessor keine Aktien drin.

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;

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

Das verwechselst Du mit #define