char * const?

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