Wie kann ich prüfen, ob eine C++ - std::string beginnt mit einem bestimmten string und konvertiert einen Teilstring in einen int?

Wie implementiere ich die folgenden (Python-pseudocode) in C++?

if argv[1].startswith('--foo='):
    foo_value = int(argv[1][len('--foo='):])

(Zum Beispiel, wenn argv[1] ist --foo=98, dann foo_value ist 98.)

Update: ich bin zögerlich, um zu schauen, in Boost, da bin ich gerade auf der Suche zu machen, eine sehr kleine änderung, um ein einfaches kleines Kommandozeilen-tool (ich würde lieber nicht haben, um zu lernen, wie zu verlinken und die Verwendung von Boost für eine kleine änderung).

  • Dieser ist auch interessant.
InformationsquelleAutor Daryl Spitzer | 2009-12-10
  1. 83

    Wenn Sie bereits mit Boost, die Sie tun können, es mit boost string algorithmen + boost-lexical-cast:

    #include <boost/algorithm/string/predicate.hpp>
#include <boost/lexical_cast.hpp>

try {    
    if (boost::starts_with(argv[1], "--foo="))
        foo_value = boost::lexical_cast<int>(argv[1]+6);
} catch (boost::bad_lexical_cast) {
    //bad parameter
}

    Diese Art von Ansatz, wie viele der anderen Antworten hier ist ok für sehr einfache Aufgaben, aber im langen Lauf Sie sind in der Regel besser über ein command line parsing library. Boost hat ein (Boost.Program_options), was Sinn machen würde, wenn Sie passieren zu sein mit Boost schon.

    Sonst eine Suche nach "c++ - Kommandozeilen-parser" wird der Ertrag einer Reihe von Optionen.

    • "boost::algorithm::starts_with" anstelle von "boost::starts_with" ?
    • Scheint, dass Sie beide arbeiten. Ich habe immer verwendet die kürzere form.
    • boost::starts_with und boost::algorithm::starts_with sind die gleiche Sache. Wenn Sie sich am Ende dieser Datei svn.boost.org/svn/boost/trunk/boost/algorithm/string/... sehen Sie: // pull-Namen, um die boost-namespace mithilfe von Algorithmus::starts_with; [...]
    • Ziehen in große Abhängigkeiten für eine string prefix-check ist wie das Schießen Vögel mit Kanonen.
    • "Boost" ist immer die falsche Antwort, wenn jemand fragt, wie es zu tun ist eine einfache string-operation in C++.
    • minus 1 für die Annahme Boost
    • Mit boost ist hier falsch.
    • Mit boost ist hier richtig, wenn Sie schon die Verwendung von boost in Ihrem Projekt.
    • Mit boost für diese ist falsch, wenn dies ist der Grund, für welche würden Sie sich entscheiden, zu verknüpfen, steigern in Erster Linie, wenn Sie bereits mit boost für andere Gründe, die ich nicht sehen, warum dies wäre große problem.
    • Die Antwort vorangestellt ist, "Wenn Sie mit Boost...". Klar ist das die richtige Antwort "...wenn Sie mit Boost". Wenn nicht, sehen Sie den Vorschlag von @Thomas

    InformationsquelleAutor Ferruccio
  2. 277
    std::string s = "tititoto";
