int an char* hängen



  • Hallo!

    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



  • Hi,

    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.



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

    #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;
    }
    


  • r0nny schrieb:

    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.



  • zur compilezeit

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

    und der ist für einige typen überladen



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

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



  • #include <string>
    #include <boost/lexical_cast.hpp>
    using namespace std;
    
    string text = "Text";
    int i = 1;
    string neuertext = text + boost::lexical_cast<string>(i);
    i++;
    string neuertext2 = text + boost::lexical_cast<string>(i);
    


  • r0nny schrieb:

    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.



  • Jester schrieb:

    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.


Log in to reply