¿Cómo puedo comprobar si un C++ comienza con una cadena determinada y convertir una subcadena en una int?

Lo harías así:

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

Buscando una lib como Boost.ProgramOptions que hace esto por usted también es una buena idea.

Solo para completar, mencionaré la forma C de hacerlo:

Si str es su cadena original, substr es la subcadena que desea control, entonces

strncmp(str, substr, strlen(substr))

Volverá 0 si str comienza con substr. Las funciones strncmp y strlen están en la C archivo de cabecera <string.h>

^{(publicado originalmente por Yaseen Rauf aquí , marcado añadido)}

Para una comparación que no distingue entre mayúsculas y minúsculas, use strnicmp en lugar de strncmp.

Esta es la forma en C de hacerlo, para las cadenas de C++ puede usar la misma función de esta manera:

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

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

¿Quién necesita algo más? ¡Pure STL!

Código que uso yo mismo:

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

Nadie usó la función STL algorithm/mismatch todavía. Si esto devuelve true, prefix es un prefijo de 'toCheck':

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

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

Editar:

Como sugiere @James T. Huggett, std::equal es una mejor opción para la pregunta: ¿Es A un prefijo de B? y es un código ligeramente más corto:

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

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

Dado que ambas cadenas - argv[1] y "--foo" - son cadenas C, La respuesta de@FelixDombek es sin duda la mejor solución.

Al ver las otras respuestas, sin embargo, pensé que vale la pena señalar que, si su texto ya está disponible como std::string, entonces existe una solución simple, de copia cero y máxima eficiencia que no se ha mencionado hasta ahora:

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

Y si foo ya es una cadena:

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

A riesgo de ser flameado por usar construcciones C, creo que este ejemplo sscanf es más elegante que la mayoría de las soluciones Boost. ¡Y no tiene que preocuparse por la vinculación si se está ejecutando en cualquier lugar que tenga un intérprete de 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;
}

Aquí hay un ejemplo de salida que demuestra que la solución maneja la basura inicial/final tan correctamente como el código Python equivalente, y más correctamente que cualquier cosa que use atoi (que ignorará erróneamente un sufijo no numérico).

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

Usando STL esto podría verse como:

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

¿Por qué no usar gnu getopts? He aquí un ejemplo básico (sin controles de seguridad):

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

Para el siguiente comando:

$ ./a.out --foo=33

Obtendrá

33

Utilizo std::string::compare envuelto en el método de utilidad como a continuación:

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

También puedes usar strstr:

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

Pero creo que es bueno solo para cadenas cortas porque tiene que recorrer toda la cadena cuando la cadena no comienza realmente con 'substr'.

Ok ¿por qué el uso complicado de las bibliotecas y esas cosas? Los objetos de cadena de C++ sobrecargan el operador [], por lo que solo puede comparar caracteres.. Como lo que acabo de hacer, porque quiero enumerar todos los archivos en un directorio e ignorar los archivos invisibles y el.. y . pseudofiles.

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

Es así de 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;
}

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

Con C++17 puede utilizar std::basic_string_view & con C++20 std::basic_string::starts_with o std::basic_string_view::starts_with.

El beneficio de std::string_view en comparación con std::string - con respecto a la gestión de memoria - es que solo tiene un puntero a una "cadena" (secuencia contigua de objetos similares a char) y conoce su tamaño. Ejemplo sin mover / copiar las cadenas de origen solo para obtener el valor entero:

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

Aunque llego 8 años tarde a la fiesta, aquí está la forma más simple de hacerlo:

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

Desde C++11 también std:: regex_search se puede usar, por ejemplo, de la siguiente manera (devuelve una cadena vacía si falla):

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

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

Esto no ha sido probado. El principio es el mismo que el de Python. Requiere Impulso.StringAlgo y Boost.LexicalCast.

Compruebe si la cadena comienza con la otra cadena, y luego obtenga la subcadena ('slice') de la primera cadena y conviértala usando un molde léxico.