in meinem header hab ich mir

struct MenuItem
{
	char *Caption;
	TEXT_ALIGN text_align;
	byte color;
};

dass zusammen gebastelt

in der cpp datei steht das :

void SceneManager::DrawBox(int x, int y, int w, int h,byte BorderColor,int nItems,MenuItem *Items)
{
	char corner[4] = {201,187,200,188};
	char line[2] = {205,186};
	COORD coord = {x,y};
	SetConsoleCursorPosition(hConsole,coord);
	//Kasten dravvn
	SetConsoleTextAttribute(hConsole,BGColor|BorderColor);
	printf("%c",corner[0]);
	DrawLine(line[0],BorderColor,w-2);
	printf("%c\n",corner[1]);
	for (int i = 0;i<h;i++)
	{
		coord.X = x;
		coord.Y = y+1+i;
		SetConsoleCursorPosition(hConsole,coord);
		printf("%c",line[1]);
		DrawLine(' ',BorderColor,w-2);
		printf("%c\n",line[1]);
	}
	coord.X = x;
	coord.Y = y+h+1;
	SetConsoleCursorPosition(hConsole,coord);
	printf("%c",corner[2]);
	DrawLine(line[0],BorderColor,w-2);
	printf("%c\n",corner[3]);
	for (int i = 0;i<(nItems-1);i++)
	{
		SetConsoleTextAttribute(hConsole,BGColor | Items[i].color);

		if (Items[i].text_align == ALIGN_CENTER)
		{
			coord.X = (x+(w/2))-(strlen(Items[i].Caption)/2);
			coord.Y = y+1+i;
			SetConsoleCursorPosition(hConsole,coord);
			printf("%s",Items[i].Caption);
		}
		else if (Items[i].text_align == ALIGN_RIGHT)
		{
			coord.X = (x+w-1)-(strlen(Items[i].Caption));
			coord.Y = y+1+i;
			SetConsoleCursorPosition(hConsole,coord);
			printf("%s",Items[i].Caption);
		}
		else
		{
			coord.X = x+1;
			coord.Y = y+1+i;
			SetConsoleCursorPosition(hConsole,coord);
			printf("%s",Items[i].Caption);		
		}
	}

}

Nun hab ich aber ein problem :
main

MenuItem m[2];
	m[1].text_align= ALIGN_CENTER;
	m[1].Caption="Test";
	m[1].color=COLOR_GREEN;

	smgr->DrawBox(2,3,60,20,COLOR_BLUE,1,m);

nun sollte als erstes element eig test kommen , das tut es aber nicht :|
Was mach ich falsch.

Ich bitte die die mir wircklich helfen wollen , eine kleine erklärung zu schreiben wenn möglich.
Dankeschön

Und gleich sagt dir jemand (voraussichtlich Nutzer 3.1415...), dass dein C++ wahnsinnig schlecht ist, aber ich habe dazu jetzt keine Zeit das groß zu erläutern.

z.B:

m[0].color=COLOR_BLUE;

muss ich dann auch bei dem funktions aufruf m[0] statt m einsetzen ?

Also das heißt das ich immer bei 0 anfange und in diesen speicher schreibe ?

z.B:

m[0].color=COLOR_BLUE;

Ja, das heißt es (btw, im Inneren der Funktion wendest du die Indizes halbwegs korrekt an)

muss ich dann auch bei dem funktions aufruf m[0] statt m einsetzen ?

Nein, mußt du nicht - m[0] ist das erste Array-Element, m bezeichnet das komplette Array (und wird vom Compiler bei Bedarf in einen Zeiger auf den Array-Anfang umgewandelt).

Dankeschöne

Eine Variable ist ein einzeln stehender Wert, den du über seinen Namen ansprechen kannst, z.B. int x .
Ein Array ist eine Sammlung von mehreren identisch aufgebauten Werten unter einem gemeinsamen Namen (z.B. ist m der Name für eine Gruppe von zwei structs). Um zu unterscheiden, welchen dieser Werte du ansprechen willst, verwendet man den Index-Operator - mit m[i] greifst du auf das i-te Element zu (von 0 an gezählt).
(Zeiger sind wieder etwas anderes, sie enthalten die Adresse einer anderen Variablen. Aber sie bieten ebenfalls einen Index-Zugriff an, der davon ausgeht, daß der Zeiger nicht auf eine alleinstehende Variable verweist, sondern auf ein Element eines Arrays.)

& operator

macht.Schreibt er jetzt die adresse eines poiters wo anders rein oder den speicher oder was anders ? In meinem buch ist das ganze mit einem klassen bsp dargestellt :

Klasse MeineKlasse;
Klasse* meineKlassepointer = &MeineKlasse;

