Strings in C++

sheddy

Hi,

ich habe mal ein paar Fragen zu strings bzw. chars in C++.

Ich habe z.b. dieses in einer Klasse in der header-datei:

private:
	char *marke;

Dazu mache ich einen Konstruktor:

public:
	PKW(char = "Mercedes", unsigned long = 0, unsigned int = 100);

So, das funktioniert schon mal nicht! Ich weiß aber nicht warum.

Dazu kommt noch, dass ich nicht weiß, wie ich jetzt dem char eine Wort zuweise.

Bei der Funktiondefinition in der eigentlichen .cpp habe ich dann z.b. sowas:

PKW::PKW(char a_name, unsigned long a_nr, unsigned int a_lst)
{
	strcpy(marke,a_name);
	fgstnr=a_nr;
	leistung=a_lst;

	cout << "Pkw der Marke "<< marke
		<< " mit Fahrgestellnummer " << fgstnr
		<< " und Leistung "<< leistung
		<< " erzeugt\n";
}

Gibt alles Fehler. Ich weiß einfach nicht, wie ich mit chars bzw. strings umgehen soll.

Das hier:

char *marke;

ist doch ein Zeiger auf einen String bzw. auf das erste Zeichen eines Char-Array, oder?! Woher weiß man wieviel Zeichen es aufnehmen kann?

Danke im vorraus

gruß sheddy

Entweder du schaust dir nochmal die Grundlagen zu arrays an oder du verwendest std::string und std::vector. Da gibts die Länge/Größe usw. kostenlos^1* dazu.

~1* Angebot gilt nur so lange der Vorrat reicht.~

sheddy

Ich kann die Grundlagen.

Aber ich tue mich mit "char *marke" schwer.
Bin neu in C++!
Wie bekomme ich dort einen String rein?

char* marke ist ein Zeiger, richtig. Wieviel Zeichen es aufnehmen kann, hängt davon ab, wieviel Speicher da dafür vom Betriebssystem anforderst. Weil ein Zeiger zeigt ja auf einen Speicherbereich. Das macht man mittels new.
http://tutorial.schornboeck.net/dyn_speicher.htm
Dieser Artikel kann dir hier weiterhelfen.

Im Fall deines Konstruktors:

PKW(char = "Mercedes", unsigned long = 0, unsigned int = 100);

Kann nicht gehen, weil char nur ein einzelnes Zeichen ist.
So wärs richtig:

PKW(char* _marke = "Mercedes", unsigned long a= 0, unsigned int b= 100)
{
   int memory_size =sizeof(char)*strlen(_marke);
   marke = new char[memory_size];
   strcpy(marke, _marke);
}

// Den speicher müssen wir beim beenden auch löschen
PKW::~PKW()
{
  delete [] marke;
}

Wir arbeiten aber mit C++:

class PKW{

std::string marke;

PKW(std::string _marke = "Mercedes", unsigned long a = 0, unsigned int b=100)
{
  marke = _marke;
}
}

edit bevor nen Schlaumeier kommt:

class PKW{

std::string marke;

PKW(std::string _marke = "Mercedes", unsigned long a = 0, unsigned int b=100) : marke(_marke)
{

}
}

So gehts auch, per initialisierungsliste
rya.

Badestrand

sheddy schrieb:

PKW(char = "Mercedes", unsigned long = 0, unsigned int = 100);

Sowas hab ich noch nie gesehen, kompiliert das wirklich

sheddy schrieb:

Das hier:
char *marke;
ist doch ein Zeiger auf einen String bzw. auf das erste Zeichen eines Char-Array, oder?! Woher weiß man wieviel Zeichen es aufnehmen kann?

Richtig, das ist ein Zeiger auf einen Char oder mehrere Chars. Das Ding ist, dass es eben nur ein Zeiger ist, der so halt erstmal auf garnix zeigt. Damit du "hinter dem Zeiger" auch sinnvoll Zeichen speichern kannst, muss der Zeiger irgendwohin zeigen, wo auch Speicherplatz für deine Zeichen reserviert ist. Das macht man normalerweise mit "new". Damit reserviert man ein Stück Speicher, die Funktion "new" gibt dabei den Zeiger auf den Speicher zurück. Deinen Zeiger kannst du dann auf diesen Bereich zeigen lassen und schon kannst du Zeichen in den Speicher beim Zeiger schreiben, bzw daraus lesen.
Mit "new char [100]" reservierst du Platz für 100 Zeichen, du musst dir dabei halt immer selber merken, wieviel Platz du zur Verfügung hast. Mit "new char" reservierst du nur Platz für ein einzelnes Zeichen

