ich hätte da nun auch mal einige Fragen zu Strings und Char-Arrays.

1.Beispiel:

const int GR = 10000;
char rohstring[GR]
file.getline(rohstring,GR);

So habe ich ja hier ja quasi einen Eingabepuffer mit fester Größe.

Nehme ich aber so etwas:

std::string rohstring;
getline(file,rohstring)

Da habe ich ja nun einen String, der ja größendynamisch ist, also seine Größe je nach dem was man reinpackt dynamisch anpasst.

Wenn also nun in der Datei Zeilen mit 1000 bis 8000 Zeichen Länge sind, so ist die obere Variante ein wenig Speicherintensiver und eventuell sogar zu gross gewählt, während die string Variante ja immer den exakten Speicher für die aktuelle Zeile belegt.
Aber leidet dann nicht auch ein wenig die Performance, was sich dann bei 70000 Zeilen vielleicht auch stark bemerkbar macht weil der String ja ständig in seiner Größe rauf und runter pendelt?
Was sagen die Experten?

2.Beispiel:

struct Buecher
{
char sku[10];
char stichwort[150];
char titel[350];
char utitel[350];
char autor[150];
char auflage[120];
char verlag[120];
char format[120];
char seiten[60];
char jahrT[20];
char einband[50];
char zustandT[350];
char zustandZ[30];
char gewichtT[10];
char dataender[25];
char daterstell[25];
char preisT[10];
char sprache[30];
char isbn[20];
char amakat[100];
char isbn13[20];
char intinfo[150];
char mengeT[5];
char sach1[300];
char exportT[10];
}buch[200000];

Hier ist eine ziemlich fette Struktur, die dazu dient, 200000 Buecher mit ihren Daten wie Titel, Verlag, Autor usw. aufzunehmen.
(Mittlerweile arbeite ich mit einer Dateigepufferten Variante. Ich lese also nicht mehr alle Bücher ein, sondern hole mir immer den relevanten Datensatz aus der Datei) Aber mich würde trotzdem mal an dem Beispiel mit den 200000 Buchstrukturen interessieren inwie hier nun die String Variante besser ist.

struct Buecher
{
std::string sku;
std::string stichwort;
std::string titel;
.
.
}buch[200000];

Im char Beispiel habe ich ja bei 200000 Datensätzen eine wahnsinnige Speicherverschwendung, weil ja alle Strukturelemente in der Größe festgesetzt sind und demnach kürzere Texte viel zu viel Platz im Array haben.
Auch ist es erforderlich, zuerst die maximale Länge des größten Datensatztes durchzumessen, um zu wissen, welche Größe man ungefähr wählt, man möchte ja noch ein wenig Sicherheit nach oben.

Bei std::strings würde sich das doch alles erübrigen oder?
Die nehmen immer die Länge an, die sie brauchen und verschwenden nicht soviel Speicher.
Ist das wirklich so? Dann wären std::strings ja dem normalen char Array völlig überlegen. Oder haben diese super intelligenten Textspeicher auch unangenehme Nachteile?

Wäre mal über ein Aufklärung und Meinungen sehr erfreut.
(Habe mich bisher immer vor std::strings ferngehalten, weil die mir nicht so geheuer waren)

Gruß,
DC

r.
Ist das wirklich so? Dann wären std::strings ja dem normalen char Array völlig überlegen.

Du hast es erfasst. Und auch begründet. Und noch viele weitere Gründe gar nicht erwähnt.

Oder haben diese super intelligenten Textspeicher auch unangenehme Nachteile?

Sie sind ein bisschen langsamer. Was eher selten ins Gewicht fällt, weil Stringverarbeitung selten Performancerelevant ist. Der Performanceverlust spielt jeweils an den Stellen eine Rolle wo man die Zusatzfeatures des Strings benutzt, eben wie beim besagten Einlesen. Würde man den gleichen Effekt nachbauen, indem man char-Arrays dynamisch anlegt, hätte man bei beiden die gleiche Laufzeit.

Ich werde mich dann mal intesiver mit std::string Klasse beschäftigen.

Nur was ist, wenn ich nun sowas hier habe:

char *bigbuffer = new char[VeryVeryBig];

