char *CTools::lowerCase(const char *pszString)
{
	char *pszLowered = new char[strlen(pszString) + 1];
	strcpy(pszLowered, pszString);

	for (unsigned short i = 0; i < strlen(pszLowered); i++)
	{
		if (pszLowered[i] >= 'A' && pszLowered[i] <= 'Z')
		{
			pszLowered[i] += 32;
		}
	}

	return pszLowered;
}

Ich habe außerdem eine weitere Frage. Ist es heutzutage noch wichtig, ob man unsigned short benutzt, short oder gleich int? Ich möchte halt nach dem Prinzip gehen, so wenig Speicher wie möglich vollzumüllen, da ich ein Plugin für einen Gameserver schreibe welche auf keinen Fall Abstürze oder Laggs (Verzögerungen) verursachen darf

Gruß und Danke

Falls du das nicht möchtest, bitte den Aufrufer, dir den Speicher für das Ziel zur Verfügung zu stellen.

void CTools::lowerCase(char *dest, const char *srce) {
   // ...
}

Oder konvertiere den String "in place":

void CTools::lowerCase(char *srceAndDest) {
   // ...
}

Mein erster Tip wäre allerdings immer std::string.

Und ein besserer Algorithmus

Stefan.

Gruß und Danke!

Hi.
Ich möchte auf std::string nicht zurückgreifen, da ich Erfahrungen mit char's für die Schule sammeln will.
Das mit dem bereitstellen ist eine verdammt gute Idee.
Was meinst du genau mit dem Algorithmus?

Gruß und Danke!

Du kopierst zunächst den Ausgangsstring in den Buffer. Dann ackerst du über den Buffer, um zu konvertieren. Stattdessen könntest du das Kopieren lassen, aus dem Eingansstring lesen und die Zeichen in den Ausgangsstring kopieren. Terminierendes Nullbyte nicht vergessen!

Du brauchst strlen() in der Schleife nicht. Verlasse dich darauf, dass das Ende eines C-Strings immer durch ein Nullbyte gekennzeichnet ist. Falls du das nicht möchtest, kannst du auch nur einmal strlen() aufrufen und den Wert in eine Variable schreiben. Die Länge des Strings ändert sich ja nicht.

Die eigentliche Konvertierung basiert auf der Annahme, dass die Zeichen 'A' bis 'Z' sowie 'a' bis 'z' alle hintereinander liegen. Außerdem nimmst du an, dass es von dem Großbuchstaben zum Kleinbuchstaben immer 32 Zeichen sind. Das alles ist nirgendwo festgeschrieben. Kuck dir mal std::tolower() an.

Stefan.

char *CTools::lowerCase(const char *pszString)
{
	short i = 0;

	while (true)
	{
		if (pszString[i] >= 'A' && pszString[i] <= 'Z')
		{
			pszString[i] += 32;
		}

		i++;

		if (pszString[i] == '\0')
			break;
	}

	return pszString;
}

Entspricht das so mehr dem, was du meinst?
Das mit den +32 habe ich aus der ASCII Tabelle (http://de.wikipedia.org/wiki/ASCII).

Gruß und Danke

Aber warum machst du es jetzt mit while()? Und dann auch noch ohne Bedingung? Das verstreut die Behandlung der Zähl-Variable und den Abbruch-Test quer durch die ganze Funktion. In dieser Hinsicht war die for-Schleife deutlich besser, weil übersichtlicher.

Außerdem brauchst du nicht

pszString[i] == '\0'

zu schreiben, der Ausdruck

pszString[i]

erfüllt denselben Zweck.

Also:

for(unsigned i = 0; pszString[i]; ++i) {

   // ...

}

Für die Konvertierung solltest du dir noch std::tolower() ansehen, das ist im Header clocale.

Stefan.

char * to_lower_case(const char *str, size_t len)
{
    char *copy = new char[len + 1];
    std::transform(str, str + len, copy, std::tolower);
    return copy;
}

Und der Benutzer gibt den Speicher frei. Oder sinnvoller:

char * to_lower_case(const char *str, size_t len)
{
    std::transform(str, str + len, str, std::tolower);
    return str; // Wer will kann die Funktion auch als void deklarieren.
}

macht mehr Sinn ;o)

