String.Format für C ++

Question

Suchen Sie eine Implementierung für C ++ eine Funktion wie von .NET String.Format. Offensichtlich gibt es printf und es ist Sorten, aber ich bin auf der Suche nach etwas, das Positions ist wie in:

  

String.Format ( "Hallo zusammen {0}. Sie sind   {1} Jahre alt. Wie fühlt es sich an sein   {1} „, Name, Alter);?

Dies ist notwendig, weil wir versuchen, gehen und macht es einfacher, unsere App zu lokalisieren, und geben die Übersetzer {0} und {1}, um überall im Satz zu positionieren ist viel einfacher, als ihnen ein% s geben,% d,% d, die in dieser Reihenfolge in ihrer Übersetzung positioniert werden muß.

Ich nehme Suchen und Ersetzen mit variablen Eingänge (va_start, va_end, etc) ist das, was ich Gebäude am Ende werde, aber wenn es bereits eine feste Lösung ist, das wäre preferrable.

Danke:)

Answer 1

Es gibt viele gute Empfehlungen über das würde in den meisten Fällen funktionieren. In meinem Fall, ich wollte schließlich Strings von einer Ressource laden, und halten Sie die String-Ressourcen so nahe .NET String.Format wie ich konnte, so rollte ich meine eigenen. Nach einem Blick auf einige der Implementierungen oben für Ideen, war die resultierende Umsetzung recht kurz und einfach.

Es gibt eine Klasse String, der in meinem Fall leitet sich von Microsofts CString, aber es könnte etwa eine beliebige Zeichenfolge-Klasse abgeleitet. Es gibt auch eine Klasse StringArg - es ist Aufgabe jeden Parametertyp zu nehmen ist, und schalten Sie ihn in einen String (dh es ahmt ToString in .NET). Wenn ein neues Objekt zu ToString'd benötigt, fügen Sie einfach einen weiteren Konstruktor. Der Konstruktor ermöglicht eine printf-Stil Formatbezeichner für Nicht-Standardformatierung.

Die String-Klasse übernimmt dann eine Zeichenfolge Tabellen-ID für die Quellzeichenfolge, eine Reihe von StringArg Parameter und schließlich eine optionale HINSTANCE (ich benutze viele DLLs, von denen jede die String-Tabelle Host könnte, so das mir erlaubt, passieren es in, oder eine DLL-spezifischen HINSTANCE verwendet standardmäßig).

Anwendungsbeispiele:

dlg.m_prompt = String(1417); //"Welcome to Stackoverflow!"
MessageBox(String(1532, m_username)); //"Hi {0}"

Wie es ist, es dauert nur eine String-ID für einen Eingang, aber es wäre trivial eine Eingabezeichenfolge anstelle einer String-ID hinzuzufügen:

CString s = String.Format("Hi {0}, you are {1} years old in Hexidecimal", m_userName, StringArg(m_age, "%0X"));

Jetzt für die StringArg Klasse, die das Äquivalent von ToString auf Variablen tut:

class StringArg
{
StringArg(); //not implemented
        StringArg(const StringArg&); //not implemented
        StringArg& operator=(const StringArg&); //not implemented

    public:
        StringArg(LPCWSTR val);
    StringArg(const CString& val);
    StringArg(int val, LPCWSTR formatSpec = NULL);
    StringArg(size_t val, LPCWSTR formatSpec = NULL);
    StringArg(WORD val, LPCWSTR formatSpec = NULL);
    StringArg(DWORD val, LPCWSTR formatSpec = NULL);
    StringArg(__int64 val, LPCWSTR formatSpec = NULL);
    StringArg(double val, LPCWSTR formatSpec = NULL);
    CString ToString() const;
private:
    CString m_strVal;
};

extern HINSTANCE GetModuleHInst(); //every DLL implements this for getting it's own HINSTANCE -- scenarios with a single resource DLL wouldn't need this

Für die String-Klasse gibt es eine Reihe von Elementfunktionen und Konstrukteuren, die zu 10 Argumenten übernehmen. Diese letztlich nennen CentralFormat, die macht die eigentliche Arbeit.

