Bagaimana cara memeriksa apakah string C ++ std :: dimulai dengan string tertentu, dan mengonversi substring ke int?

Bagaimana cara menerapkan yang berikut (Python pseudocode) di C ++?

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

(Misalnya, jika argv[1]ada --foo=98, maka foo_valueadalah 98.)

Pembaruan: Saya ragu-ragu untuk melihat Boost, karena saya hanya ingin membuat perubahan kecil ke alat command-line kecil yang sederhana (saya lebih suka tidak harus belajar cara menautkan dan menggunakan Boost untuk anak di bawah umur perubahan).

Gunakan kelebihan rfindyang memiliki posparameter:

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

Siapa yang butuh yang lain? STL murni!

Banyak yang salah membaca ini berarti "mencari mundur seluruh string mencari awalan". Itu akan memberikan hasil yang salah (misalnya string("tititito").rfind("titi")mengembalikan 2 sehingga bila dibandingkan terhadap == 0akan kembali salah) dan itu akan menjadi tidak efisien (melihat seluruh string bukan hanya awal). Tapi itu tidak melakukan itu karena melewati posparameter sebagai 0, yang membatasi pencarian hanya cocok pada posisi itu atau sebelumnya . Sebagai contoh:

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)

Anda akan melakukannya seperti ini:

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

Mencari lib seperti Boost.ProgramOptions yang melakukan ini untuk Anda juga merupakan ide yang bagus.

Hanya untuk kelengkapan, saya akan menyebutkan cara C untuk melakukannya:

Jika strstring asli Anda, substrapakah substring yang ingin Anda periksa, maka

strncmp(str, substr, strlen(substr))

akan kembali 0jika str dimulai dengan substr. Fungsi strncmpdan strlenberada di file header C.<string.h>

^{(awalnya diposting oleh Yaseen Rauf di sini , markup ditambahkan)}

Untuk perbandingan case-insensitive, gunakan strnicmpsebagai ganti strncmp.

Ini adalah cara C untuk melakukannya, untuk string C ++ Anda dapat menggunakan fungsi yang sama seperti ini:

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

Jika Anda sudah menggunakan Boost, Anda bisa melakukannya dengan meningkatkan algoritma string + 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
}

Pendekatan semacam ini, seperti banyak jawaban lain yang disediakan di sini adalah ok untuk tugas yang sangat sederhana, tetapi dalam jangka panjang Anda biasanya lebih baik menggunakan parsing library baris perintah. Boost memiliki satu ( Boost.Program_options ), yang mungkin masuk akal jika Anda sudah menggunakan Boost.

Kalau tidak, pencarian untuk "c ++ command line parser" akan menghasilkan sejumlah opsi.

Kode yang saya gunakan sendiri:

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

Belum ada yang menggunakan fungsi algoritma / ketidakcocokan STL . Jika ini mengembalikan true, awalan adalah awalan dari 'toCheck':

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

Contoh lengkap 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:

Seperti yang disarankan @James T. Huggett, std :: equal lebih cocok untuk pertanyaan: Apakah A awalan B? dan kode sedikit lebih pendek:

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

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

Mengingat bahwa kedua string - argv[1]dan "--foo"- adalah string C, jawaban @ FelixDombek adalah solusi terbaik.

Namun, melihat jawaban lain, saya pikir perlu dicatat bahwa, jika teks Anda sudah tersedia sebagai std::string, maka ada solusi sederhana, tanpa salinan, dan efisien maksimal yang belum disebutkan sejauh ini:

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

Dan jika foo sudah menjadi string:

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

Dengan C ++ 17 Anda dapat menggunakan std::basic_string_view& dengan C ++ 20 std::basic_string::starts_withatau std::basic_string_view::starts_with.

Manfaat std::string_viewdibandingkan dengan std::string- mengenai manajemen memori - adalah bahwa ia hanya memegang pointer ke "string" (urutan berdekatan objek seperti char) dan tahu ukurannya. Contoh tanpa memindahkan / menyalin string sumber hanya untuk mendapatkan nilai integer:

#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

Menggunakan STL ini bisa terlihat seperti:

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

Dengan risiko dinyalakan karena menggunakan konstruksi C, saya pikir sscanfcontoh ini lebih elegan daripada kebanyakan solusi Peningkatan. Dan Anda tidak perlu khawatir tentang hubungan jika Anda menjalankan di mana saja yang memiliki juru bahasa 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;
}

Berikut adalah beberapa contoh output yang menunjukkan solusi menangani terkemuka / trailing sampah dengan benar sebagai kode Python yang setara, dan lebih tepat daripada apa pun yang menggunakan atoi(yang keliru mengabaikan akhiran non-numerik).

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

Saya menggunakan std::string::comparemetode utilitas terbungkus seperti di bawah ini:

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

Mengapa tidak menggunakan getah gnu? Inilah contoh dasar (tanpa pemeriksaan keamanan):

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

Untuk perintah berikut:

$ ./a.out --foo=33

Kamu akan mendapatkan

33

Jika Anda membutuhkan kompatibilitas C ++ 11 dan tidak dapat menggunakan boost, berikut adalah drop-in yang kompatibel dengan boost dengan contoh penggunaan:

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

Anda juga dapat menggunakan strstr:

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

tapi saya pikir itu bagus hanya untuk string pendek karena harus mengulang seluruh string ketika string tidak benar-benar dimulai dengan 'substr'.

Ok mengapa rumit menggunakan perpustakaan dan barang-barang? C ++ String objek membebani operator [], jadi Anda bisa membandingkan karakter .. Seperti yang baru saja saya lakukan, karena saya ingin membuat daftar semua file dalam direktori dan mengabaikan file yang tidak terlihat dan .. dan. pseudofil.

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

Sesederhana itu ..

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

Dengan C ++ 11 atau lebih tinggi, Anda dapat menggunakan find()danfind_first_of()

Contoh menggunakan find untuk menemukan char tunggal:

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

Contoh menggunakan find untuk menemukan string penuh & mulai dari posisi 5:

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

Contoh menggunakan find_first_of()dan hanya karakter pertama, untuk mencari di awal saja:

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

• Lebih lanjut tentang temukan
• Lebih lanjut tentang find_first_of

Semoga berhasil!

Karena C ++ 11 std::regex_searchjuga dapat digunakan untuk memberikan pencocokan ekspresi yang lebih kompleks. Contoh berikut ini menangani juga angka mengambang thorugh std::stofdan pemain berikutnyaint .

Namun parseIntmetode yang ditunjukkan di bawah ini bisa melempar std::invalid_argumentpengecualian jika awalan tidak cocok; ini dapat dengan mudah disesuaikan tergantung pada aplikasi yang diberikan:

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

Jenis sulap dari pola regex terinci dengan baik dalam jawaban berikut .

EDIT: jawaban sebelumnya tidak melakukan konversi ke bilangan bulat.

Dimulai dengan C ++ 20, Anda dapat menggunakan starts_withmetode ini.

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

Ini sama sekali belum diuji. Prinsipnya sama dengan yang Python. Membutuhkan Boost.StringAlgo dan Boost.LexicalCast.

Periksa apakah string dimulai dengan string lain, lalu dapatkan substring ('slice') dari string pertama dan konversikan menggunakan lexical cast.