wie schaffe ich es eine konstante Referenz auf ein String Literal zu binden.

template<class T>
void fun(const T &ref) { }

fun("string");

Hier ist T vom Typ const char[7]. Doch ohne T, also den Typ selber hinzuschreiben, bekomme ich irgendwie nicht hin. Alle versuche und Kombinationen sind bis jetzt gescheitert ...

Desweiteren:

char *p = "Hallo";

In http://www.c-plusplus.net/forum/viewtopic-var-t-is-218128.html haben wir gelernt das dies ein "deprecated compatibility feature" ist.

Ich dachte dies wäre nur für die initialisierung gültig, doch auch die Zuweisung funktioniert:

char *p; 
p = "Hallo";

Ist das immer noch"deprecated compatibility feature" ???

fun(std::string("string"));

templateparameter kenne keine implizite typumwandlung, was auch reichlich absurd wäre, da templates dazu diene, pro typ etwas zu erzeugen, daher muss man sie explizit ausführen.

nein, das ist reine eindeutigkeit. wenn du einen string willst, musst das deinem compiler auch sagen:

fun(std::string("string"));

templateparameter kenne keine implizite typumwandlung, was auch reichlich absurd wäre, da templates dazu diene, pro typ etwas zu erzeugen, daher muss man sie explizit ausführen.

Du hast micht falsch verstanden.

Ich will dies erreichen:

const char* &ref = "Hallo"; // Error

Dies funktioniert natürlich nicht, da Hallo vom Typ const char[6] ist.
Das hier funktioniert natürlich ( siehe anderen Thread ) :

char *ref = "Hallo";

Dann ändern wir dies mal auf:

const char &ref[6] = "Hallo"; //Error

Denn so würde ich versuchen nen Array von Refernzen anzulegen, was verboten ist ( wieso ? ).

Das Template weiß wie die Syntax aussieht, nur ich anscheinend nicht ...

Da man ja konstante Referenzen an Rvalues bin kann, zB const int &ref = 5, wollte ich dies auch mit einem Stringliteral probieren.

Doch so einfach

char *p = "Hallo";

In http://www.c-plusplus.net/forum/viewtopic-var-t-is-218128.html haben wir gelernt das dies ein "deprecated compatibility feature" ist.

Ich dachte dies wäre nur für die initialisierung gültig, doch auch die Zuweisung funktioniert:

char *p; 
p = "Hallo";

Ist das immer noch "deprecated compatibility feature" ???

Das erste ist doch noch gesund und funktioniert, das Zweite jedoch ist nicht gültig und wahrscheinlich undefiniert, doch wieso ist es hier erlaubt ?

Hier existiert doch die Speicherstelle, in der "Hallo" steht, solange wie auch p existiert.

char *p;
p = "Hallo";

Hier müsste die Speicherstelle von "Hallo" nach der Anweisung wieder frei sein. Also zeigt p ins Nirvana.
Ich hätte eher gedacht das ein String-Literal (const char[x]) nur bei der Initalisierung in ein char* konvertiert werden darf ( deprecated compatibility feature ).

Das es auch bei der Zuweisung erlaubt ist finde ich merkwürdig, den wie gesagt, ist dies undefiniert.

Hier existiert doch die Speicherstelle, in der "Hallo" steht, solange wie auch p existiert.

Seit wann haben Literale Referenzzählung oder Pointer einen Mechanismus dafür?

Das Literal existiert während der gesamten Programmlaufzeit, die Adresse davon solange, bis Du sie verlierst.

EDIT:
Zur Klärung: Das Literal "Hallo" wird vom Compiler "irgendwo" hingeschoben und die Adresse von "irgendwo" an der Stelle des Literals eingesetzt. Wieso sollte das Ergebnis dessen (oder gar die Lebensdauer vom Literal) bei einer Initialisierung anders sein als bei einer Zuweisung?

Seit wann haben Literale Referenzzählung oder Pointer einen Mechanismus dafür?

Temporäre Objekte existieren auch, solange der Ausdruck nicht abgearbeitet ist, zB bei der Übergabe eines temp-Objektes an eine Funktion, aber brauche ich dir ja nicht alles zu erklären

Ich werd noch wahnsinnig, diese Literal-Geschichte macht mich noch ganz vErÜcKT.
Ich glaube ich lasse das dann mal und nehme einige Sachen mal erstmals so hin ...