(Wie prüfe ich hier eigentlich, ob das System mir auch Speicher gibt?)

Aber angenommen, ich fordere Speicher für einen Riesigen Text an, das System gibt ihn mir und ich kann auch prüfen, daß ich ihn bekommen habe, dann bin ich hier doch auf der sicheren Seite.

Wenn ich aber dann:

std::string *bigbuffer = new std::string;

Dann habe ich zum Einen, keine Größenangabe für die Reservierung und zum Zweiten wäre das doch total unsinnig, weil diese obige Definition ja identisch mit:

std::string bigbuffer;

wäre.

Und wenn ich nun einen Text mit der Länge VeryVeryBig einfach mal in diesen String packe, dann wäre das ja wieder Hammermethode, nach dem Motto, wird schon passen.
Wahrscheinlich gibt es aber Klassenfunktionen, mit denen ich meinem String eine Minimalgröße verpassen kann und auch prüfen, ob der Speicher vorhanden ist, aber aufgrund der Dynamik in der Größe könnte es doch dann irgendwann doch nicht mehr passen?

Naja, ich werde mich mal in den nächsten Tagen mehr mit der C++ Klassenbibliothek befassen. (Hatte bisher kein anständiges Buch. Nun bekomme ich übermorgen den C++ Programmierer geliefert. Uhhh, teuer.. )
(Aber immer nur C++ für Dummies als einziges C++ Buch, das erweitert nicht wirklich den Programmierhorizont)

Aber wie dem auch sei, sobald ich mehr Erfahrung mit der string-Klasse gemacht habe, erschließen sich mir wahrscheinlich auch einige Dinge, so daß sich solche Fragen wie die bisherigen erübrigen, aber ein wenig SmallTalk ist auch mal schön...

Und dieser Größendynamik, ich weiß nicht, ist mir nicht so ganz geheuer..
!!!Das ist Hexenwerk.....!!! !!Verbrennt die String-Klasse...!!

Gruß,
DC

std::string *bigbuffer = new std::string;

Dann habe ich zum Einen, keine Größenangabe für die Reservierung und zum Zweiten wäre das doch total unsinnig, weil diese obige Definition ja identisch mit:

...dann hättest du einen Zeiger auf ein std::string-Objekt, ja.
std::string macht intern den ganzen Firlefanz mit new usw. für dich! Das ist doch das Feature von der Klasse. Der nimmt dir das alles ab, mit den Tests, ob etwas passt, ob mehr Speicher gebraucht wird, etc.
Du kannst in einen std::string soviel reinpacken, wie dein PC bzw. dein Adressraum zulässt. D.h. bei std::string stürzt es nicht ab, weil der String zu lang ist, sondern weil dein PC zu wenig Speicher hat, sozusagen.
Missverstehe std::string nicht als eingebauten Typ! Das ist eine C++ Klasse. Dass man ihren Objekten Stringliterale ( "asfafs" ) zuweisen kann, liegt an impliziten Konvertierungen und Operatoren und Konstruktoren.

Muß ich mir einbläuen... Es ist eine Klasse und kein Typ....

Gruß,
DC

string a; // Objekt a vom Typ String

Was sollen Klassen sonst sein?

Und das schöne an C++ ist auch, das sich die Klassen so konstruieren lassen, das sie sich sogar wie eingebaute Typen anfühlen. Dafür ist Operator-Überladungen da.

Im inneren der String-Klasse wird natürlich alles versteckt, und es ist am Ende kein Hexenwerk, sondern normales C++. Aber interessiert das wirklich? So lange die Klasse so arbeitet, wie vorgesehen, ist das irrelevant, ob C++-new oder Assemblercode in der Klasse steht.

#include <fstream>
#include <sstream>

std::string ReadFromFile(std::string name)
{
    std::ifstream input;
    input.open(name.c_str());
    if(!input.is_open())
    {
        return "";  //hier sollte man evtl. eine Exception werfen
    }
    std::ostringstream filecontent_stream;
    filecontent_stream << input.rdbuf();
    input.close();
    return filecontent_stream.str();
}

An die Grenzen von std::string stößt du eigentlich erst dann, wenn du Unicode verwenden willst.

Gruß,
DC