Wie überprüfe ich, ob ein C ++ & lt; String & gt; beginnt mit einer bestimmten Zeichenfolge und konvertiert eine Teilzeichenfolge in ein int?

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.

InformationsquelleAutor der Antwort Thomas

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

Wer braucht noch was? Reine STL!

InformationsquelleAutor der Antwort user3046585

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

InformationsquelleAutor der Antwort matiu

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

InformationsquelleAutor der Antwort Tom

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 der Antwort Carl Cook

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 der Antwort szx

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

InformationsquelleAutor der Antwort mois

zwar bin ich 8 Jahre zu spät auf die party, hier ist die einfachste do-it-yourself Weg, es zu tun:

#include <iostream>
#include <string>

using namespace std; //for clarity's sake.

bool startswith(string prefix, string text) {
    if (prefix.length() > 0 && text.length() > prefix.length()) {
        int i = 0;
        while (i < prefix.length()) {
            if (text[i] != prefix[i]) return false;
            i++;
        }
        return true;
    }

    else return false;
}

int main (int argc, char* argv) {
    if(startswith("--foo=", argv[1]))
        //do something about it!
}

InformationsquelleAutor der Antwort 7kemZmani

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();
}

InformationsquelleAutor der Antwort alextoind