class String : public CString
{
public:
    String() { }
    String(WORD stringTableID, HINSTANCE hInst = GetModuleHInst()) { Format(stringTableID, hInst); }
    String(WORD stringTableID, const StringArg& arg1, HINSTANCE hInst = GetModuleHInst()) { Format(stringTableID, arg1, hInst); }
    String(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, HINSTANCE hInst = GetModuleHInst()) { Format(stringTableID, arg1, arg2, hInst); }
    String(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, HINSTANCE hInst = GetModuleHInst()) { Format(stringTableID, arg1, arg2, arg3, hInst); }
    String(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, HINSTANCE hInst = GetModuleHInst()) { Format(stringTableID, arg1, arg2, arg3, arg4, hInst); }
    String(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, HINSTANCE hInst = GetModuleHInst()) { Format(stringTableID, arg1, arg2, arg3, arg4, arg5, hInst); }
    String(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, const StringArg& arg6, HINSTANCE hInst = GetModuleHInst()) { Format(stringTableID, arg1, arg2, arg3, arg4, arg5, arg6, hInst); }
    String(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, const StringArg& arg6, const StringArg& arg7, HINSTANCE hInst = GetModuleHInst()) { Format(stringTableID, arg1, arg2, arg3, arg4, arg5, arg6, arg7, hInst); }
    String(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, const StringArg& arg6, const StringArg& arg7, const StringArg& arg8, HINSTANCE hInst = GetModuleHInst()) { Format(stringTableID, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, hInst); }
    String(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, const StringArg& arg6, const StringArg& arg7, const StringArg& arg8, const StringArg& arg9, HINSTANCE hInst = GetModuleHInst()) { Format(stringTableID, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, hInst); }


    CString& Format(WORD stringTableID, HINSTANCE hInst = GetModuleHInst());
    CString& Format(WORD stringTableID, const StringArg& arg1, HINSTANCE hInst = GetModuleHInst());
    CString& Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, HINSTANCE hInst = GetModuleHInst());
    CString& Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, HINSTANCE hInst = GetModuleHInst());
    CString& Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, HINSTANCE hInst = GetModuleHInst());
    CString& Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, HINSTANCE hInst = GetModuleHInst());
    CString& Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, const StringArg& arg6, HINSTANCE hInst = GetModuleHInst());
    CString& Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, const StringArg& arg6, const StringArg& arg7, HINSTANCE hInst = GetModuleHInst());
    CString& Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, const StringArg& arg6, const StringArg& arg7, const StringArg& arg8, HINSTANCE hInst = GetModuleHInst());
    CString& Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, const StringArg& arg6, const StringArg& arg7, const StringArg& arg8, const StringArg& arg9, HINSTANCE hInst = GetModuleHInst());
private:
    void CentralFormat(WORD stringTableID, std::vector<const StringArg*>& args, HINSTANCE hInst);
};

Schließlich ist die Implementierung (hoffentlich es OK ist, diese zu schreiben viel auf Stackoverflow, obwohl der Großteil der es sehr einfach ist):

StringArg::StringArg(LPCWSTR val)
{
    m_strVal = val;
}

StringArg::StringArg(const CString& val)
{
    m_strVal = (LPCWSTR)val;
}

StringArg::StringArg(int val, LPCWSTR formatSpec)
{
    if(NULL == formatSpec)
        formatSpec = L"%d"; //GLOK
    m_strVal.Format(formatSpec, val);
}

StringArg::StringArg(size_t val, LPCWSTR formatSpec)
{
    if(NULL == formatSpec)
        formatSpec = L"%u"; //GLOK
    m_strVal.Format(formatSpec, val);
}

StringArg::StringArg(WORD val, LPCWSTR formatSpec)
{
    if(NULL == formatSpec)
        formatSpec = L"%u"; //GLOK
    m_strVal.Format(formatSpec, val);
}

StringArg::StringArg(DWORD val, LPCWSTR formatSpec)
{
    if(NULL == formatSpec)
        formatSpec = L"%u"; //GLOK
    m_strVal.Format(formatSpec, val);
}

StringArg::StringArg(__int64 val, LPCWSTR formatSpec)
{
    if(NULL == formatSpec)
        formatSpec = L"%I64d"; //GLOK
    m_strVal.Format(formatSpec, val);
}

StringArg::StringArg(double val, LPCWSTR formatSpec)
{
    if(NULL == formatSpec)
        formatSpec = L"%f"; //GLOK
    m_strVal.Format(formatSpec, val);
}

CString StringArg::ToString() const
{ 
    return m_strVal; 
}