?
Ich denke mein buch ist doch nicht so gut wie es angepriesen war , denn ich hab im internet rumgeschaut und da sah es einfacher aus.

PS: Das buch heißt C++ echt einfach von Franzis verlag und geschrieben von oliver böhm.Eig find ich es ganz nett , doch ist es nicht sehr anfänger freundlich , meiner meinung nach

Ahh ok.
Ich habe jetzt in meinem buck etwas weiter gelesen doch nicht so ganz verstanden was der

& operator

macht.Schreibt er jetzt die adresse eines poiters wo anders rein oder den speicher oder was anders ? In meinem buch ist das ganze mit einem klassen bsp dargestellt :

Klasse MeineKlasse;
Klasse* meineKlassepointer = &MeineKlasse;

Kurzfassung: Der Operator ermittelt die Adresse einer Variablen, als Umkehrung dazu gibt es auch noch den * Operator, der den Wert hinter einem Zeiger holt:

int i = 4711;
int* p = &i; //p bekommt die Adresse von i zugewiesen
*p = 42;     //Dereferenzierung - greife auf den Wert zu, dessen Adresse in p steht (d.h. indirekt auf i)

(außerdem gibt es noch den Typ-Modifizierer^(?) & für Referenzen und den binären & Operator (bitweise UND-Verknüpfung))

Sich nur den Zeiger auf einen string zu merken wird mit Sicherheit auch zu Problemen führen, wenn die Lebenszeit des zugewiesenen Strings abläuft, denn dann hast du einen Zeiger auf einen nicht mehr existierenden String -> Rumms!
Am besten ersetzt du char* Caption durch std::string Caption .

Sich nur den Zeiger auf einen string zu merken wird mit Sicherheit auch zu Problemen führen, wenn die Lebenszeit des zugewiesenen Strings abläuft, denn dann hast du einen Zeiger auf einen nicht mehr existierenden String -> Rumms!
Am besten ersetzt du char* Caption durch std::string Caption.

Er weist direkt ein zur Compilezeit bekanntes Stringliteral zu, da wird nichts scheppern und er darf sich gerne den Umweg über den Heap sparen.

Sich nur den Zeiger auf einen string zu merken wird mit Sicherheit auch zu Problemen führen, wenn die Lebenszeit des zugewiesenen Strings abläuft, denn dann hast du einen Zeiger auf einen nicht mehr

Auch wenn das , wie die anderen sagen nicht stimmt (ich wieß es nicht) würde ich gerne wissen was man damit meint.Wann genau läuft die "Lebenszeit" ab und auch wie ?

Wann genau läuft die "Lebenszeit" ab und auch wie ?

// Automatisch (char-Array): Bis ans Ende der Funktion
char array[] = "text";

// Dynamisch: Bis zur expliziten Freigabe
char* ptr = new char[5];
std::strcpy(ptr, "text");
delete[] ptr;

// Statisch (Zeiger auf Stringliteral): Bis Programmende
const char* ptr = "text";

// Automatisch (std::string): Bis ans Ende der Funktion,
// kann aber kopiert werden; Text bleibt somit gültig
std::string str = "text";

Nehmt statt der char -Array-Frickelei einfach std::string , es sei denn ihr habt einen guten Grund es nicht zu tun. Besser als "ich habe gehört std::string sei langsam"...

Sich nur den Zeiger auf einen string zu merken wird mit Sicherheit auch zu Problemen führen, wenn die Lebenszeit des zugewiesenen Strings abläuft, denn dann hast du einen Zeiger auf einen nicht mehr existierenden String -> Rumms!
Am besten ersetzt du char* Caption durch std::string Caption.

Er weist direkt ein zur Compilezeit bekanntes Stringliteral zu, da wird nichts scheppern und er darf sich gerne den Umweg über den Heap sparen.

Das meinst du jetzt nicht ernst, oder?

Ethon schrieb:

Sich nur den Zeiger auf einen string zu merken wird mit Sicherheit auch zu Problemen führen, wenn die Lebenszeit des zugewiesenen Strings abläuft, denn dann hast du einen Zeiger auf einen nicht mehr existierenden String -> Rumms!
Am besten ersetzt du char* Caption durch std::string Caption.

Er weist direkt ein zur Compilezeit bekanntes Stringliteral zu, da wird nichts scheppern und er darf sich gerne den Umweg über den Heap sparen.

Das meinst du jetzt nicht ernst, oder?

Doch.

Schau mal seinen Code an:

m[1].Caption="Test";

"Test" sitzt in .rdata und bleibt da auch bis zum Programmende, also passt das so.

Zu char* mit manueller Speicherverwaltung besteht in C++ unter normalen Umständen kein Anlass.

Also so wie es aussieht in dem fall ist eine Zeichenkette angebracht.

Eine weise Erkenntnis, doch was für eine Zeichenkette?