if (s.rfind("titi", 0) == 0) {
  //s starts with prefix
}

    Wer braucht noch was? Reine STL!

    • diese Antwort sollten Sie die meisten up stimmten nicht steigern 😀 warum verwenden Sie eine andere Bibliothek, wenn Sie bereits über STL.
    • Diese Antwort falsch ist und es verdient, downvoted.
    • Ich bin verwirrt, auf Ihrer ersten Behauptung. Der Rückgabewert von find wird nur null sein, wenn titi ist bei der start string. Wenn es gefunden wird irgendwo sonst, erhalten Sie einen nicht-null-Wert zurückgeben und, wenn es nicht gefunden wird, erhalten Sie npos ist auch nicht null. Vorausgesetzt ich habe Recht, ich würde es vorziehen, diese Antwort da ich nicht haben, um in einem nicht-standard-Sachen (ja, ich weiß, Boost ist überall, ich würde lieber nur Kern-C++ - libs für einfache Sachen wie diese).
    • du hast Recht, es ist in der Tat prüfen, ob es beginnt mit titi, aber die conversion-Teil fehlt.
    • Dieser code ist schlecht, weil es ist sehr ineffizient. find wird auch weiterhin auf der Suche, für ein Spiel auch nach es ist schon klar, dass das argument ist nicht ein Präfix zu s. Dies ist eine enorme performance-Einbußen.
    • Möchten Sie vielleicht, um die optimierte "code" (Richter nie die Leistung des nicht optimierten code). Da es eine Vorlage, der code ist verfügbar für inlining. Und nach dem inlining, es ist klar, dass die zugrunde liegenden Schleife variable gegen null getestet, direkt danach. Es ist nicht trivial, aber ich wäre nicht überrascht, wenn Optimierer fangen diese (auch 10 Jahre alt Optimierer könnte)
    • OK, mein Kommentar war auch veraltet durch meine änderung, weil rfind(s, 0) haben nicht, dieses problem in den ersten Platz. Ich scheine vergessen zu haben, um es zu löschen. Danke für den Hinweis, wie find könnte noch optimiert werden; ich war nicht bewusst, dass die Möglichkeit.
    • Wir haben keine Beweise, dass diese optimiert ist in den meisten Compilern? Ich finde nicht, anderswo zu erwähnen, entweder "Suche" oder "rfind" Optimierung ist die gemeinsame Praxis basiert auf dem return-Wert es überprüft wird.
    • An alle, es ist nicht ein billiges äquivalent zu string:finden.

    InformationsquelleAutor Ludovic Aubert
  3. 177

    Würden Sie es so machen:

    std::string prefix("--foo=");
if (!arg.compare(0, prefix.size(), prefix))
    foo_value = atoi(arg.substr(prefix.size()).c_str());

    Suchen für eine Bibliothek wie Boost.ProgramOptions, dass dies für Sie ist auch eine gute Idee.

    • Das größte problem mit diesem ist, dass atoi("123xyz") zurück 123, in der Erwägung, dass Python ' s int("123xyz") eine exception wirft.
    • Die Problemumgehung, die wir tun können, ist zu einer sscanf() und Vergleiche das Ergebnis und das original, um zu entscheiden, ob zu gehen oder eine Ausnahme auslösen.
    • Oder ersetzen Sie einfach atoi mit strtol oder strtoll werden, die uns erkennen Fehlerbedingungen in der input-Wert.
    InformationsquelleAutor Thomas
  4. 134

    Nur der Vollständigkeit halber erwähne ich das C Weg, es zu tun:

    Wenn str Ihre ursprünglichen Zeichenfolge substr ist die Zeichenkette, auf die Sie wollen
    check, dann

    strncmp(str, substr, strlen(substr))

    zurück 0 wenn str
    beginnt mit substr. Die Funktionen strncmp und strlen sind in der C
    header-Datei <string.h>

    (Zitat von Yasin Rauf hier, markup Hinzugefügt)

    Für eine groß- /Kleinschreibung-Vergleich, nutzen strnicmp statt strncmp.

    Dies ist das C Weg, es zu tun, für die C++ - strings können Sie verwenden die gleiche Funktion wie diese:

    strncmp(str.c_str(), substr.c_str(), substr.size())
    • in der Tat, jeder scheint nur zu gehen "boost" und ich bin dankbar für eine stl-oder OS-Bibliothek version
    InformationsquelleAutor Felix Dombek
  5. 79

    Code, den ich selbst benutze:

    std::string prefix = "-param=";
std::string argument = argv[1];
if(argument.substr(0, prefix.size()) == prefix) {
    std::string argumentValue = argument.substr(prefix.size());
}
    • die meisten prägnant und hängt nur von std::string, mit Ausnahme entfernen Sie die optionale und irreführende argument.size() am Ende der letzten substr.
    • Vielen Dank für das heads-up. Wusste nicht, es war freiwillig.
    • Mit substr führt zu unnötigen kopieren. Die str.compare(start, count, substr) Methode verwendet, die in Thomas' Antwort effizienter ist. razvanco13 Antwort hat eine andere Methode, die verhindert das kopieren von mit std::equal.
    • Thomas verwendet atoi, die ist nur für windows. Der Vergleich line können leicht geändert werden, um eine der diese zwei Antworten, wenn die Leistung ein Problem, was ich bezweifle, wäre für einen Betrieb über Kommandozeilen-Argumente.
    • verwendet atoi, die ist nur für windows Huh? atoi wurde ein C-standard-library-Funktion seit... immer. In der Tat atoi ist schlecht - nicht, weil es ist Windows-spezifisch ist, sondern weil es (1) C, nicht C++, und (2) veraltet, auch in C (Sie sollten mit strtol oder eine der anderen Funktionen. Da atoi hat keine Fehlerbehandlung. Aber, wieder, das ist nur in C sowieso).
    InformationsquelleAutor Hüseyin Yağlı
  6. 45

    Niemand verwendet die STL Algorithmus/mismatch Funktion noch nicht. Wenn diese true zurückgibt, Präfix ist ein Präfix von 'toCheck':

    std::mismatch(prefix.begin(), prefix.end(), toCheck.begin()).first == prefix.end()

    Vollständiges Beispiel prog:

    #include <algorithm>
