if ((lpszBuffer[k] != '/')
if ((lpszBuffer[k] != "/")

Ok ich weiß das der zweite Ausdruck
ungleich ASCII Zeichen bedeutest
was bedeutet er aber mit einfachen
Hochkommas.

Ok ich weiß das der zweite Ausdruck
ungleich ASCII Zeichen bedeutest

Falsch. Der erste überprüft, ob das k-te Zeichen aus lpszBuffer ungleich dem Zeichen 0 ist.

Der Zweite macht keinen Sinn. Da wird die Adresse einer Zeichenkette mit einem Zeichen verglichen.

Der nächste bitte

Ja ist ein bischen anders wie Delphi Pascal.
Danke

Nein, das ist anders als...

Der Fehler hier ist der, zu denken, const char* oder char* wäre etwas, was man wie einen String im Sinne des Werttyps (zB std::string) handhaben kann. Nein, char* ist nunmal ein Zeiger und nichts anderes.

Was soll denn da anders sein? Ich habe Pascal inzwischen verlernt, kann dazu also nicht viel sagen. Aber in Pascal gibt es auch Zeiger und die lassen sich bestimmt nicht mit String-Literalen vergleichen.

AFAIK werden in Pascal die Strings in Hochkommata eingeschlossen und nicht in Anführungszeichen.

AFAIK werden in Pascal die Strings in Hochkommata eingeschlossen und nicht in Anführungszeichen.

Und sie sind auch keine Adresse sondern immer die Zeichenkette selbst. Daher wahrscheinlich die Unklarheiten.

"/" ist aber auch kein char*, sondern ein const char[2]

Richtig, aber auch nur wegen dem \0;
Korrekterweiße:

char const c = "/"[0];

oder gleich:

char const c = '/';

Alle Konstanten beginnend mit "" sind Adresse auf die Zeichenkette die sie enthalten und referenzieren mind. 1 Byte, da ein \0 immer angehängt wird.
Konstanten beginnend mit '' repräsentieren wirklich einen expliziten char.

Bashar schrieb:

"/" ist aber auch kein char*, sondern ein const char[2]

Richtig, aber auch nur wegen dem \0;

Es ging ihm eigentlich darum, dass "blablabla" keine Adresse ist, wie man es eigentlich aus deiner Aussage ableiten könnte:

FrEEzE2046 schrieb:

ProgChild schrieb:

AFAIK werden in Pascal die Strings in Hochkommata eingeschlossen und nicht in Anführungszeichen.

Und sie sind auch keine Adresse sondern immer die Zeichenkette selbst. Daher wahrscheinlich die Unklarheiten.

Auch in C und C++ sind es keine Adressen, sondern die Zeichenketten selbst, um genau zu sein ein char-Array. Arrays sollte man nicht mit Adressen gleichsetzen, es sind eigenständige Typen. Sie besitzen allerdings einen impliziten Konvertierungsoperator zu einer Adresse, weshalb Arrays so flüchtig sind.

Grüssli

void* mem = "Hallo";
for( int i = 0; i < 5; i++ )
	cout << *(reinterpret_cast<char*>(mem) + i);
cout << '\n';

Ja, aber eine Array-Variable ist immer die Adresse auf das erste Element.

http://www.youtube.com/watch?v=WrjwaqZfjIY

FrEEzE2046 schrieb:

Ja, aber eine Array-Variable ist immer die Adresse auf das erste Element. Insofern kann man das - dem Verständnis halber - schon so erklären.

void* mem = "Hallo";
for( int i = 0; i < 5; i++ )
	cout << *(reinterpret_cast<char*>(mem) + i);
cout << '\n';

Wo gibt es denn da eine "Array-Variable"? Ich sehe keine.

...und dass eine "Array-Variable" eine Adresse auf das erste Element "ist", ist mehrfach falsch. Zunächst einmal ist ein Array ein Array und kein Zeiger. Zeiger sind auch keine Adressen -- sie speichern welche.

Ja, aber eine Array-Variable ist immer die Adresse auf das erste Element. Insofern kann man das - dem Verständnis halber - schon so erklären.

void* mem = "Hallo";
for( int i = 0; i < 5; i++ )
	cout << *(reinterpret_cast<char*>(mem) + i);
cout << '\n';

Der Code ist schonmal kein ISO C++.

krümelkacker schrieb:

Zunächst einmal ist ein Array ein Array und kein Zeiger. Zeiger sind auch keine Adressen -- sie speichern welche.

1. Halte ich es für "sehr Intelligent" eine einfache Verständnisproblematik so umständlich zu erklären. Der Denkfehler lag doch ganz wo anders, da kann man die Erklärung auch abstrakt formulieren.
2. Ist das - in diesem Fall - Erbsenzählerei. "Ein int ist auch keine Ganzzahl, sondern speichert eine" ...

rüdiger schrieb:

Der Code ist schonmal kein ISO C++.

Weshalb?

rüdiger schrieb:

Der Code ist schonmal kein ISO C++.

Weshalb?

Weil die Konvertierung in void* die constness entfernen würde.

Weil die Konvertierung in void* die constness entfernen würde.

Dann packen wir halt noch nen const_cast rum, okay^^

Implizit ist eine Konstante beginned mit "" immer ein const char* const, somit ein Pointer auf eine Zeichenkette und dadurch eine Adresse.

Erkläre mir mal die Bedeutung von "implizit sein".

Ein String-Literal ist ein Lvalue-Ausdruck vom Typ const char[N] , wobei N die Zahl der Zeichen des Arrays sind (inklusive Nullterminierung). In einigen Kontexten findet hier "array-to-pointer decay" statt, welches dir einen Zeiger-Wert (RValue) des Typs const char* liefert und nicht const char* const .

Das hat nichts mit Erbsenzählerei zu tun. Deine Aussage ist einfach falsch. Du hast wegen des "array-to-pointer decay"s den Typ eines String-Literals falsch abgeleitet. Nach Deiner Logik wäre bei folgendem Programm

template<typename T> void foo(T const& x);
int main() {
  foo("Gefaehrliches Halbwissen");
}

der Template-Parameter T = const char* . Ist er aber nicht. Es gilt hier T = char[25] .

Ich sagte nur, dass "letztendlich" (praktisch) ein char[25] trotzdem eine Adresse ist

Ja, habe ich schon verstanden, was Du sagen willst. Ist aber falsch. Ein Lvalue-Ausdruck, welcher sich auf ein Array bezieht, kann in Kontexten verwendet werden, in denen eine Adresse benötigt wird. Hier findet dann ein automatisches "array-to-pointer decay" statt welches die Adresse (= Wert eines Zeiger-Typs) auf das erste Element liefert. Trotzdem ist ein Array kein Zeiger und auch keine Adresse. Da kannst Du noch soviele Qualifizierer (praktisch, implizit, aus logischer Sicht, letztendlich...) benutzen, das macht Deine Aussage nicht weniger falsch. Es ist auch keine Erbsenzählerei. Im Gegenteil. Ich finde das, was Du da von Dir gibst, unverantwortlich. Der unerfahrene Programmierer könnte Dir ja noch den Unsinn glauben und sich später wundern, warum sizeof(char[25]) != sizeof(char*) gilt, oder warum auf einmal die Template-Argument-Deduction bei Arrays "ganz komisch" funktioniert. Dann kommen wieder Sprüche wie "Ich dachte ein Array sei nur ein Zeiger" etc etc etc. Das Array/Zeiger Thema bereitet Anfängern schon genug Probleme. Da brauchst Du nicht auch noch anfangen, Array=Zeiger oder Array=Adresse zu behaupten.

Ich sagte nur, dass "letztendlich" (praktisch) ein char[25] trotzdem eine Adresse ist, an der eine 25 Byte Zeichenkette liegt.

Letztendlich ist JEDES OBJEKT nur ein Zeiger auf eine definierte Menge Bytes. Daher ist diese Argumentation völliger Unsinn.

Grüssli