char Variable Verständnis problem

STF-DIR

Hallo,

sorry wenns ne dumme frage wird, aber ich versteh hier was mit den Variablen nicht. ( ich fang gerade mit C++ an !!! )

Also folgendes :
Ich bin bei minem Tutorial gerade bei den Variablen angekommen.
Das gibt ja nun ne Menge davon und die sollte man schon richtig verstehen. Ich kapier das mit den Wertebereichen aber nicht so ganz.

z.B. char :

Laut Visual Studio 2005 Hilfe 1 byte und wertebereich -128 bis +127.
Dache ich mir ok .. probieren
Console Programm win32

char charVar = -127;
cout << charVar << endl;

hmm, da kommt ein 'ü' raus ???? Hä ???

Hat das irgendwas mit der ASCII Tabelle zu tun ?
Aber da gibts doch keine negativen Zahlen drin ?

Kapier ich nicht .... könnt ihr mir da mal helfen ?

genau diese __int8 von MS:

__int8 iVar = 8;
cout << "iVar: " << iVar << endl;

da kommt erst mal gar keine Ausgabe.
Ich möchte das aber ganz genau verstehen damit ich später damit keine Probleme habe und irgendwelche Variablen Werte annehmen von denen ich keine Ahnung habe.
Das könnte schwierig werden.

Also bitte ich Euch um Hilfe
Danke
MAtthias

Char ist ein Datentyp für Zeichen. In C++ missbraucht man ihn aber öfter um kleine Zahlen zu speichern. Von daher müsstest du in der Ausgabe nach irgend nen Ganzzahltyp casten um wirklich ne Zahl rauszubekommen.

Noch ne Anmerkung: Programmierst du wirklich unmanaged(ich sag mal normales C++) oder managed C++ bzw. heißts ja ab .Net 2.0 C++/CLI mit dem .Net Framework? Weil im zweiteren Fall ist ein char 2 Byte groß, weil Unicode, und nicht nur 1 Byte.

STF-DIR

Hallo,

danke für die Erklärung erst mal ...also ein ein-ZeichenTyp .. ok soweit erst mal.

Zu dem anderen .. darüber hab ich auch schon gesimpelt.
Also ich mach das heir erst mal alles nach diesem Tutorial. Allerdings its das in englisch. Ich versth zwar das meiste, aber manches eben auch nicht .

( falls falsch bitte bitte berichtigen !! )

So, ich arbeite hier also mit MS Visual C++ 2005. Das dürfte .Net sein ?

Derzeit steht in dem Tut ich soll ne "CLR-Console Application" erstellen.Das dürfte dann managed code sein oder ?

Sieht so aus :

// EX2_12.cpp: Hauptprojektdatei.

#include "stdafx.h"

using namespace System;

int main(array<System::String ^> ^args)
{
    Console::WriteLine(L"Hello World");
    return 0;
}

Einige Kapitel weiter vorne sollte ich eine Win32-Console Application erstellen.
Die schaute natürlich ein bischen anders aus.

Was ist denn nun was ?
Was gibts da noch für Unterscheide ?

Matthias

ps : das hier

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

gibt mit eine 1 ( eins ) zurück, also 1 byte.
Das ist doch aber eine CLR Console Anwendung und in dem TUT steht auch was von .NET. Warum sind es dann nicht 2 byte ?
Hä ??

STF-DIR schrieb:

ps : das hier
Console::WriteLine("Size: " + sizeof(char));
gibt mit eine 1 ( eins ) zurück, also 1 byte.
Das ist doch aber eine CLR Console Anwendung und in dem TUT steht auch was von .NET. Warum sind es dann nicht 2 byte ?
Hä ??

"Size: " ist vom Typ const char *, also ein Zeiger. sizeof(char) gibt 1 zurück, du inkrementierst den Zeiger (auf die Adresse vom Literal "Size: ") um eins, er zeigt nun auf "ize: ". Unter .NET wird aber nicht direkt mit solchen Zeigern gearbeitet, WriteLine ist nicht auf const char * überladen. Es findet eine implizite Konvertierung nach bool (System::Boolean) statt, da diese nach C++-Semantik am ehesten in Frage kommt. Weil dein Zeiger nicht auf Null zeigt, wird der Wert auf True gesetzt, was einem Wert ungleich Null, in deinem Fall 1 ist. Willst du aber die Grösse eines char ausgeben, schreibst du:

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

Das mag sehr komisch wirken, aber sobald du einmal das System dahinter begriffen hast, wirst du deine Freude daran haben.

PS: Habe auch deine andere Frage beantwortet.

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