#include <string>
#include <iostream>

int main(int argc, char** argv) {
    if (argc != 3) {
        std::cerr << "Usage: " << argv[0] << " prefix string" << std::endl
                  << "Will print true if 'prefix' is a prefix of string" << std::endl;
        return -1;
    }
    std::string prefix(argv[1]);
    std::string toCheck(argv[2]);
    if (prefix.length() > toCheck.length()) {
        std::cerr << "Usage: " << argv[0] << " prefix string" << std::endl
                  << "'prefix' is longer than 'string'" <<  std::endl;
        return 2;
    }
    if (std::mismatch(prefix.begin(), prefix.end(), toCheck.begin()).first == prefix.end()) {
        std::cout << '"' << prefix << '"' << " is a prefix of " << '"' << toCheck << '"' << std::endl;
        return 0;
    } else {
        std::cout << '"' << prefix << '"' << " is NOT a prefix of " << '"' << toCheck << '"' << std::endl;
        return 1;
    }
}

    Edit:

    Als @James T. Huggett schlägt vor, std::equal ist eine bessere Passform für die Frage: Ist Ein Präfix von B? und ist leicht kürzer-code:

    std::equal(prefix.begin(), prefix.end(), toCheck.begin())

    Vollständiges Beispiel prog:

    #include <algorithm>
#include <string>
#include <iostream>

int main(int argc, char **argv) {
  if (argc != 3) {
    std::cerr << "Usage: " << argv[0] << " prefix string" << std::endl
              << "Will print true if 'prefix' is a prefix of string"
              << std::endl;
    return -1;
  }
  std::string prefix(argv[1]);
  std::string toCheck(argv[2]);
  if (prefix.length() > toCheck.length()) {
    std::cerr << "Usage: " << argv[0] << " prefix string" << std::endl
              << "'prefix' is longer than 'string'" << std::endl;
    return 2;
  }
  if (std::equal(prefix.begin(), prefix.end(), toCheck.begin())) {
    std::cout << '"' << prefix << '"' << " is a prefix of " << '"' << toCheck
              << '"' << std::endl;
    return 0;
  } else {
    std::cout << '"' << prefix << '"' << " is NOT a prefix of " << '"'
              << toCheck << '"' << std::endl;
    return 1;
  }
}
    • Warum nicht std::equal?
    • Klingt gut für mich. Es wäre kürzer-code zu. Ich Schätze, ich werde haben, zu Bearbeiten, nun die Antwort :p
    • Mit std::equal für strings hat den Nachteil, dass es nicht erkennt die Zeichenfolge am Ende, so müssen Sie manuell überprüfen, ob das Präfix ist kürzer als der ganze string. (Als richtig gemacht in der Beispiel-prog, aber fehlt in der one-liner oben).
    • Also kein Vorteil gegenüber rfind?
    InformationsquelleAutor matiu
  7. 24

    Gegeben, dass beide Zeichenfolgen — argv[1] und "--foo" — sind C-strings, @FelixDombek Antwort ist die Hände-down die beste Lösung.

    Sehen die anderen Antworten, aber ich dachte es erwähnenswert, dass, wenn Ihr text bereits als ein std::string, dann eine einfache, null-Kopie, die maximal effiziente Lösung existiert, die noch nicht erwähnt wurde bisher:

    const char * foo = "--foo";
if (text.rfind(foo, 0) == 0)
    foo_value = text.substr(strlen(foo));

    Und wenn foo bereits ein string:

    std::string foo("--foo");
if (text.rfind(foo, 0) == 0)
    foo_value = text.substr(foo.length());
    • rfind(x, 0) == 0 sollte wirklich in der Norm definiert als starts_with
    • Nein, weil rfind() (statt startswith()) ist sehr ineffizient - es hält auf der Suche, bis das Ende der Zeichenfolge.
    • rfind(x) Durchsuchungen vom Ende bis zum Anfang, bis er eine findet x, in der Tat. Aber rfind(x,0) beginnt mit der Suche von Anfang an (position=0) bis zum start, so ist es nur sucht, wo es suchen muss; nicht die Suche von/bis zum Ende.
    InformationsquelleAutor Marcelo Cantos
  8. 11

    Verwendung von STL-dies Aussehen könnte:

    std::string prefix = "--foo=";
