Comment puis-je vérifier si une chaîne std :: C ++ commence par une certaine chaîne et convertir une sous-chaîne en int?

Comment implémenter les éléments suivants (pseudocode Python) en C ++?

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

(Par exemple, si argv[1]c'est le cas --foo=98, alors l' foo_valueest 98.)

Mise à jour: j'hésite à étudier Boost, car je cherche simplement à apporter une toute petite modification à un simple petit outil en ligne de commande (je préfère ne pas avoir à apprendre à me connecter et à utiliser Boost pour un mineur changement).

Utilisez une surcharge rfinddont le posparamètre est:

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

Qui a besoin d'autre chose? Pure STL!

Beaucoup ont mal interprété cela pour signifier "rechercher en arrière dans toute la chaîne à la recherche du préfixe". Cela donnerait le mauvais résultat (par exemple string("tititito").rfind("titi")retourne 2 donc par rapport à contre == 0retournerait faux) et ce serait inefficace (regarder à travers la chaîne entière au lieu du simple début). Mais il ne le fait pas car il transmet le posparamètre as 0, ce qui limite la recherche à une correspondance uniquement à cette position ou plus tôt . Par exemple:

std::string test = "0123123";
size_t match1 = test.rfind("123");    // returns 4 (rightmost match)
size_t match2 = test.rfind("123", 2); // returns 1 (skipped over later match)
size_t match3 = test.rfind("123", 0); // returns std::string::npos (i.e. not found)

Vous le feriez comme ceci:

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

La recherche d'une bibliothèque telle que Boost.ProgramOptions qui le fait pour vous est également une bonne idée.

Juste pour être complet, je mentionnerai la manière C de le faire:

Si strest votre chaîne d'origine, substrest la sous-chaîne que vous souhaitez vérifier, puis

strncmp(str, substr, strlen(substr))

reviendra 0si str commence par substr. Les fonctions strncmpet strlensont dans le fichier d'en-tête C<string.h>

^{(initialement publié par Yaseen Rauf ici , balisage ajouté)}

Pour une comparaison insensible à la casse, utilisez strnicmpau lieu de strncmp.

C'est la façon C de le faire, pour les chaînes C ++, vous pouvez utiliser la même fonction comme ceci:

strncmp(str.c_str(), substr.c_str(), substr.size())

Si vous utilisez déjà Boost, vous pouvez le faire avec des algorithmes de chaîne boost + boost cast lexical:

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

Ce type d'approche, comme la plupart des autres réponses fournies ici, convient aux tâches très simples, mais à long terme, il est généralement préférable d'utiliser une bibliothèque d'analyse de ligne de commande. Boost en a un ( Boost.Program_options ), ce qui peut avoir du sens si vous utilisez déjà Boost.

Sinon, une recherche de «analyseur de ligne de commande c ++» donnera un certain nombre d'options.

Code que j'utilise moi-même:

std::string prefix = "-param=";
std::string argument = argv[1];
if(argument.substr(0, prefix.size()) == prefix) {
    std::string argumentValue = argument.substr(prefix.size());
}

Personne n'a encore utilisé l' algorithme STL / la fonction de non-concordance . Si cela retourne vrai, prefix est un préfixe de 'toCheck':

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

Exemple de prog complet:

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

Éditer:

Comme le suggère @James T. Huggett, std :: equal est mieux adapté à la question: A est-il un préfixe de B? et est un code légèrement plus court:

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

Exemple de prog complet:

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

Étant donné que les deux chaînes - argv[1]et "--foo"- sont des chaînes C, @ FelixDombek's answer la meilleure solution.

En voyant les autres réponses, cependant, j'ai pensé qu'il valait la peine de noter que, si votre texte est déjà disponible en tant que std::string, il existe une solution simple, sans copie et à efficacité maximale qui n'a pas été mentionnée jusqu'à présent:

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

Et si foo est déjà une chaîne:

std::string foo("--foo");
if (text.rfind(foo, 0) == 0)
    foo_value = text.substr(foo.length());

Avec C ++ 17, vous pouvez utiliser std::basic_string_view& avec C ++ 20 std::basic_string::starts_withou std::basic_string_view::starts_with.

L'avantage de std::string_viewpar rapport à std::string- en ce qui concerne la gestion de la mémoire - est qu'il ne détient qu'un pointeur vers une "chaîne" (séquence contiguë d'objets de type char) et connaît sa taille. Exemple sans déplacer / copier les chaînes source juste pour obtenir la valeur entière:

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