void String::CentralFormat(WORD stringTableID, std::vector<const StringArg*>& args, HINSTANCE hInst)
{
    size_t argsCount = args.size();
    _ASSERT(argsCount < 10); //code below assumes a single character position indicator

    CString tmp;
    HINSTANCE hOld = AfxGetResourceHandle();
    AfxSetResourceHandle(hInst);
    BOOL b = tmp.LoadString(stringTableID);
    AfxSetResourceHandle(hOld);
    if(FALSE == b)
    {
#ifdef _DEBUG

        //missing string resource, or more likely a bad stringID was used -- tell someone!!
    CString s;
        s.Format(L"StringID %d could not be found!  %s", stringTableID, hInst == ghCommonHInst ? L"CommonHInst was passed in" : L"CommonHInst was NOT passed in"); //GLOK
        ::MessageBeep(MB_ICONHAND);
        ::MessageBeep(MB_ICONEXCLAMATION);
        ::MessageBeep(MB_ICONHAND);
        _ASSERT(0);
        ::MessageBox(NULL, s, L"DEBUG Error - Inform Development", MB_ICONSTOP | MB_OK | MB_SERVICE_NOTIFICATION); //GLOK
        }
#endif //_DEBUG

    CString::Format(L"(???+%d)", stringTableID); //GLOK
        return;
    }

    //check for the degenerate case
    if(0 == argsCount)
    {
        CString::operator=(tmp);
        return;
    }

    GetBuffer(tmp.GetLength() * 3); //pre-allocate space
    ReleaseBuffer(0);
    LPCWSTR pStr = tmp;
    while(L'\0' != *pStr)
    {
        bool bSkip = false;

        if(L'{' == *pStr)
        {
            //is this an incoming string position?
            //we only support 10 args, so the next char must be a number
            if(wcschr(L"0123456789", *(pStr + 1))) //GLOK
            {
                if(L'}' == *(pStr + 2)) //and closing brace?
                {
                    bSkip = true;

                    //this is a replacement
                    size_t index = *(pStr + 1) - L'0';
                    _ASSERT(index < argsCount);
                    _ASSERT(index >= 0);
                    if((index >= 0) && (index < argsCount))
                        CString::operator+=(args[index]->ToString());
                    else
                    {
//bad positional index

                        CString msg;
                        msg.Format(L"(??-%d)", index); //GLOK
                        CString::operator+=(msg);
                    }
                    pStr += 2; //get past the two extra characters that we skipped ahead and peeked at
                }
            }
        }

        if(false == bSkip)
            CString::operator+=(*pStr);
        pStr++;
    }
}


CString& String::Format(WORD stringTableID, HINSTANCE hInst)
{
    std::vector<const StringArg*> args;
    CentralFormat(stringTableID, args, hInst);
    return *this;
}

CString& String::Format(WORD stringTableID, const StringArg& arg1, HINSTANCE hInst)
{
    std::vector<const StringArg*> args;
    args.push_back(&arg1);
    CentralFormat(stringTableID, args, hInst);
    return *this;
}

CString& String::Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, HINSTANCE hInst)
{
    std::vector<const StringArg*> args;
    args.push_back(&arg1);
    args.push_back(&arg2);
    CentralFormat(stringTableID, args, hInst);
    return *this;
}

CString& String::Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, HINSTANCE hInst)
{
    std::vector<const StringArg*> args;
    args.push_back(&arg1);
    args.push_back(&arg2);
    args.push_back(&arg3);
    CentralFormat(stringTableID, args, hInst);
    return *this;
}

CString& String::Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, HINSTANCE hInst)
{
    std::vector<const StringArg*> args;
    args.push_back(&arg1);
    args.push_back(&arg2);
    args.push_back(&arg3);
    args.push_back(&arg4);
    CentralFormat(stringTableID, args, hInst);
    return *this;
}

CString& String::Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, HINSTANCE hInst)
{
    std::vector<const StringArg*> args;
    args.push_back(&arg1);
    args.push_back(&arg2);
    args.push_back(&arg3);
    args.push_back(&arg4);
    args.push_back(&arg5);
    CentralFormat(stringTableID, args, hInst);
    return *this;
}

CString& String::Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, const StringArg& arg6, HINSTANCE hInst)
{
    std::vector<const StringArg*> args;
    args.push_back(&arg1);
    args.push_back(&arg2);
    args.push_back(&arg3);
    args.push_back(&arg4);
    args.push_back(&arg5);
    args.push_back(&arg6);
    CentralFormat(stringTableID, args, hInst);
    return *this;
}

CString& String::Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, const StringArg& arg6, const StringArg& arg7, HINSTANCE hInst)
{
    std::vector<const StringArg*> args;
    args.push_back(&arg1);
    args.push_back(&arg2);
    args.push_back(&arg3);
    args.push_back(&arg4);
    args.push_back(&arg5);
    args.push_back(&arg6);
    args.push_back(&arg7);
    CentralFormat(stringTableID, args, hInst);
    return *this;
}

CString& String::Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, const StringArg& arg6, const StringArg& arg7, const StringArg& arg8, HINSTANCE hInst)
{
    std::vector<const StringArg*> args;
    args.push_back(&arg1);
    args.push_back(&arg2);
    args.push_back(&arg3);
    args.push_back(&arg4);
    args.push_back(&arg5);
    args.push_back(&arg6);
    args.push_back(&arg7);
    args.push_back(&arg8);
    CentralFormat(stringTableID, args, hInst);
    return *this;
}