std::string arg = argv[1];
if (prefix.size()<=arg.size() && std::equal(prefix.begin(), prefix.end(), arg.begin())) {
  std::istringstream iss(arg.substr(prefix.size()));
  iss >> foo_value;
}
    • Das sollte if (prefix.size()<=arg.size() && std::equal(...)).
    InformationsquelleAutor razvanco13
  9. 9

    Auf die Gefahr geflamed zu werden für die Verwendung von C-Konstrukten, ich denke, das sscanf Beispiel ist eleganter als die meisten Boost-Lösungen. Und Sie müssen nicht sorgen zu machen über die Verknüpfung, wenn Sie überall, dass hat einen Python-interpreter!

    #include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
    for (int i = 1; i != argc; ++i) {
        int number = 0;
        int size = 0;
        sscanf(argv[i], "--foo=%d%n", &number, &size);
        if (size == strlen(argv[i])) {
            printf("number: %d\n", number);
        }
        else {
            printf("not-a-number\n");
        }
    }
    return 0;
}

    Hier einige Beispiel-Ausgabe zeigt, dass die Lösung verarbeitet leading/trailing garbage als richtig, wie die entsprechenden Python-code, und mehr richtig, als alles, was mit atoi (die fälschlicherweise ignorieren eine nicht-numerische suffix).

    $ ./scan --foo=2 --foo=2d --foo='2 ' ' --foo=2'
number: 2
not-a-number
not-a-number
not-a-number
    • Wenn argv[i] ist "--foo=9999999999999999999999999", das Verhalten ist nicht definiert, (obwohl die meisten oder alle Implementierungen Verhalten sollte sanely). Ich gehe davon aus 9999999999999999999999999 > INT_MAX.
    InformationsquelleAutor Tom
  10. 9
    text.substr(0, start.length()) == start
    InformationsquelleAutor Macsinus
  11. 8

    Mit C++17, die Sie verwenden können std::basic_string_view & mit C++20 std::basic_string::starts_with oder std::basic_string_view::starts_with.

    Nutzen std::string_view im Vergleich zu std::string - in Bezug auf Speicher-management - ist, dass es hält nur ein Zeiger auf einen "string" (zusammenhängende Sequenz von char-ähnlichen Objekte) und kennt seine Größe. Beispiel ohne verschieben/kopieren die Quell-strings, nur um mit den integer-Wert:

    #include <string_view>
#include <exception>
#include <iostream>

const char * argument = "--foo=42"; //Emulating command argument.
const char * argumentPrefix = "--foo";
int inputValue = 0;

std::string_view argView = argument;
if (argView.starts_with(argumentPrefix))
{
    std::string_view prefixView = argumentPrefix; //Helper for getting the size of argumentPrefix.
    try
    {
        //The underlying data of argView is nul-terminated, therefore we can use data().
        inputValue = std::atoi(argView.substr(prefixView.size() + 1).data());
    }
    catch (std::exception& e)
    {
        std::cerr << e.what();
    }
}
    InformationsquelleAutor Roi Danton
  12. 7

    Benutze ich std::string::compare verpackt in utility-Methode wie folgt:

    static bool startsWith(const string& s, const string& prefix) {
    return s.size() >= prefix.size() && s.compare(0, prefix.size(), prefix) == 0;
}
    InformationsquelleAutor Shital Shah
  13. 5

    Warum nicht gnu getopts? Hier ist ein einfaches Beispiel (ohne Sicherheitsprüfung):

    #include <getopt.h>
#include <stdio.h>

int main(int argc, char** argv)
{
  option long_options[] = {
    {"foo", required_argument, 0, 0},
    {0,0,0,0}
  };

  getopt_long(argc, argv, "f:", long_options, 0);

  printf("%s\n", optarg);
}

    Für den folgenden Befehl ein:

    $ ./a.out --foo=33

    Erhalten Sie

    33
    InformationsquelleAutor Carl Cook
  14. 3

    In Fall müssen Sie die C++11-Kompatibilität und nicht die Verwendung von boost, hier ist eine boost-kompatibel drop-in mit einem Beispiel der Nutzung:

    #include <iostream>
#include <string>

static bool starts_with(const std::string str, const std::string prefix)
{
    return ((prefix.size() <= str.size()) && std::equal(prefix.begin(), prefix.end(), str.begin()));
}