*D*Evil

#include <cstring> // std::strlen, std::strcpy
#include <iostream> // std::cout

PKW::PKW(const char* name, unsigned long nr, unsigned int lst) : fgstnr(nr), leistung(lst)
{
    marke = new char[std::strlen(name) + 1];
    std::strcpy(marke, name);

    std::cout << "PKW der Marke " << marke
        << " mit Fahrgestellnummer " << fgstnr
        << " und Leistung "<< leistung
        << " erzeugt!" << std::endl;
}

PKW::~PKW() { delete [] marke; }

wenn du wirklich mit char-Array's arbeiten willst Das kannst du, wie hier schon erwähnt wurde, aber viel einfacher mit der Klasse std::string bekommen

@Scorcher24:

PKW(char* _marke = "Mercedes", unsigned long a= 0, unsigned int b= 100)
{
   int memory_size =sizeof(char)*strlen(_marke);
   marke = new char[memory_size];
   strcpy(marke, _marke);
}

Ehm deine Berechnung ist etwas merkwürdig. Das sizeof(char) hat da NICHTS zu suchen! Das sizeof(char) steckt schon in new char mit drin.
Des weiteren sollte _marke const sein ... typisches Merkmal einer schlechten Bibliothek. Ehm und ich hab noch keine negative Speichergröße gefunden, du?

class PKW{

std::string marke;

PKW(std::string _marke = "Mercedes", unsigned long a = 0, unsigned int b=100) : marke(_marke)
{

}
}

Hmm ... also das rum kopieren ist äußerst unschön C++ kennt Referenzen. Dann nur so als kleiner Hinweiß: du kannst auch einfach den Parameter marke (ohne führendes _) nenne. Der weiß was der da tun muss
Achja. So wirst du wenig Spaß beim erstellen von Instanzen deiner Klasse bekommen. Default-Privacy.

#include <string>

class PKW
{
    std::string m_marke;
    unsigned long m_fgstnr;
    unsigned int m_leistung;

public:
    PKW(std::string const& marke = "Mercedes", unsigned long fgstnr = 0, unsigned int leistung = 100) : m_marke(marke), m_fgstnr(fgsnr), m_leistung(leistung) {}
};

So hat das ganze auch Stil

Des weiteren sollte _marke const sein ... typisches Merkmal einer schlechten Bibliothek. Ehm und ich hab noch keine negative Speichergröße gefunden, du?

Was meinst du mit negativen Speichergrößen??
Und wegen const... ich hätte es auch const gemacht, ich hab nur an dem orientiert, was der TE geliefert hat....

Das sizeof(char) hat da NICHTS zu suchen! Das sizeof(char) steckt schon in new char mit drin.

Na gut..

Achja. So wirst du wenig Spaß beim erstellen von Instanzen deiner Klasse bekommen. Default-Privacy.

Jetzt häng dich halt an dem fehlenden public auf omg, wenn man hier mal kurz ein Beispiel reintippt. Das sollte jeder der hier fragt, automatisch wissen, wann private und public zum Einsatz kommen, ausser man fragt explizit danach. Aber das hab ich in diesem Board eh schon gemerkt, dass man auf so Kleinigkeiten gern rumreitet $:\$
rya.

Badestrand

Scorcher24 schrieb:

Aber das hab ich in diesem Board eh schon gemerkt, dass man auf so Kleinigkeiten gern rumreitet $:\$

Glaub mir, irgendwann ignorierst du solche Kleinigkeit-anfechtenden Posts einfach
Das mit der negativen Speichergröße bezog sich glaubich darauf, dass du einen (signed) int für memory_size genommen hast.. Womit wir wieder bei den Kleinigkeiten wären

sheddy

danke jungs! hat funktioniert!
ich versuche es mal mit std::string