char Variable Verständnis problem

STF-DIR

Hallo,

ganze ehrlich ??
Das hab ich nicht verstanden .. STOP Taste , Schneller Rücklauf und Play :

"Size: " ist vom Typ const char *, also ein Zeiger. sizeof(char) gibt 1 zurück

Was hat das denn mit dem Wort "Size" zu tun ?

Ich hab mich sicherlich falsch ausgedrückt.
Ich hab ( frag mich nicht mehr wo ) heute irgendwo gelesen das bei .NET der Typ char nicht 1 byte sondern 2 Byte groß sein soll ?

Das wollte ich mit

Console::WriteLine("Size: " + sizeof(char));

ich weiss ( jetzt ) das das "L" fehlte, hatte ich vergessen.
Das sizeof sollte sich aber niocht auf das "Size" beziehen sondern ich dachte damit eigentlich die größe des Datentypes (char) angezeigt zu bekommen.

Hätte vielleicht besser so

Console::WriteLine(L"Size: {0}", sizeof(char));

schreiben sollen.

Übrigens zeigt das hier von Dir :

Console::WriteLine(L"Size: " + (sizeof(char)).ToString());

auch eine 1 an. Also ist das kein .NET was ich hier mache oder stimmt das mit den 2Byte für einen char bei .NET doch nicht ?

Matthias

Ps.: Ich gewinne den Eindruck das C++ nicht viel mit Strings am Hut hat .. ??

Verwende mal

Console::WriteLine(L"Sizeof Char: " + sizeof(Char));

und du wirst Wunder staunen

In C# wäre char automatisch nen Alias zu Char, aber das geht in C++/CLI nicht so, weil es ja auch den 1 Byte char Typen gibt aus dem C++ Standard und dem wird der Vorzug gegeben.

Zwergli schrieb:

Verwende mal
Console::WriteLine(L"Sizeof Char: " + sizeof(Char));
und du wirst Wunder staunen

In C# wäre char automatisch nen Alias zu Char, aber das geht in C++/CLI nicht so, weil es ja auch den 1 Byte char Typen gibt aus dem C++ Standard und dem wird der Vorzug gegeben.

Du hast offensichtlich keine Ahnung davon. Der C#-Typ char (System::Char) ist in C++/CLI der Typ wchar_t. Der C++/CLI char aber ist in C# je nach Compilereinstellung byte oder sbyte (also System::Byte oder System::SByte).

STF-DIR

Hallo,

äh, iGod und Zwergli ... würdet Ihr Euch mal bitte einig werden ?
SO komme ich ja noch mehr durcheinander, wenn ihr das schon nicht genau wisst.

Aber mal noch was anderes.Ich bin gerade an einer Stelle wo es um Arrays und char ( schon wieder dieser char Typ ) geht.

Ich kann folgendes machen :

// Als Beispiel ein Record von 5 double Werten
	double data[5];
	// Mal irgendwelche Werte zuweisen
	data[0] = 0.0;
	data[1] = 1.1;
	data[2] = 2.2;
	data[3] = 3.3;
	data[4] = 4.4;

	// Beispiel ausgabe über Array direkt
	for(int x=0;x<5;x++)
		{
			cout << data[x] << endl;
		}

	// Beispiel Ausgabe über Zeiger
	double *pAdrOfData;			// Zeiger vom typ double
	pAdrOfData = &data[0];	// Zeiger Zeigt auf die Anfangsadress von data[]
	for(int x=0;x<5;x++)
		{
			cout << *pAdrOfData << endl;  
			pAdrOfData++;       // Zeiger auf die nächste position setzen
		}

Was da raus kommt wisst Ihr sicher oder könnt es eben kurz testen.
Jedenfalls funktioniert das genau so wie ich das verstanden habe.

Nun wollte ich das ganze mit dem Beispiel aus dem Tut machen aber als Char Array. Dachte mir eigentlich das das das gleiche sein müsste .. is es aber wieder nicht

char *aStars[] = {
		"Robert Redford",
		"Hopalong Cassidy",
		"Lassie",
		"Slim Pickens",
		"Boris Karloff",
		"Oliver Hardy"
		};

So ist dann der Array definiert, aber das ist ja schon wieder anders als bei dem double. (*aStars[] ) das heist ja ein Zeiger auf jeden char in dem Array (oder?)
Also wie könnte ich denn jetzt eine variable vom typ char ( denke ich mal ) felstlegen etwa so :

char *pStars; // wäre ein zeiger auf einen char
pStars = &aStars[0]; // müsste dann iauf die erste Adresse von aStars[] zeigen.
Das geht aber so nicht , ich weiss.
Was ich wissen möchte ob das geht und wenn ja dann vielleicht auch wie ?

Ich weiss, das mag jetzt alles unsinnig erscheinen aber ich will das endlich verstehen !

Matthias

Knuddlbaer

Warum kommt System::Bool am ehesten in Frage ?

System::String hat einen Konstruktur, der const char* entgegen nimmt. Dann wird der Operator+ verwendet um das Ergebnis von sizeof(char); an den String zu ketten.

So gibt

Console::WriteLine("Hello World " + sizeof(int));

nicht 1 für true aus sondern Hello World 4

Allerdings gibt ein:

char ta[] = "Hallo Welt";
	const char const * tb = &ta[0];
         Console::WriteLine(tb);

ein True aus, wobei ich eine Wandlung in Int32 oder Int64 erwartet hätte, aber nicht in bool. (Ich war allerdings in den Auflösungsregeln ohnehin nie gut, zumal beim .Net wohl noch ein paar dinge hinzugekommen sind).