Wichtig ist eigentlich nur, dass Literale in einem Bereich unendlicher Lebensdauer liegen, und dass der Compiler ihr Vorkommen durch eine Adresse ersetzt (wobei nicht definiert ist, ob Literale identischen Inhalts auch identische Adressen haben müssen). Damit ist folgendes technisch identisch:

char* x = 0x123456;
x = 0x654321;

int y = 12;
y = 24;

Wichtig ist eigentlich nur, dass Literale in einem Bereich unendlicher Lebensdauer liegen, und dass der Compiler ihr Vorkommen durch eine Adresse ersetzt (wobei nicht definiert ist, ob Literale identischen Inhalts auch identische Adressen haben müssen).

Das gilt aber nur für String-Literale, oder? Für andere wird doch keinen Speicher alloziert...

char *p;
p = "Hallo";

Denn normal würde man das hier doch so machen:

char p[10];
strcpy(p, "Hallo");

// oder
char *p = new char[10];
strcpy(p, "Hallo");

delete [] p;

Nexus schrieb:

Das gilt aber nur für String-Literale, oder? Für andere wird doch keinen Speicher alloziert...

Was für "andere"? Meinst Du Arrays? Sprich:

char x[] = "Hallo"; // x == Array von 6 Bytes auf Stack mit Inhalt 'H', 'a', ...
char* y = "Hallo"; // y == Zeiger auf Stack mit Inhalt "Adresse von Literal Hallo im Readonly-Speicher"

Im ersten Fall werden sechs Bytes auf dem Stack benötigt, im zweiten sizeof(void*) auf dem Stack und 6 in dem Bereich, in dem der Compiler Literale ablegt.

@KasF

KasF schrieb:

Ok, danke und was ist hiermit, ist dies wohldefiniert und gültig:

Ich glaube, hier ist irgendwo ein Verständnisproblem oder ein kleines Brett vorhanden

Hier passiert:

Datenbereich des Programms:
0x01000 H a l l o \0
0x01006 W e l t \0

Funktion des Programms: [Pseudocode]
add ebp, 4 // 4 Byte auf Stack reservieren (hieß mal "p")
mov [ebp+0], 0x01000 // auf "p" die Adresse von "Hallo" schreiben
....
mov [ebp+0], 0x01006 // auf "p" die Adresse von "Welt" schreiben

Ich weiss nicht, wie ich sonst darstellen soll, dass es sich bei Literalen um Daten, die unbegrenzte Lebenszeit während der Programmlaufzeit haben, handelt, und die Adressen dieser Daten lediglich im Programm "herumgeschubst" werden.

Ich weiss nicht, wie ich sonst darstellen soll, dass es sich bei Literalen um Daten, die unbegrenzte Lebenszeit während der Programmlaufzeit haben, handelt, und die Adressen dieser Daten lediglich im Programm "herumgeschubst" werden.

Hmm... vielleicht so:
Wenn du ein String-Literal benutzt, wird für dich ein globale Konstante angelegt.

int main()
{
    const char* p = "Hello World!";
}

Ist also (in etwa) identisch zu:

const char Literal_Hello_World[] = "Hello World!";

int main()
{
    const char* p = Literal_Hello_World;
}

Deshalb kann man z.B. String-Literale aus Funktionen zurückgeben, ohne undefiniertes Verhalten hervorzurufen.

Gruß
Don06

@Nexus

Nexus schrieb:

Das gilt aber nur für String-Literale, oder? Für andere wird doch keinen Speicher alloziert...

Was für "andere"? Meinst Du Arrays?

Nein, ich meinte Non-String-Literale wie 43.7f oder 208 , für die ja kein Speicher reserviert wird. Aber darum scheint es eh nicht zu gehen, es war mir nur aus deinem Post nicht ganz klar, ob du allgemein Literale meintest.

Wenn man das selbe String-Literal mehrmals benutzt, wird jedes Mal Speicher reserviert, oder?
Also abgesehen von der Sinnlosigkeit:

std::cout << "Hello World" << std::endl;
std::string Str = "Hello World";

char* text = "hallo";

text[0] = 'B'; //kracht natürlich

Aus Kompatibilitätsgründen nehme ich an, oder?

kleines Brett vorhanden

Brett von LordJaxom durchgeschlagen.

templäd schrieb:

Wobei ich nicht verstehe wieso man das machen kann.

char* text = "hallo";

text[0] = 'B'; //kracht natürlich

Aus Kompatibilitätsgründen nehme ich an, oder?

text ist halt nen einfaches char* und da ist text[0] = ... bzw *(text+0) = ... auch ja ganz normal und hat hier nichts mit Kompatibilität zu tun.