Das ist doch Käse, mach es einfach so:

char * to_lower_case(const char *str, size_t len)
{
    char *copy = new char[len + 1];
    std::transform(str, str + len, copy, std::tolower);
    return copy;
}

Und der Benutzer gibt den Speicher frei. Oder sinnvoller:

char * to_lower_case(const char *str, size_t len)
{
    std::transform(str, str + len, str, std::tolower);
    return str; // Wer will kann die Funktion auch als void deklarieren.
}

Du hast natürlich Recht. Das ist genau der Code, der zur Frage passt!
Und der Benutzer gibt den Speicher frei.

Stefan.

while (*pszString)
{
    if (*pszString = ...)
        ...;

    *pszString++;
}

Wie soll das denn gehen? Verstehen tue ich das nicht so recht.

Und wenn ich noch einmal auf die andere Frage von mir verweisen darf:

Ist es heutzutage noch wichtig, ob man unsigned short benutzt, short oder gleich int? Ich möchte halt nach dem Prinzip gehen, so wenig Speicher wie möglich vollzumüllen, da ich ein Plugin für einen Gameserver schreibe welche auf keinen Fall Abstürze oder Laggs (Verzögerungen) verursachen darf

Danke an Alle und Gruß

Hi.
Danke, jetzt weiß ich darüber endlich mal etwas mehr bescheid.
Ich habe heute einen Code entdeckt, der so (oder ähnlich) aufgebaut war (ich finde ihn irgendwie nicht mehr):

while (*pszString)
{
    if (*pszString = ...)
        ...;
    
    *pszString++;
}

Wie soll das denn gehen? Verstehen tue ich das nicht so recht.

Such mal nach "Pointerarithmetik".

*pszString bedeutet dasselbe wie pszString[0] und ++pszString verschiebt den Pointer auf das nächte Element. In deinem Fall also auf den nächsten char.

theliquidwave schrieb:

Und wenn ich noch einmal auf die andere Frage von mir verweisen darf:

Ist es heutzutage noch wichtig, ob man unsigned short benutzt, short oder gleich int? Ich möchte halt nach dem Prinzip gehen, so wenig Speicher wie möglich vollzumüllen, da ich ein Plugin für einen Gameserver schreibe welche auf keinen Fall Abstürze oder Laggs (Verzögerungen) verursachen darf

Wichtig wofür? Grundsätzlich würde ich mich darum bemühen, die "signedness" korrekt darzustellen, also nicht int nehmen für Zahlen, die gar nicht negativ sein können. Alles andere wird erst wichtig, wenn es um den Speicherverbrauch von Datenstrukturen geht.

Stefan.

Was passiert da ?

Was bedeutet memory leak ( Speicher leck ) ?

Was passiert da ?

Wenn du z.B mit new Speicher anforderst und den dann nicht freigibst, dann bleibt der allokiert. Sprich er ist blockiert, bis man ihn wieder freigibt, was niemals der Fall sein muss. Üblicherweise wird das das Heutzutage vom Betriebssystem gemacht, wenn dein Programm beendet ist.

Gibt es eigentlich Analysetools mit denen man Memory leaks finden kann?

Gruß und Danke

Gibt es eigentlich Analysetools mit denen man Memory leaks finden kann?

Ja, z.B. valgrind

Gruß

@ drakon: Das kann ich aber schlecht benutzen, da ich eine DLL erstelle, die kann ich ja schlecht im Debugmodus starten >_>
Gruß

Warum sollte das nicht gehen?

Gruß

Hi.
Wie soll das denn gehen?
Die .exe kommt ja nicht von mir - ich erstelle ja nur die .dll, muss aber die .exe starten um die .dll zu laden - wie also kann ich das realisieren?

Gruß

Na und? Du schreibst dir einfach eine EXE, die Funktionen aus der DLL aufruft. Das ist ohnehin eine gute Idee, um deinen Code zu testen.

Stefan.

Gruß und Danke