int main(int argc, char* argv[])
{
    bool usage = false;
    unsigned int foos = 0; //default number of foos if no parameter was supplied

    if (argc > 1)
    {
        const std::string fParamPrefix = "-f="; //shorthand for foo
        const std::string fooParamPrefix = "--foo=";

        for (unsigned int i = 1; i < argc; ++i)
        {
            const std::string arg = argv[i];

            try
            {
                if ((arg == "-h") || (arg == "--help"))
                {
                    usage = true;
                } else if (starts_with(arg, fParamPrefix)) {
                    foos = std::stoul(arg.substr(fParamPrefix.size()));
                } else if (starts_with(arg, fooParamPrefix)) {
                    foos = std::stoul(arg.substr(fooParamPrefix.size()));
                }
            } catch (std::exception& e) {
                std::cerr << "Invalid parameter: " << argv[i] << std::endl << std::endl;
                usage = true;
            }
        }
    }

    if (usage)
    {
        std::cerr << "Usage: " << argv[0] << " [OPTION]..." << std::endl;
        std::cerr << "Example program for parameter parsing." << std::endl << std::endl;
        std::cerr << "  -f, --foo=N   use N foos (optional)" << std::endl;
        return 1;
    }

    std::cerr << "number of foos given: " << foos << std::endl;
}
    InformationsquelleAutor vallismortis
  15. 2

    Können Sie auch strstr:

    if (strstr(str, substr) == substr) {
    //'str' starts with 'substr'
}

    aber ich denke, es ist nur gut für kurze strings, da hat es eine Schleife über den gesamten string, wenn der string nicht tatsächlich beginnen mit 'substr'.

    InformationsquelleAutor szx
  16. 2

    Ok, warum die komplizierte Nutzung von Bibliotheken und Sachen? C++ String-Objekte überladen des [] - operator, so können Sie einfach vergleichen chars.. Wie das, was ich gerade getan habe, weil ich will, um eine Liste aller Dateien in einem Verzeichnis und ignoriert die unsichtbaren Dateien und .. und . pseudofiles. 

    while ((ep = readdir(dp)))
{
    string s(ep->d_name);
    if (!(s[0] == '.')) //Omit invisible files and .. or .
        files.push_back(s);
}

    So einfach ist das..

    InformationsquelleAutor Nils
  17. 1
    std::string text = "--foo=98";
std::string start = "--foo=";

if (text.find(start) == 0)
{
    int n = stoi(text.substr(start.length()));
    std::cout << n << std::endl;
}
    • Es wäre toll, wenn Sie vermeiden, einfügen von code ohne code-Erklärung. Danke.
    • Ineffizienter code, wäre weiterhin auf der Suche nach dem Anfang des Strings.
    InformationsquelleAutor mois
  18. 1

    Seit C++11 auch std::regex_search verwendet werden kann, z.B. wie folgt (eine leere Zeichenfolge zurück, im Fehlerfall):

    #include <regex>

std::string startsWith(const std::string &str, const std::string &prefix) {
  std::smatch match;
  std::regex_search(str, match, std::regex("^" + prefix));
  return match.suffix();
}
    • Es wird nicht funktionieren, wenn Sie nicht entkommen Präfix ersten.
    InformationsquelleAutor alextoind
  19. 0

    Mit C++11 oder höher können Sie find() und find_first_of()

    Beispiel für die Verwendung finden, um einen einzigen char:

    #include <string>
std::string name = "Aaah";
size_t found_index = name.find('a');
if (found_index != std::string::npos) {
    //Found string containing 'a'
}

    Beispiel für die Verwendung finden, zu finden, eine vollständige Zeichenfolge & ab der position 5:

    std::string name = "Aaah";
size_t found_index = name.find('h', 3);
if (found_index != std::string::npos) {
    //Found string containing 'h'
}

    Beispiel für die Verwendung der find_first_of() und nur den ersten char zu suchen, der am Anfang nur:

    std::string name = ".hidden._di.r";
size_t found_index = name.find_first_of('.');
if (found_index == 0) {
    //Found '.' at first position in string
}

    Glück!

    InformationsquelleAutor danger89
  20. -3
    if(boost::starts_with(string_to_search, string_to_look_for))
    intval = boost::lexical_cast<int>(string_to_search.substr(string_to_look_for.length()));

    Dies ist völlig ungetestet. Das Prinzip ist das gleiche wie der Python-Version. Erfordert Steigern.StringAlgo und zu Steigern.LexicalCast.

    Prüfen, ob der string beginnt mit der anderen Schnur, und dann Holen Sie sich die substring ('slice') des ersten string ein und wandeln es mithilfe von lexikalischen Besetzung.

    InformationsquelleAutor blwy10
Schreibe einen Kommentar