int main()
{
    constexpr auto argument = "--foo=42"; // Emulating command argument.
    constexpr auto prefix = "--foo=";
    auto inputValue = 0;

    constexpr auto argumentView = std::string_view(argument);
    if (argumentView.starts_with(prefix))
    {
        constexpr auto prefixSize = std::string_view(prefix).size();
        try
        {
            // The underlying data of argumentView is nul-terminated, therefore we can use data().
            inputValue = std::stoi(argumentView.substr(prefixSize).data());
        }
        catch (std::exception & e)
        {
            std::cerr << e.what();
        }
    }
    std::cout << inputValue; // 42
}

text.substr(0, start.length()) == start

En utilisant STL, cela pourrait ressembler à:

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

Au risque d'être critiqué pour l'utilisation de constructions C, je pense que cet sscanfexemple est plus élégant que la plupart des solutions Boost. Et vous n'avez pas à vous soucier de la liaison si vous exécutez n'importe où qui a un interpréteur Python!

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

Voici un exemple de sortie qui montre que la solution gère les ordures de début / fin aussi correctement que le code Python équivalent, et plus correctement que tout ce qui utilise atoi(qui ignorera par erreur un suffixe non numérique).

$ ./scan --foo=2 --foo=2d --foo='2 ' ' --foo=2'
number: 2
not-a-number
not-a-number
not-a-number

J'utilise std::string::compareenveloppé dans une méthode utilitaire comme ci-dessous:

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

Pourquoi ne pas utiliser les getopts gnu? Voici un exemple de base (sans contrôles de sécurité):

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

Pour la commande suivante:

$ ./a.out --foo=33

Tu auras

33

Dans le cas où vous avez besoin de la compatibilité C ++ 11 et ne pouvez pas utiliser boost, voici un drop-in compatible avec boost avec un exemple d'utilisation:

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

Vous pouvez également utiliser strstr:

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

mais je pense que c'est bon uniquement pour les chaînes courtes, car il doit parcourir toute la chaîne lorsque la chaîne ne commence pas réellement par «substr».

Ok pourquoi l'utilisation compliquée des bibliothèques et des trucs? Les objets C ++ String surchargent l'opérateur [], vous pouvez donc simplement comparer les caractères .. Comme ce que je viens de faire, car je veux répertorier tous les fichiers dans un répertoire et ignorer les fichiers invisibles et les .. et. pseudofiles.

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

C'est si simple..

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

Avec C ++ 11 ou supérieur, vous pouvez utiliser find()etfind_first_of()

Exemple utilisant find pour trouver un seul caractère:

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

Exemple utilisant find pour trouver une chaîne complète et à partir de la position 5:

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

Exemple utilisant le find_first_of()et uniquement le premier caractère, pour rechercher uniquement au début:

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

• En savoir plus sur find
• En savoir plus sur find_first_of

Bonne chance!

Depuis C ++ 11 std::regex_searchpeut également être utilisé pour fournir des expressions encore plus complexes. L'exemple suivant gère également les nombres flottants std::stofet une conversion ultérieure enint .

Cependant, la parseIntméthode illustrée ci-dessous peut lever une std::invalid_argumentexception si le préfixe n'est pas mis en correspondance; cela peut être facilement adapté en fonction de l'application donnée:

#include <iostream>
#include <regex>

int parseInt(const std::string &str, const std::string &prefix) {
  std::smatch match;
  std::regex_search(str, match, std::regex("^" + prefix + "([+-]?(?=\\.?\\d)\\d*(?:\\.\\d*)?(?:[Ee][+-]?\\d+)?)$"));
  return std::stof(match[1]);
}

int main() {
    std::cout << parseInt("foo=13.3", "foo=") << std::endl;
    std::cout << parseInt("foo=-.9", "foo=") << std::endl;
    std::cout << parseInt("foo=+13.3", "foo=") << std::endl;
    std::cout << parseInt("foo=-0.133", "foo=") << std::endl;
    std::cout << parseInt("foo=+00123456", "foo=") << std::endl;
    std::cout << parseInt("foo=-06.12e+3", "foo=") << std::endl;

//    throw std::invalid_argument
//    std::cout << parseInt("foo=1", "bar=") << std::endl;

    return 0;
}

Le type de magie du modèle d'expression régulière est bien détaillé dans la réponse suivante .

EDIT: la réponse précédente n'a pas effectué la conversion en entier.

À partir de C ++ 20, vous pouvez utiliser la starts_withméthode.

std::string s = "abcd";
if (s.starts_with("abc")) {
    ...
}

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

Ceci est complètement non testé. Le principe est le même que celui de Python. Nécessite Boost.StringAlgo et Boost.LexicalCast.

Vérifiez si la chaîne commence par l'autre chaîne, puis récupérez la sous-chaîne («tranche») de la première chaîne et convertissez-la à l'aide d'une conversion lexicale.