假设我有一个字符串:

argsStr = "server ('m1.labs.terad  ''ata.com') username ('us ''er5') password('user)5') dbname ('def\\ault')";

现在我使用以下代码来提取标记:

'm1.labs.terad  ''ata.com'  <- token1
'us ''er5'                    <-token2
'user)5'                    <-token3
'def\ault'                  <-token4

代码:

regex re("(\'(.*?)\'\)");
typedef std::vector<std::string> StringVector;
StringVector arg_values;
boost::regex re_arg_values("('[^']*(?:''[^']*)*')");
boost::sregex_token_iterator name_iter_start(argsStr.begin(),argsStr.end(), re_arg_values, 0),name_iter_end;
std::copy(value_iter_start, value_iter_end,std::back_inserter(arg_values)); 
//putting the token in the string vector.

现在将其放入字符串 vector 后，如何转换标记/字符串以用单引号替换双引号:

例如:

'm1.labs.terad ''ata.com' 应该变成 'm1.labs.terad 'ata.com' 并且 'us ''er5' 应该变成 'us 'er5'。

我可以为此使用 boost::replace_all 吗？

最佳答案

好的。您已经连续问了 6 个有关此解析作业的问题¹。

很多人一直在告诉您正则表达式不是完成这项工作的工具。 Including me :

我给你看了

• 将此配置字符串解析为键值映射的 Spirit X3 语法示例，正确解释转义引号(例如 '\\'')(参见 here)
• 我对其进行了扩展(13 个字符)以允许重复引号转义引号(参见 here)

我所有的示例都非常出色，因为它们已经将键与值一起解析，因此您拥有正确的配置设置映射。

但您在最新的问题 ( Extract everything apart from what is specified in the regex ) 中仍然要求它。

当然答案在我的第一个答案中:

for (auto& setting : parse_config(text))
    std::cout << setting.first << "\n";

我posted this连同它的 C++03 版本 live on Coliru

编写手动解析器

如果你因为不明白而拒绝它，你所要做的就是问。

如果您“不想”使用 Spirit，您可以轻松地手动编写一个类似的解析器。我没有，因为它很乏味且容易出错。如果您需要它来获得灵感，请看这里:

1. 还是c++03
2. 仅使用标准库功能
3. 仍然使用转义引号解析单引号/双引号字符串
4. 仍然解析为map<string, string>
5. 在无效输入时引发信息性错误消息

BOTTOM LINE: Use a proper grammar like people have been urging you since day 1

Live On Coliru

#include <iostream>
#include <sstream>
#include <map>

typedef std::map<std::string, std::string> Config;
typedef std::pair<std::string, std::string> Entry;

struct Parser {
    Parser(std::string const& input) : input(input) {}
    Config parse() {
        Config parsed;

        enum { KEY, VALUE } state = KEY;
        key = value = "";
        f = input.begin(), l = input.end();

        while (f!=l) {
            //std::cout << "state=" << state << ", '" << std::string(It(input.begin()), f) << "[" << *f << "]" << std::string(f+1, l) << "'\n";
            switch (state) {
              case KEY:
                  skipws();
                  if (!parse_key())
                      raise("Empty key");

                  state = VALUE;
                  break;
              case VALUE:
                  if (!expect('(', true))
                      raise("Expected '('");

                  if (parse_value('\'') || parse_value('"')) {
                      parsed[key] = value;
                      key = value = "";
                  } else {
                      raise("Expected quoted value");
                  }

                  if (!expect(')', true))
                      raise("Expected ')'");

                  state = KEY;
                  break;
            };
        }

        if (!(key.empty() && value.empty() && state==KEY))
            raise("Unexpected end of input");

        return parsed;
    }

  private:
    std::string input;

    typedef std::string::const_iterator It;
    It f, l;
    std::string key, value;

    bool parse_key() {
        while (f!=l && alpha(*f))
            key += *f++;
        return !key.empty();
    }

    bool parse_value(char quote) {
        if (!expect(quote, true))
            return false;

        while (f!=l) {
            char const ch = *f++;
            if (ch == quote) {
                if (expect(quote, false)) {
                    value += quote;
                } else {
                    //std::cout << " Entry " << key << " -> " << value << "\n";
                    return true;
                }
            } else {
                value += ch;
            }
        }

        return false;
    }

    static bool space(unsigned char ch) { return std::isspace(ch); }
    static bool alpha(unsigned char ch) { return std::isalpha(ch); }
    void skipws() { while (f!=l && space(*f)) ++f; }
    bool expect(unsigned char ch, bool ws = true) {
        if (ws) skipws();
        if (f!=l && *f == ch) {
            ++f;
            if (ws) skipws();
            return true;
        }
        return false;
    }

    void raise(std::string const& msg) {
        std::ostringstream oss;
        oss << msg << " (at '" << std::string(f,l) << "')";
        throw std::runtime_error(oss.str());
    }
};

int main() {
    std::string const text = "server ('m1.labs.terad  ''ata.com') username ('us\\* er5') password('user)5') dbname ('def\\ault')";

    Config cfg = Parser(text).parse();

    for (Config::const_iterator setting = cfg.begin(); setting != cfg.end(); ++setting) {
        std::cout << "Key " << setting->first << " has value " << setting->second << "\n";
    }

    for (Config::const_iterator setting = cfg.begin(); setting != cfg.end(); ++setting) {
        std::cout << setting->first << "\n";
    }
}

一如既往地打印:

Key dbname has value def\ault
Key password has value user)5
Key server has value m1.labs.terad  'ata.com
Key username has value us\* er5
dbname
password
server
username

¹ 见

1. avoid empty token in cpp
2. extracting whitespaces using regex in cpp
3. Regex to extract value between a single quote and parenthesis using boost token iterator
4. tokenizing string , accepting everything between given set of characters in CPP
5. extract a string with single quotes between parenthesis and single quote
6. Extract everything apart from what is specified in the regex
7. 这个

关于c++ - 将双单引号 (' ' ) 替换为单引号 (')，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/45272783/