Как проверить, начинается ли строка C++ std::string с определенной строки, и преобразовать подстроку в int?
Как мне реализовать следующее (псевдокод Python) в C++?
if argv[1].startswith('--foo='):
foo_value = int(argv[1][len('--foo='):])
(Например, если argv[1] является --foo=98, затем foo_value является 98.)
Обновление: я не решаюсь взглянуть на Boost, так как я просто смотрю на внесение очень небольших изменений в простой маленький инструмент командной строки (я бы предпочел не учиться связывать и использовать Boost для незначительного менять).
25 ответов
Если вы используете Boost, вы можете сделать это с помощью алгоритмов boost string + 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
}
Как и большинство библиотек надстроек, строковый алгоритм и лексическое приведение только для заголовков, в них нет ничего для ссылки.
Такой подход, как и многие другие ответы, представленные здесь, подходит для очень простых задач, но в долгосрочной перспективе вам обычно лучше использовать библиотеку синтаксического анализа командной строки. Boost имеет один ( Boost.Program_options), который может иметь смысл, если вы уже используете Boost.
В противном случае поиск "синтаксического анализатора командной строки C++" даст ряд опций.
std::string s = "tititoto";
if (s.rfind("titi", 0) == 0) {
// s starts with prefix
}
Кому еще что-нибудь нужно? Чистый STL!
Вы бы сделали это так:
std::string prefix("--foo=");
if (!arg.compare(0, prefix.size(), prefix))
foo_value = atoi(arg.substr(prefix.size()).c_str());
Поиск библиотеки, такой как Boost.ProgramOptions, которая делает это для вас, также является хорошей идеей.
Просто для полноты я упомяну способ C сделать это:
Если
strваша оригинальная строка,substrподстрока, которую вы хотите проверить, тогда
strncmp(str, substr, strlen(substr))вернусь
0еслиstrначинается сsubstr, Функцииstrncmpа такжеstrlenнаходятся в заголовочном файле C<string.h>
(первоначально размещено здесь Ясином Рауфом, добавлена разметка)
Для сравнения без учета регистра используйте strnicmp вместо strncmp,
Это способ C, для строк C++ вы можете использовать одну и ту же функцию следующим образом:
strncmp(str.c_str(), substr.c_str(), substr.size())
Код я использую сам:
std::string prefix = "-param=";
std::string argument = argv[1];
if(argument.substr(0, prefix.size()) == prefix) {
std::string argumentValue = argument.substr(prefix.size());
}
Никто еще не использовал алгоритм STL / функцию несовпадения. Если это возвращает true, префикс является префиксом 'toCheck':
std::mismatch(prefix.begin(), prefix.end(), toCheck.begin()).first == prefix.end()
Полный пример проги:
#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;
}
}
Редактировать:
Как предполагает @James Т. Huggett, std::equal лучше подходит для вопроса: является ли A префиксом B? и немного короче код:
std::equal(prefix.begin(), prefix.end(), toCheck.begin())
Полный пример проги:
#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;
}
}
С C++17 вы можете использовать std::basic_string_view & с C++20 std::basic_string::starts_with или же std::basic_string_view::starts_with,
Преимущество std::string_view по сравнению с std::string - в отношении управления памятью - это то, что он содержит только указатель на "строку" (непрерывную последовательность объектов, похожих на символы) и знает ее размер. Пример без перемещения / копирования исходных строк только для получения целочисленного значения:
#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();
}
}
Учитывая, что обе строки - argv[1] а также "--foo" - являются C-струнами, ответ @FelixDombek - это лучшее решение.
Видя другие ответы, я подумал, что стоит отметить, что если ваш текст уже доступен в виде std::stringзатем существует простое, максимально эффективное решение, которое до сих пор не упоминалось:
const char * foo = "--foo";
if (text.rfind(foo, 0) == 0)
foo_value = text.substr(strlen(foo));
И если foo уже является строкой:
std::string foo("--foo");
if (text.rfind(foo, 0) == 0)
foo_value = text.substr(foo.length());
Начиная с C++20, вы можете использовать starts_with метод.
std::string s = "abcd";
if (s.starts_with("abc")) {
...
}
Обновление C++ 20:
- Использовать
std::string::starts_with
https://en.cppreference.com/w/cpp/string/basic_string/starts_with
std::string str_value = /* smthg */;
const auto starts_with_foo = str_value.starts_with(std::string_view{"foo"});
При использовании STL это может выглядеть так:
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;
}
Я использую std::string::compare завернутый в полезный метод, как показано ниже:
static bool startsWith(const string& s, const string& prefix) {
return s.size() >= prefix.size() && s.compare(0, prefix.size(), prefix) == 0;
}
Риск быть воспламененным для использования конструкций C, я думаю, что это sscanf Пример более элегантный, чем большинство решений Boost. И вам не нужно беспокоиться о связях, если вы работаете в любом месте, где есть интерпретатор 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;
}
Вот некоторые примеры выходных данных, которые демонстрируют, что решение обрабатывает начальный / конечный мусор так же правильно, как эквивалентный код Python, и более правильно, чем что-либо, использующее atoi (который будет ошибочно игнорировать нечисловой суффикс).
$ ./scan --foo=2 --foo=2d --foo='2 ' ' --foo=2'
number: 2
not-a-number
not-a-number
not-a-number
В C++20 теперь есть start_with, доступная как функция-член, определенная как:
constexpr bool start_with (string_view sv) const noexcept;
constexpr bool start_with (CharT c) const noexcept;
constexpr bool start_with(const CharT* s) const;
Итак, ваш код может быть примерно таким:
std::string s{argv[1]};
if (s.starts_with("--foo="))
Если вам нужна совместимость с C++11 и вы не можете использовать boost, вот буст-совместимое раскрывающееся окно с примером использования:
#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;
}
Почему бы не использовать GNU Getopts? Вот базовый пример (без проверок безопасности):
#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);
}
Для следующей команды:
$ ./a.out --foo=33
Ты получишь
33
Хорошо, почему сложное использование библиотек и прочего? Строковые объекты C++ перегружают оператор [], так что вы можете просто сравнивать символы.. Как и я, потому что я хочу перечислить все файлы в каталоге и игнорировать невидимые файлы и... и. pseudofiles.
while ((ep = readdir(dp)))
{
string s(ep->d_name);
if(!(s[0] == '.')) // Omit invisible files and .. or .
files.push_back(s);
}
Это так просто..
С C++11 или выше вы можете использовать find() а также find_first_of()
Пример использования find для поиска одного символа:
#include <string>
std::string name = "Aaah";
size_t found_index = name.find('a');
if (found_index != std::string::npos) {
// Found string containing 'a'
}
Пример использования find для поиска полной строки, начиная с позиции 5:
std::string name = "Aaah";
size_t found_index = name.find('h', 3);
if (found_index != std::string::npos) {
// Found string containing 'h'
}
Пример использования find_first_of() и только первый символ, только для поиска в начале:
std::string name = ".hidden._di.r";
size_t found_index = name.find_first_of('.');
if (found_index == 0) {
// Found '.' at first position in string
}
Удачи!
Вы также можете использовать strstr:
if (strstr(str, substr) == substr) {
// 'str' starts with 'substr'
}
но я думаю, что это хорошо только для коротких строк, потому что он должен перебирать всю строку, когда строка на самом деле не начинается с 'substr'.
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;
}
Поскольку в C++11 также можно использовать std::regex_search, например, следующим образом (при ошибке возвращает пустую строку):
#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();
}
С++20, используйтеs.starts_with(), см. ссылку для примеров:
https://en.cppreference.com/w/cpp/string/basic_string/starts_with
Хотя я и опоздал на вечеринку на 8 лет, вот самый простой способ сделать это самостоятельно:
#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!
}
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()));
Это полностью не проверено. Принцип такой же, как у Python. Требуются Boost.StringAlgo и Boost.LexicalCast.
Проверьте, начинается ли строка с другой строки, а затем получите подстроку ('slice') первой строки и преобразуйте ее, используя лексическое приведение.