CString& String::Format(WORD stringTableID, const StringArg& arg1, const StringArg& arg2, const StringArg& arg3, const StringArg& arg4, const StringArg& arg5, const StringArg& arg6, const StringArg& arg7, const StringArg& arg8, const StringArg& arg9, HINSTANCE hInst)
{
    std::vector<const StringArg*> args;
    args.push_back(&arg1);
    args.push_back(&arg2);
    args.push_back(&arg3);
    args.push_back(&arg4);
    args.push_back(&arg5);
    args.push_back(&arg6);
    args.push_back(&arg7);
    args.push_back(&arg8);
    args.push_back(&arg9);
    CentralFormat(stringTableID, args, hInst);
    return *this;
}

Answer 2

Sehen Sie sich die Boost-Format Bibliothek.

Answer 3

Qt QString Damit können Sie tun, um diese:

QString("Hi there %1. You are %2 years old. How does it feel \
         to be %2?").arg(name).arg(age)

Answer 4

Ob Sie es glauben oder nicht, printf und Freunde Positionsargumente unterstützen.

 #include <stdio.h>

 int main() {
   char *name = "Logan";
   int age = 25;
   printf("Hi there %1$s, you are %2$d years old. How does it feel to be %2$d?\n", name, age);
  return 0;
 }

Answer 5

Sie können einen Blick auf die FastFormat -Bibliothek.

Answer 6

Ich glaube, Sie können FastFormat , wie

std::string result;

fastformat::fmt(result, "Hi there {0}. You are {1} years old. How does it feel to be {1}?", name, age);

, die fast die gleiche Syntax ist.

Answer 7

Mehrere Optionen:

• Boost-Format-Bibliothek (bereits erwähnt)
• stringstreams
• Legacy-printf / sprintf Funktionen
• benutzerdefinierte Implementierung von regulären Ausdrücken oder integrierte String-Funktionen mit

Über einen entsprechenden Hinweis, was Sie sprechen, ist völlig unzureichend für die Lokalisierung.

Answer 8

Iostream:

stringstream s;
string a;
s << "this is string a: " << a << endl;

Sie können wie sprintf formatieren (google für "Iostream Format") und sein in dem C ++ Standard.

Answer 9

Wenn Sie vorhaben, Ihre eigenen zu schreiben, Suchen und Ersetzen ist wahrscheinlich nicht der beste Ansatz, da die meisten Suchen / Ersetzen-Methoden, die Sie nur lassen einer nach dem anderen ersetzen, und machen einen sehr schlechten Job escpae Zeichen zuzulassen ( wie wenn Sie die Zeichenkette {0} in der Ausgabe enthalten.

Sie sind viel besser Sie Ihre eigenen endlichen Automaten schriftlicher Form über die Eingabezeichenfolge zu gehen, eine Ausgabezeichenfolge on the fly in einem Durchgang zu erzeugen. Dies ermöglicht Ihnen, Zeichen und komplizierte Ausgabefunktionen zu handhaben entkommen (wie lokalisierte Daten zum Beispiel {0:dd\MM\yyyy}). Es wird Ihnen viel mehr Flexibilität neben schneller als eine Suche zu sein / ersetzen oder ein regulärer Ausdruck Ansatz.

Answer 10

Windows-Targetting? Format () ist dein Freund

Answer 11

Wenn Sie Cross-Plattform sein sollte, dann würde ich stimme für boost :: Format, oder vielleicht ICU. Wenn Sie sollten nur von Windows unterstützt, dann Format (oder die bequeme Wrapper kommt, dass CString :: Format, wenn Sie MFC verwenden)

Kann hier für einen Vergleich einen Blick: http: // www. mihai-nita.net/article.php?artID=20060430a

Answer 12

Vor einiger Zeit habe ich versucht, so etwas zu tun, aber mit einigen zusätzlichen Annahmen:

• keine Unterstützung für Positions-Formatierung (also denke ich, es für Sie ein no go ist)
• c ++ 2k3 (kann es mit einigen älteren Codes zu übernehmen)
• (fast) keine Abhängigkeiten (auch crt, also keine sprintf Abhängigkeiten)

Ich habe es nicht, und es ist völlig unfertig, aber Sie können auf einige Ergebnisse sehen immer noch:

http://code.google.com/p/pileofcrap/ Quelle / browse / tests_format.cpp

http://code.google.com/p/ pileofcrap / source / browse / format / Format.h

Answer 13

Neben Optionen, die von anderen vorgeschlagen kann ich empfehlen die fmt Bibliothek die Zeichenfolge Formatierung ähnlich implementiert zu str.format in Python und String.Format in C #. Hier ein Beispiel:

string result = fmt::format("Hi {0}. You are {1} years old.", name, age);

Die Bibliothek ist voll typsicher und ist viel schneller als Boost-Format.

Disclaimer:. Ich bin der Autor dieser Bibliothek