Hallo ersteinmal
Ich beschäfftige mich mit der OO Programmierung, bin da leider etwas aus anderen Programmier- bzw Scriptsprachen "versaut"

Ich schreibe also ein Programm, dass aus verschiedenen Teilen/Modulen besteht.
Diese Teile habe ich alle in eigenen Klassen gepackt, da sie zueinander unabhängig sind, und nicht mit einander zu tun haben.

Nun habe ich aber auch noch einige eigene (Hilfs-)Funktionen (Zeichenkettenmanipulation, etc) die von alles Klassen verwendet werden.

Die Frage ist jetzt, was man das am besten mit solchen Funktionen macht? Erstellt man eine eigene Klasse??
Wie binde ich die am sinnvollsten in den einzelnen Klassen ein?

Bin da wirklich ratlos.

Grüße
Maddes

Es gibt Programmierer, die Utility-Klassen schreiben, um Hilfsfunktionen zu sammeln, aber das ist schlechter Stil und kommt aus Programmiersprachen, die keine eigenständigen Funktionen kennen. Es macht keinen Sinn etwas zusammen zu fassen, was nicht zusammen gehört.

Wenn Du die Funktionen irgendwie zusammenfassen möchtest, dann verwende Namensräume (namespace).

Tntnet

spricht doch nix dagegen, wenn du deine hilfsfunktionen in ne eigene datei schreibst oder also static members in ne klasse packst. dann bindest die ein, wenn du sie brauchst. vielleicht noch als template, damit du die funktionen spaeter auch fuer wide-strings verwenden kannst. wenn du reine funktionen machst, waere es unter umstaenden auch geschickt, diese in einen eigenen namespace zu legen, falls du mal fremde bibliotheken verwendest und die funktionsnamen schon vorhanden sein sollten. dann gibts wenigstens keinen aerger.
wuerd mich aber auch interessieren, wie es andere machen.

Meep Meep

Ich würde die Funktionen nicht als static-member in eine Klasse packen, weil es doch auch dafür namespaces gibt. Also eigenen namespace Funktionen rein und alles ist bgut.

chrische

Werds so machen!
Dachte erst, es wäre vllt nicht "genug objektorientiert"

Hab da gleich noch eine Frage.

eine Funktion

std::string foobar (std::string& foo) {

    machwas...

}

aufgerufen durch:

foobar(bla);

oder eine Funktion

std::string foobar (std::string foo) {

    machwas...
    return foo;

}

aufgerufen durch:

bla = foobar(bla);

Was ist "besser"?
Ich glaube das nennt man call-by-reference und call-by-value, richtig? *duck*

genau weiss ichs nicht

std::string foobar (std::string& foo) {

    machwas...

}

da hast doch auch einen rueckgabewert. da brauchst dann auch ein return.
ansonsten ist der rueckgabewert 'void'.

wie du das nun machst, haengt von der funktionalitaet deiner funktion ab.
soll der string manipuliert werden ? oder willst du nur eine kopie des manipulierten strings haben ? gibts viel moeglichkeit.
da muesstest schon ein konkretes beispiel geben, damit man sich dazu gendanken machen kann. oftmals werden von funktionen auch werte zurueckgegeben, die nur indirekt mit dem string zu tun haben.

Meep Meep

okay, Rückgabewert der ersten Funktion ist natürlich falsch. Wäre dann wahrscheinlich int mit 0 oder 1.

Ja, der String soll manipuliert werden.
Hier mal ein Beispiel.

Die Funktionen habe ich gestern geschrieben und da ist mir die Frage gekommen. Die sollen halt im string str - rep durch rep2 ersetzten:

int replace ( std::string& str, std::string rep, std::string rep2 ) {

	while ( str.find(rep) < 1024 )      // Workaround
	{
		str.replace( str.find(rep), sizeof(rep), rep2 );
	}	
    return 1;
}

bzw.

std::string replace ( std::string str, std::string rep, std::string rep2 ) {

	while ( str.find(rep) < 1024 )      // Workaround
	{
		str.replace( str.find(rep), sizeof(rep), rep2 );
	}	
    return std;
}

bitte nicht über die Funktionen lachen
Aber für ein Beispiel sind die denk ich gut geeignet.

int replace ( std::string& str, std::string rep, std::string rep2 ) {

    while ( str.find(rep) < 1024 )      // Workaround
    {
        str.replace( str.find(rep), sizeof(rep), rep2 );
    }   
    return 1;
}

aus laufzeitgruenden solltest di funktion etwas umschreiben:

int replace ( std::string& str, const std::string &rep, const std::string &rep2 ) {

    while ( str.find(rep) < 1024 )      // Workaround
    {
        str.replace( str.find(rep), sizeof(rep), rep2 );
    }   
    return 1;
}

sonst wird immer ne kopie angelegt.
in dem fall koennte man z.b. bool zurueckgeben, ob der string ueberhaupt gefunden wurde, der ersetzt werden soll. oder einen int mit der position, bzw. einen iterator, ab wo der string geaendert worden war.
eventuell eine referenz auf den veraenderten string selber zurueckgeben.
hab da wirklich keine ahnung was in dem fall sinnbringender waere.

Meep Meep

• sizeof(rep) liefert nicht die Stringlänge, sondern die Größe der String-Verwaltungsdaten (ein char* und ein paar size_t's)
• string::find() liefert npos zurück, wenn es nichts gefunden hat
• wenn rep ein Teil von rep2 ist, läufst du in eine Endlosschleife^(*)

Schau dir mal den Artikel "Stringverarbeitung in C++" an, dort habe ich eine replace_all()-Funktion für dich geschrieben.

^(*) OK, nicht ganz - nach einer Weile würde sich der String mit einer Exception bedanken.