ฉันจะตรวจสอบว่าสตริง C ++ std :: เริ่มต้นด้วยสตริงที่แน่นอนและแปลงสตริงย่อยเป็น int ได้อย่างไร

ฉันจะใช้สิ่งต่อไปนี้ (Python pseudocode) ใน C ++ ได้อย่างไร

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

(ตัวอย่างเช่นถ้าargv[1]เป็น--foo=98เช่นนั้นfoo_valueคือ98)

อัปเดต:ฉันลังเลที่จะดู Boost เนื่องจากฉันแค่มองการเปลี่ยนแปลงเล็กน้อยเป็นเครื่องมือบรรทัดคำสั่งเล็ก ๆ น้อย ๆ (ฉันไม่ต้องการเรียนรู้วิธีเชื่อมโยงและใช้ Boost สำหรับผู้เยาว์ การเปลี่ยนแปลง)

ใช้โอเวอร์โหลดrfindที่มีposพารามิเตอร์:

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

ใครต้องการอะไรอีกบ้าง เพียว STL!

หลายคนเข้าใจผิดว่าหมายถึง "ค้นหาย้อนหลังผ่านสตริงทั้งหมดเพื่อค้นหาคำนำหน้า" ที่จะให้ผลลัพธ์ที่ผิด (เช่นstring("tititito").rfind("titi")คืน 2 ดังนั้นเมื่อเทียบกับ== 0จะกลับเท็จ) และมันจะไม่มีประสิทธิภาพ (มองผ่านสตริงทั้งหมดแทนที่จะเป็นเพียงการเริ่มต้น) แต่ไม่ได้ทำเช่นนั้นเพราะผ่านposพารามิเตอร์เป็น0ซึ่ง จำกัด การค้นหาให้จับคู่ที่ตำแหน่งนั้นหรือก่อนหน้าเท่านั้น ตัวอย่างเช่น:

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)

คุณจะทำเช่นนี้:

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

กำลังมองหา lib เช่น Boost.ProgramOptions ที่ทำสิ่งนี้เพื่อคุณก็เป็นความคิดที่ดีเช่นกัน

เพื่อความสมบูรณ์ฉันจะพูดถึงวิธีการทำ C:

ถ้าstrเป็นสตริงเดิมของคุณsubstrคือสตริงย่อยที่คุณต้องการตรวจสอบแล้ว

strncmp(str, substr, strlen(substr))

จะกลับมา0ถ้าเริ่มต้นด้วยstr substrฟังก์ชั่นstrncmpและstrlenอยู่ในไฟล์ส่วนหัว C<string.h>

^{(โพสต์ครั้งแรกโดย Yaseen Rauf ที่นี่เพิ่มมาร์กอัป)}

สำหรับการเปรียบเทียบกรณีตายใช้แทนstrnicmpstrncmp

นี่คือวิธีการทำ C สำหรับสตริง C ++ คุณสามารถใช้ฟังก์ชั่นเดียวกันนี้:

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

หากคุณใช้ 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 ++ บรรทัดคำสั่ง parser" จะให้ตัวเลือกจำนวนมาก

รหัสฉันใช้เอง:

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

ยังไม่มีใครใช้อัลกอริทึม STL /ฟังก์ชั่นที่ไม่ตรงกัน ถ้าสิ่งนี้คืนค่าจริงคำนำหน้าเป็นคำนำหน้า 'toCheck':

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

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

แก้ไข:

ดังที่ @James T. Huggett แนะนำ std :: equal เป็นแบบที่ดีกว่าสำหรับคำถาม: A เป็นส่วนนำหน้าของ B หรือไม่ และเป็นรหัสที่สั้นกว่าเล็กน้อย:

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

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

เนื่องจากทั้งสตริง - argv[1]และ"--foo"- เป็นสตริง C คำตอบของ @ FelixDombekจึงเป็นทางออกที่ดีที่สุด

อย่างไรก็ตามเมื่อเห็นคำตอบอื่น ๆ ฉันคิดว่ามันควรค่าแก่การสังเกตว่าถ้าข้อความของคุณพร้อมใช้งานแล้ว a 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 ++ 17 คุณสามารถใช้std::basic_string_view& กับ C ++ 20 std::basic_string::starts_withหรือstd::basic_string_view::starts_withหรือ

