4. char-Array mit String initialisieren

char-Array mit String initialisieren

  • V

    Ich will ein char-Array mit einem String initialisieren. Warum geht das so nicht:

    int array[1000];

    array[] = "abcdefg";

    Könnt ihr mir helfen?

    0
  • C

    Initialisierungen funktionieren nur, wenn man sie direkt bei der Definition der Variablen angibt - also char array[1000] = "abcdef"; . Alles, was danach passiert, ist eine Zuweisung und folgt anderen Regeln. Wenn due diese Initialisierung nur einmal brauchst, dann mach es sofort (s.o), wenn du das Array öfter zurücksetzen willst, schau dir mal strcpy() an.

    0
  • V

    Ich hab hier ein kleines Programm:

    Ich möchte mir nun den Inhalt des arrays in der Funktion print() ausgeben lassen. Ich bekomme aber nur 10 mal so ein komisches Zeichen...

    #include<iostream>
#include"stack.h"
using namespace std;

void print(char* stack)
{
	for(int i=1; i<10; i++)
	{
		char zeichen = stack[i];
		cout << zeichen << endl;
	}
}

int main()
{
	char stack[10] = {"abcdefg"};

	stack[0] = 0;	//initialisierung des Stacks im Element 0 mit 0
	for(int i=1; i<10; i++)		//initialisierung als leerer Stack: §-Zeichen symbolisiert leeres Element
	{
		stack[i] = '§';
	}

	print(stack);

return 0;
}
    0
  • V

    Hm, is schon klar, wenn ich mir nach der array-Initialisierung das array mit der for-Schleife dann mit den §-Zeichen überschreibe 🙂

    Was hat denn die Funktion strincopy mit der Initialisierung von arrays zu tun die nicht mehr bei der Deklaration stehen?

    0
  • C

    vip@r schrieb:

    Was hat denn die Funktion strincopy mit der Initialisierung von arrays zu tun die nicht mehr bei der Deklaration stehen?

    Wenn du nach der Definition etwas in die Variablen reinschreiben willst, ist das keine Initialisierung mehr, sondern eine Zuweisung (sagt ich aber schon). Bei skalaren Werten wird für beides das = verwendet, aber bei Arrays ist die Zuweisung nicht erlaubt, da kannst du nur jedes Element einzeln zuweisen. Funktionen wie strcpy() oder memset() sind nur Abkürzungen für diese elementweisen Zuweisungen.

    PS: Hat dieses Gemisch aus C und C++ einen tieferen Sinn?

    0
  • V

    Nein, diese Gemisch hat keinen tieferen Sinn; können wir uns darauf einigen dass darüber hinweg siehst? 🙂

    #include<iostream>
#include"stack.h"
using namespace std;

void testfunktion(char* stack)
{
	char test_string[8] = {"0abcdef"};

	strcpy(stack, test_string);

	int i=0;
	char zeichen;

	while(stack[i] != '\0');
	{
		zeichen = stack[i];
		cout << zeichen << endl;
		i++;
	}
}

