Ich habe folgendes Problem:
Ich möchte einen char* laufende int-Werte hängen. Pseudomäßig also so:

char* text = "Text";
int i = 1;

char* neuertext = text+i //"Text1"

i++

char* neuertext2 = text+i; //"Text2"

Wie kann ichd as in C++ realisieren?

Danke!

Jörg

stringstream macht das prima.

#include <sstream>
#include <string>

using std::ostringstream;
using std::string;

...
    // in einen ostringstream kann man prima "Zeug reinpacken"
    ostringstream ost;
    int i = 1;
    ost << "Text" << i;

    // mit einem string kann man prima "rumarbeiten".
    string neuertext1 = ost.str();

    // stringstream leeren
    ost.str("");
    ost << "Text" << ++i;
    string neuertext2 = ost.str();
...

Gruß,

Simon2.

#include <boost/format.hpp>
#include <iostream>
using boost::format;

int main() {

format x("sting %d");

for(int i=0;i<100;++i) cout << x%i;

return 0;
}

das ganze lässt sich mit boost::format recht elegant lösen
...

Schick !

Aber sehe ich das richtig, daß die Typprüfung zur Laufzeit stattfindet ?
Wäre zwar immer noch besser als gar keine (wie bei printf()), aber zur Compilezeit (wie bei den operator<<()) gefällt mir irgendwie besser ... gerade, weil ein falscher Typ wohl eher ein Programmier- als ein Bedienfehler ist.

Aber ansonsten ist boost::format schon gaaaaanz schön mächtig und vielseitig, scheint's.

Gruß,

Simon2.

der % operator würd zum einsetzen eines elementes in ein format genutzt

und der ist für einige typen überladen

und du kannst hier statt %d auch %1% verwenden

zur compilezeit

der % operator würd zum einsetzen eines elementes in ein format genutzt

und der ist für einige typen überladen

Hi,

das hatt ich schon begriffen, aber woher weiß der Compiler, was im Formatstring steht ? ("..%d ...")

__me schrieb:

Wieso sollte % nicht Typsicher sein, << aber schon?...

Es könnte (!! - ich weiß zuwenig darüber, um ein Urteil zu fällen) sein, daß ostream zur Compilezeit Typsicherheit prüfen kann und boost::format erst zur Laufzeit ! (aufgefallen, daß ich nicht behaupte, eine Lösung sei "nicht typsicher" ?).
Und zwar wenn bei der ostream-Semantik nur 1 Information gebraucht wird, die zur Compilezeit feststeht (statischer Typ des Parameters), bei der boost::format aber anscheinend 2 Informationen zusammengebracht werden, von denen eine erst zur Laufzeit bestimmt wird (Inhalt Formatstring).
Aber wie gesagt: Ich weiß nicht, ob ich das richtig verstanden habe und frage deswegen hier nach - wer's mir erklären mag, ist herzlich eingeladen.

Gruß,

Simon2.

Im Prinzip kannst Du im Formatstring einfach %1, %2 etc. schreiben. An dieser Stelle wird dann einfach das entsprechende mit % angehängte Objekt ausgegeben. Das ist natürlich typsicher.

Aha !

OK,
ich denke, jetzt habe ich's geschnallt. Das "%d" hat mich einfach irritiert.

Danke,

Simon2.