Type Conversion LPCTSTR to Int



  • Hi Leute, bin zwar mit dem "casting" von Java und Php vertraut, konnte jedoch nichts hilfreiches über casten in c++ bei google finden.

    Also falls jemand den Befehl, die Funktion oder sonstiges kennt bitte ein kurzes beispiel angeben.

    Ich möchte einen Integer und einen String zusammenfügen und in einen LPCTSTR casten. (ggf. auch 2 Strings zusammenfügen (mit +) und dann in einen LPCTSTR umwandeln.

    Danke



  • Da kann man nicht wirlklich irgendwas "casten".

    Wenn dann kannst du folgendes machen:

    #include <sstream>
    
    int main(){
       int meine_zahl = 76876;
       std::ostringstream ostr("Meine Zahl lautet: ");
       ostr << meine_zahl << ".";
       function_die_lpcstr_erwartet(ostr.str().c_str()); 
    }
    

    Übrigens ist LPCSTR ein typedef für char const *

    BR
    Vinzenz



  • Er wollte aber LPCTSTR.

    #include <sstream>
    #include <tchar.h>
    
    typedef std::basic_ostringstream<TCHAR> tostringstream;
    
    int main()
    {
        int meine_zahl = 76876;
        tostringstream ostr(_T("Meine Zahl lautet: "));
        ostr << meine_zahl << ".";
        function_die_lpctstr_erwartet(ostr.str().c_str());
        return 0;
    }
    


  • LPCTSTR intToStr(int a) 
    { 
        tostringstream ostr(_T("Meine Zahl lautet: ")); 
        ostr << a << "."; 
        return ostr.str().c_str(); 
    } 
    LPCTSTR getFPS ()
    {
    
    	return (LPCTSTR) intToStr(5);
    }
    

    Sorry, das hat nicht ganz geklappt, das rückgabeergebnis scheint ein leerer String zu sein.



  • Ben86 schrieb:

    LPCTSTR intToStr(int a) 
    { 
        tostringstream ostr(_T("Meine Zahl lautet: ")); 
        ostr << a << "."; 
        return ostr.str().c_str(); 
    } // ab hier existiert ostr nicht mehr!
    

    so geht's:

    #include <string>
    #include <sstream>
    #include <iostream>
    
    #include <windows.h>
    #include <tchar.h>
    
    using namespace std;
    
    LPTSTR intToStr(int a)
    {
        stringstream ss;
        ss << _T( "Meine Zahl lautet: " ) << a << _T( "." );
        char *txt = new TCHAR[ ss.str( ).size( ) + 1 ];
        _tcscpy( txt, ss.str( ).c_str( ) );
        return txt;
    }
    
    LPTSTR getFPS ()
    {
        return intToStr( 5 );
    }
    
    int main( )
    {
        LPTSTR text = getFPS( );
        cout << text << endl;
        delete [ ] text;
    }
    

    Greetz, Swordfish



  • Du solltest trotzdem basic_stringstream<TCHAR> anstatt stringstream verwenden, sonst wird das mit dem _tcscpy unter Unicode nix.

    Ich würde es übrigens ohne das explizite Speicherhandling machen:

    #include <sstream>
    #include <string>
    #include <tchar.h>
    
    typedef std::basic_ostringstream<TCHAR> tostringstream;
    typedef std::basic_string<TCHAR> tstring;
    
    tstring intToStr(int a)
    {
        tostringstream ostr;
        ostr << _T("Meine Zahl lautet: ") << a << _T(".");
        return ostr.str();
    }
    
    tstring getFPS()
    {
        //...
        return intToStr(5);
    }
    
    int main()
    {
        function_die_lpctstr_erwartet(getFPS().c_str());
        return 0;
    }
    


  • LPCTSTR intToStr(DWORD a) 
    { 
    	static char buffer [20];
    	sprintf_s (buffer,"%u FPS",a); 
        return buffer; 
    }
    

    das sieht besser aus und klappt auch. ob int oder DWORD unterscheidet sich dann nur in %u und %d.



  • das sieht besser aus und klappt auch.

    Für dich vielleicht.

    Übrigens hast du das 2.größte Manko deiner Lösung selbst schon angegeben. du musst unterscheiden. mit andren worten: wechselst du mal den typ, musst du die funktion verändern, toller plan.

    Zwar kannst du noch ne zweite funktion "floatToString" schreiben, aber dann darfste hinterher jedes mal, wenn du aus nem int ein float machst, den betreffenden code durchgehen, und aus jedem "intToString" ein "floatToString" machen.

    Klar, wirst du sagen, dass müsste man bei den andren lösungen auch, aber im gegensatz zu deiner Lösung kann man diesen Code sehr schnell in die passende form bringen:

    typedef std::basic_ostringstream<TCHAR> tostringstream;
    typedef std::basic_string<TCHAR> tstring;
    
    template<class Type>
    tstring typeToStr(Type a)
    {
        tostringstream ostr;
        ostr <<a;
        return ostr.str();
    }
    
    //verwendung
    float fps=...;
    tstring ausgabe = _T("FPS: ")+typeToStr(fps)+_T(".");
    
    //oder
    int fps=...;
    tstring ausgabe = _T("FPS: ")+typeToStr(fps)+_T(".");
    

    Dies ist übrigens allgemein und kann für jeden Typen verwendet werden.

    übrigens: deine Lösung hat nochn krassen makel: LPCTSTR ist nämlich ein typedef und ist entweder char** oder wchar_t**. und je nachdem welchen typ dieses typedef grad darstellt, brauchst du sprintf_s oder wsprintf_s, sonst erlebst du die ein oder andere überaschung beim compilieren.



  • Wieso sollte LPCTSTR ein Zeiger auf Zeiger (sprich ein Array von Strings) sein?



  • LordJaxom schrieb:

    Wieso sollte LPCTSTR ein Zeiger auf Zeiger (sprich ein Array von Strings) sein?

    Stimmt, sehs grad selbst in den header. Dachte im Kopf zu haben, dass LP und STR getrennt voneinander gesehen werden müssen(normal steht LP alleine schon für nen zeiger auf etwas. zb LPDWORD für einen zeiger auf DWORD). scheinbar gib das STR nun doch nur an, dass der zeiger nicht auf ein einzelnes Zeichen sondern auf mehrere zeigt. Tut mir leid halbwissen verbreitet zu haben.


Log in to reply