int main()
{
	char stack[1000];

	stack[0] = 0;				//initialisierung des Stacks im Element 0 mit 0
	for(int i=1; i<1000; i++)		//initialisierung als leerer Stack: \0-Zeichen symbolisiert leeres Element
	{
		stack[i] = '\0';
	}

	testfunktion(stack);

return 0;
}

    Ich hab hier nun das Problem, dass ich in der Testfunktion mein Stackarray nicht richtig ausgeben kann.

    Die Funktion strcpy() kopiert mir ja den test_string in stack. Kürzt die Funktion strcpy() dann den stack auf die Elementanzahl welche in test_string steht?

    Ich möchte quasi den gesamten Inhalt nach strcpy() auf dem Bildschirm sehen. in der Art: 0abcdef

    Genau das geht aber nicht... Ich sehe gar nichts.

    0
  • V

    Hab den Fehler selber gefunden; ein falsche ; war drin...

    0
  • C

    vip@r schrieb:

    Nein, diese Gemisch hat keinen tieferen Sinn; können wir uns darauf einigen dass darüber hinweg siehst? 🙂

    Normalerweise nicht, aber für dich mache ich mal eine Ausnahme 😃
    (aber du solltest dich trotzdem mal mit den C++ Methoden vertraut machen, deine Probleme zu lösen.

    Die Funktion strcpy() kopiert mir ja den test_string in stack. Kürzt die Funktion strcpy() dann den stack auf die Elementanzahl welche in test_string steht?

    Das Array verkürzen ist gar nicht möglich, aber strcpy() kopiert inklusive Null-Terminator. Übrigens kannst du als Quelle auch String-Literale angeben, da ist der Umweg über ein lokales Array nicht notwendig: strcpy(stack,"0abcdef");

    Und abgesehen von der Endlos-Schleife, die du in Zeile 16 fabriziert hast (so ein Semikolon an der falschen Stelle kann schon ärgerlich sein :D) sieht dein Programm auch in Ordnung aus.

    0
  • V

    Danke!

    Ich will hier quasi einen Stack nachprogrammieren. Ich hab hierzu mal eine header-Datei eine main.cpp und eine stack.cpp Datei angelegt. Wenn du willst kann ich's ja mal posten:

    Header-Datei:

    #ifndef STACK_H
#define STACK_H

void pop(char* stack);
int isEmpty(char* stack);
char top(char* stack);
int stackSize(char* stack);
void push(char* stack, char c);
void clear(char* stack);
void print(char* stack);

#endif STACK_H

    stack.cpp:

    #include<iostream>
#include"stack.h"
using namespace std;

//Löscht das oberste Element und aktualisiert den Zeiger auf das oberste Element
void pop(char* stack)
{
	int zeiger;

	zeiger = stack[0];
	zeiger = zeiger - 48;		//"echten" Zeigerwert berechnen

	if(stack[zeiger] != 0)		//oberste Position löschen
	{
		stack[zeiger] = '\0';
	}

	stack[0] = zeiger + 48 - 1;		//"neuen echten" Zeigerwert berechnen und in Initial-Element schreiben
}

//Liefert 1, wenn der Stack leer ist; ansonsten 0
int isEmpty(char* stack)
{
	if(stack[1] == '\0')
	{
		return 1;		//Wenn erstes Nicht-Initial-Element gleich \0 ist -> 1 zurückgeben
	}
	else
	{
		return 0;		//Ansonsten 0 zurückgeben
	}
}

//Liefert das oberste Element des Stacks ohne es zu löschen
char top(char* stack)
{
	int zeiger;

	zeiger = (stack[0]-48);		// (char-Zahl wird umgerechnet!)

	return (stack[zeiger]);
}

//Liefert die Anzahl der Elemente auf dem Stack
int stackSize(char* stack)
{
	return (stack[0]-48);		//Hier muss die char-Zahl umgerechnet werden
}

//Fügt einen neuen Wert zum Stack hinzu, in dem es den Wert
//auf das bisher oberste Elemente legt und den Zeiger auf das
//oberste Element aktualisiert
void push(char* stack, char c)
{
	int zeiger;

	zeiger = stack[0];		//aktuelle Position des obersten Elements auslesen (char-Zahl)
	zeiger++;				//Zeiger um eine Position erhöhen
	stack[0] = zeiger;		//Neuen Zeigerwert in Initial-Element schreiben

	stack[zeiger-48] = c;		//Übergebenes Zeichen auf Stack pushen  (char-Zahl wird umgerechnet!)
}

//Löscht den gesamten Stack und setzt den Zeiger auf das oberste Element zurück auf 0
void clear(char* stack)
{
	int zeiger;

	zeiger = stack[0];		//Zeiger Position des obersten Elements setzen

	for(int i=1; i<=(zeiger-48); i++)		//Stack löschen (char-Zahl wird umgerechnet!)
	{
		stack[i] = '\0';
	}

	stack[0] = '0';		//Initial-Element auf 0 zurücksetzen
}

//Gibt den Inhalt des Stacks von Initial-Element 0 bis oberstes Element auf dem Bildschirm aus

void print(char* stack)
{
	int i=0;
	char zeichen;

	while(stack[i] != '\0')
	{
		zeichen = stack[i];
		cout << zeichen;
		i++;
	}
	cout << endl;
}

    main.cpp:

    #include<iostream>
#include"stack.h"
using namespace std;

void testfunktion(char* stack)
{
	print(stack);

	cout << "liefert 1, da Stack leer ist: " << isEmpty(stack) << endl;

	cout << "liefert die momentane Anzahl der Elemente im Stack: " << stackSize(stack) << endl;

	char c = 'T';
	push(stack, c);
	print(stack);
	c = 'o';
	push(stack, c);
	print(stack);
	c = 'b';
	push(stack, c);
	print(stack);
	c = 'i';
	push(stack, c);
	print(stack);

	cout << "liefert die momentane Anzahl der Elemente im Stack: " << stackSize(stack) << endl;

	cout << "Liefert das oberste Element des Stacks: " << top(stack) << endl;

	pop(stack);
	print(stack);

	cout << "Loescht den gesamten Stack: ";
	clear(stack);
	print(stack);
}

int main()
{
	char stack[1000];

	stack[0] = '0';				//initialisierung des Stacks im Element 0 mit 0
	for(int i=1; i<1000; i++)		//initialisierung als leerer Stack: \0-Zeichen symbolisiert leeres Element
	{
		stack[i] = '\0';
	}

    testfunktion(stack);

return 0;
}
    0
  • C

    Ich würde den Stack auf jeden Fall nicht mit ungeprüften char-Arrays verwenden - besonders da push() keine Möglichkeit hat zu überprüfen, ob auf dem dahinterliegenden Array genug Platz ist. Genauso witzlos ist es imho, die Stack-Größe im nullten Array-Element unterzubringen (schon wegen Problemen mit Overflow).
    Wenn du tatsächlich mit C-Mitteln arbeiten willst, dann pack das char-Array (oder einen char-Zeiger*) zusammen mit der aktuellen und maximalen Größe in eine struct. Mit C++ würde ich das ganze inklusive der Verarbeitungsfunktionen in eine Klasse verpacken (oder gleich std::stack<> verwenden).

    * wobei die Stack-Funktionen dann bei Bedarf mehr Speicherplatz anfordern können.

    0
Anmelden zum Antworten