ประโยชน์ของstd::string_viewการเปรียบเทียบstd::string- เกี่ยวกับการจัดการหน่วยความจำ - คือมันเก็บตัวชี้ไปที่ "สตริง" เท่านั้น (ลำดับที่ต่อเนื่องกันของวัตถุที่มีลักษณะคล้ายถ่าน) และรู้ขนาดของมัน ตัวอย่างโดยไม่ย้าย / คัดลอกสตริงต้นทางเพียงเพื่อรับค่าจำนวนเต็ม:

#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

การใช้ 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;
}

ด้วยความเสี่ยงที่จะถูกไล่ออกเพราะใช้งานโครงสร้าง C ฉันคิดว่าsscanfตัวอย่างนี้ดูดีกว่าโซลูชัน Boost ส่วนใหญ่ และคุณไม่ต้องกังวลกับการเชื่อมโยงหากคุณทำงานที่ใดก็ได้ที่มี 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;
}

นี่คือตัวอย่างผลลัพธ์ที่แสดงให้เห็นถึงวิธีการแก้ปัญหาการจัดการขยะมูลฝอยชั้นนำ / ต่อท้ายอย่างถูกต้องเช่นเดียวกับรหัสงูหลามที่เทียบเท่าและมีความถูกต้องมากกว่าสิ่งที่ใช้atoi(ซึ่งจะไม่สนใจคำต่อท้ายที่ไม่ใช่ตัวเลข)

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

ฉันใช้std::string::compareวิธีการห่อหุ้มด้วยยูทิลิตี้ดังนี้:

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

ทำไมไม่ใช้ 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 ++ 11 และไม่สามารถใช้บูสต์ได้นี่เป็นตัวอย่างการใช้งานบูสต์ที่รองรับ:

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

คุณยังสามารถใช้strstr:

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

แต่ฉันคิดว่ามันดีสำหรับสตริงสั้น ๆ เท่านั้นเพราะมันต้องวนซ้ำทั้งสตริงเมื่อสตริงไม่ได้ขึ้นต้นด้วย 'substr'

โอเคทำไมการใช้ห้องสมุดและสิ่งของต่าง ๆ มีความซับซ้อน? อ็อบเจกต์ C ++ String โอเวอร์โหลดตัวดำเนินการ [] ดังนั้นคุณสามารถเปรียบเทียบ chars .. เหมือนที่ฉันเพิ่งทำเพราะฉันต้องการแสดงรายการไฟล์ทั้งหมดในไดเรกทอรีและไม่สนใจไฟล์ที่มองไม่เห็นและ .. และ pseudofiles

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

มันง่ายมาก ..

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 หรือสูงกว่าคุณสามารถใช้find()และfind_first_of()

ตัวอย่างการใช้ find เพื่อค้นหา char ตัวเดียว:

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

• เพิ่มเติมเกี่ยวกับการค้นหา
• เพิ่มเติมเกี่ยวกับ find_first_of

โชคดี!

เนื่องจาก C ++ 11 std::regex_searchยังสามารถใช้เพื่อให้การจับคู่นิพจน์ที่ซับซ้อนยิ่งขึ้น ตัวอย่างต่อไปนี้จะจัดการกับตัวเลขลอยตัวstd::stofและหลังจากintนั้น

อย่างไรก็ตามparseIntวิธีการที่แสดงด้านล่างอาจทำให้เกิดstd::invalid_argumentข้อยกเว้นหากคำนำหน้าไม่ตรงกัน สามารถปรับเปลี่ยนได้ง่ายขึ้นอยู่กับแอปพลิเคชันที่กำหนด:

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

ชนิดของความมหัศจรรย์ของรูปแบบการ regex รายละเอียดได้ดีในต่อไปนี้คำตอบ

แก้ไข:คำตอบก่อนหน้านี้ไม่ได้ทำการแปลงเป็นจำนวนเต็ม

เริ่มต้นด้วย C ++ 20 คุณสามารถใช้starts_withวิธีนี้ได้

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

นี่คือการทดสอบอย่างสมบูรณ์ หลักการนั้นเหมือนกับ Python ต้องใช้ Boost.StringAlgo และ Boost.LexicalCast

ตรวจสอบว่าสตริงเริ่มต้นด้วยสตริงอื่นแล้วรับซับสตริง ('slice') ของสตริงแรกแล้วแปลงเป็นสตริงใช้คำ