STF-DIR

Knuddlbaer schrieb:

Warum kommt System::Bool am ehesten in Frage ?

System::String hat einen Konstruktur, der const char* entgegen nimmt. Dann wird der Operator+ verwendet um das Ergebnis von sizeof(char); an den String zu ketten.

So gibt
Console::WriteLine("Hello World " + sizeof(int));
nicht 1 für true aus sondern Hello World 4

Allerdings gibt ein:
char ta[] = "Hallo Welt";
	const char const * tb = &ta[0];
         Console::WriteLine(tb);
ein True aus, wobei ich eine Wandlung in Int32 oder Int64 erwartet hätte, aber nicht in bool. (Ich war allerdings in den Auflösungsregeln ohnehin nie gut, zumal beim .Net wohl noch ein paar dinge hinzugekommen sind).

Hallo,

bool ?? Hä?
Hat das jetzt irgendwas mit meiner Frage zu tun ?

Matthias

PS.: Wenn ja , dann hab ich's nicht verstanden und Du hast überlesen das ich (blutiger) Anfänger bin !

Knuddlbaer

Nein, das ganze war an iGod gerichtet.

Was Du da machst ist sicherlich nicht für blutige Anfänger gedacht.
Ich würde auch nicht gleich mit dem .Net anfangen sondern reines C oder vllt. sinvoller wenn man am Ende auf .net will, C++ anfangen.

Hier der gewünschte Effekt wie mit dem double Array:

char *aStars[] = {
        "Robert Redford",
        "Hopalong Cassidy",
        "Lassie",
        "Slim Pickens",
        "Boris Karloff",
        "Oliver Hardy"
        }; 

	char ** ta = aStars;
	for(int i = 0; i <= 5;++i)
	{
		cout<<*ta<<"\n"<<endl;
		++ta;
	}

Du hast nun ein char ** , einen Zeiger auf ein Array von Zeigern auf char.

Und hier kannst Du dann mit den Zeigeroperationen die einezlenen Arrayelemente anspringen.

Das erste ist also an Array von Zeigern. Mit dem ta++ bewegst Du Dich in diesem Array und übergibst die dort gespeicherten Zeiger auf char an cout.

STF-DIR

Hallo,

ok das funktioniert und ich habs sogar verstanden denke ich.
Naja, ich hab hier das tutorial (1226 seiten eng ) und gehe das komplett durch. Nebenbei, also alles was behandelt wird probiere ich eben solange aus bis ich es verstanden habe. Mich drängelt ja keiner.

Ok, eine frage hab ich dazu aber trotzdem noch: ( falls irgendwas falsch - bitte richtig stellen )

double data[5];       // ein Array von 6 doubles
double *pAdrOfData;   // ein Zeiger vom typ double
// das hier :::
pAdrOfData = &data[0]; // Zeiger Zeigt auf die Anfangsadresse von data[]

das heist doch das hierbei pAdrOfData auf den Anfang des speicherbereiches zeigt wo das erste Element von data[], also data[0] abgelegt ist oder ?

Also nehmen wir mal an das data[0] an der speicheradresse 00000001 liegt ( wie gesagt nur mal angenommen ). Ein double hat 8byte. das würde bedeuten das ein pAdrOfData++ den zeiger um 8 stellen weiterschiebt, also auf 00000009. Dort steht jetzt das zweite element von data .. usw.

Wie ist das denn jetzt bei dem Array ?
Zeigt dort "char ** ta = aStars;" auch auf das erste Element von char aStars ?
Also auf die Speicheradresse wo das erste Element zu finden ist ?

Ich frage nur weil es nicht so heist :

char ** ta = &aStars[0];

Das & bedeutet doch eigentlich das der Zeiger auf die Speicheradresse zeigt ja.

Matthias

Ps:: es geht hier nur darum das ich das verstehe !!

Knuddlbaer

Na

char ** ta = &aStars[0];

wäre auch gegangen.

Ich bin zu lange aus reinem C raus, ich werde es Dir leider nich bis auf dem letzten erklären können :o(

Wenn Du das wirklich bis aufs letzte erklärt haben möchtest, möge das jemand in C Forum verschieben

Also, aStars[0] zeigt auf das erste Array. Und das & davor organisiert den Zeiger auf das erste Array. Also vollkommen richtig verstanden.

Ein T * t[]; ist am ende nichts anderes als ein T ** t;

Warum jetzt allerdings nicht:

char **aStars = {
        "Robert Redford",
        "Hopalong Cassidy",
        "Lassie",
        "Slim Pickens",
        "Boris Karloff",
        "Oliver Hardy"
        };

geht kann ich Dir leider nicht mehr erklären. Ich >>nehme an<< es hängt damit zusammen, das der Compiler mit dem [] gesagt bekommt, das er gleich Werte initialisieren soll. Hier müsste mal jemand rann, der noch richtig Fitt ist in Sachen Zeiger.

STF-DIR

Hallo,

na dann hab ich ja doch was verstanden ...

Na wie gesagt, es geht mir nur darum das ich das verstehe. Ob das nun einen Sinn hat und ob man das wirklich braucht ist eine andere Sache.

Warum das letztere nicht geht bekomm ich auch noch raus

Werd es Euch dann auch wissen lassen.
Vielleicht schreibt ja wirklich einer der C kann hier nochmal was

Dank Euch erst mal allen ganz doll !!!
Matthias

Knuddlbaer

Tip:

Die Frage rund um die Zeiger wäre im C Forum bessser aufgehoben.

WEr hier landet hat meist mehr mit OOP am Hut und da wird man etwa Zeigerträge