MfG

yahoo!

greetz, Swordfish

greetz, Swordfish

const char *foo = "Hallo";

    std::ofstream *out = new std::ofstream("out.txt", std::ofstream::out);
    out->write(strlwr(foo));
    out->close();

(wobei ich hier die c-funktion strlwr nehme statt C++-transform, da transform IMO nur mit C++-strings geht).

wobei ich hier die c-funktion strlwr nehme statt C++-transform, da transform IMO nur mit C++-strings geht.

Das funktioniert mit jedem Container, der Iteratoren anbietet.
Aber im Gegensatz zu Dir werd' ich's ihm nicht in den Hals stopfen .

greetz, Swordfish

Aber im Gegensatz zu Dir werd' ich's ihm nicht in den Hals stopfen .

mache ich ja sonst auch nicht, aber irgendwie habe ich heute nen guten tag

char* my_string; 
/* ... */
std::transforn(my_string, my_string + std::strlen(my_string), my_string, std::tolower);

...

#include <locale>

void make_lower (char* begin, char const* end)
{
   use_facet<ctype<char> >(locale()).tolower(begin, end);
}

Geht bestimmt noch iwie (sehr viel ^^) effektiver etc, aber es tut seinen Job ganz gut glaub ich : >

Bye

std::string lowercase_mitumlauten (const std::string &v)
    {
        const size_t end (v.length ());
        std::string R ("");
        for (size_t i (0); i < end; ++i)
            {
                if ((v[i] >= 'A') && (v[i] <= 'Z'))
                    R.push_back (v[i] + 32);
                else if (v[i] == 'Ä') R.push_back ('ä'); //keine ascii-tabelle
                else if (v[i] == 'Ö') R.push_back ('ö');
                else if (v[i] == 'Ü') R.push_back ('ü');
                else R.push_back (v[i]);
            }
        return R;
    };

;o)
Wenn man es ein wenig performanter will, dann muss man das eben so anstellen:

std::string R (""); //weiß nicht, obs hier nen reserve gibt...
//...
switch (v[i])
  case 'A':
    R.push_back ('a');
    break;
/*
B-Z, ÄÖÜ
*/
  default:
    R.push_back (v[i]);

Naja - toll wird es auch dann noch nicht, aber reichen tuts jz jedenfalls ^^

Bye

ich weiß, jz kommt gleich wieder einer mit dem satz: "oh - ein rad!" ^^ aber ab und an find ichs einfach vorteilhafter die fkt selbst zu schreiben...
ich kenn mich zwar auch nicht sonderlich gut damit aus aber so kann man eben z.bsp. auch bei nem toupper bestimmen, was mit nem ß passieren soll...

std::string lowercase (const std::string &v)
	{
		const size_t end (v.length ());
		std::string R ("");
/*HIER*/	R.reserve (end+1); //end oder end +1 ?
		for (size_t i (0); i < end; ++i)
			{
				switch (v[i])
					{
						case 'A':		R.push_back ('a');	break;
/*B-Z, Ä, Ö, Ü*/
						default:		R.push_back (v[i]);
					}
			}
/*HIER*/	const size_t ASD = R.capacity ();
		return R;
	};

die 2 relevanten Stellen habe ich jeweils gekennzeichnet, wie man sieht ^^
Die erste Frage:
std::string wird doch auch mit \0 terminiert. Ich muss also {Länge + 1} reservieren, genau wie bei char *, oder?!
Die zweite Frage:
Warum bildet sich da so ne große Differenz? Kann ich das irgendwie umgehen oder nutz ich womöglich einfach die falsche Fkt und man nimmt die fkt xyz dafür?

Danke...

im prinzip musst du aber gar nicht auf reserve achten, da std::string automatisch neuen speicher allokiert.

Aber in diesem Fall ist es noch überflüssiger, da dich das nicht interessiert. Es gibt kein lower case zu '\0'. Und reservieren musst du dafür auch keinen Platz. Das kann std::basic_string entweder intern machen oder lassen. Es ist für dich egal!

Warum so umständlich:

const std::string lowercase (std::string const & data)
{
    const std::size_t size(data.length());
    std::string result(size, 0); // string mit '\0' füllen.
    std::string::iterator it_result(result.begin());
    for (std::string::const_iterator it(data.begin()); it != data.end(); ++it)
    {
        if (*it >= 'A' && *it <= 'Z')
            *it_result++ = *it - 'A' + 'a';
        else
        {
            switch (*it)
            {
            case 'Ä':
                *it_result++ = 'ä'; break;
            case 'Ö':
                *it_result++ = 'ö'; break;
            case 'Ü':
                *it_result++ = 'ü'; break;
            case 'Ô':
                *it_result++ = 'ô'; break;
            default:
                *it_result++ = *it;
            }
        }
    }
}

so musst du nicht ganz so viele case reinbauen Und Iteratoren sind wesentlich schneller als der Indexoperator!

Und reservieren musst du dafür auch keinen Platz. Das kann std::basic_string entweder intern machen oder lassen. Es ist für dich egal!

Naja... Wenn ich nen string hab, der 20 Faszillionen Zeichen hat ^^ Dann wird der string (obwohl ich schon weiß, wie lang er sein muss erst leer erstellt, dann werden paar byte dazu allokiert und dann noch mal und so weiter und so fort - dann ist dort nicht genügend platz und er muss halt wo anders allokieren und umkopieren (ich glaube zumindest, dass das so gelöst ist ^^))
Das ist der Sinn darin....
Wobei sich das Problem jz eh geklärt hat weil deine Variante besser ist ^^

Ich weiß, dass man auch - 'A' und + 'a' rechnen kann (oder +32 ^^) - aber dachte eben, dass es mit nur switch schneller ist.

Und Iteratoren sind wesentlich schneller als der Indexoperator

Hmmm - gerade das dachte ich, optimiert der Compiler eh raus - aber ok.
Danke : >

Danke : >