我读取和来自通过接收c ++的std :: istream对象以逗号分隔的用户的输入?

让我们一步一步来.

首先也是最重要的一点，将使用功能 std :: getline 读取一条完整的输入行.此函数将从任何 std :: istream 中读取整行，并将其放入 std :: string .

First, and most important, one complete input line will read using the function std::getline. This function will read a complete line from whatever std::istream and put it into a std::string.

然后，我们需要将完整的字符串分成子字符串.子字符串用逗号分隔.最后，我们将有一个STL容器，其中包含所有子字符串.

Then, we need to split up the complete string into substrings. The substrings are separated by comma. In the end, we would have an STL container, containing all the substrings.

然后，我们进行完整性检查，查看拆分字符串后得到的子字符串的数量.如果计数没问题，那么我们要么直接存储字符串，要么将它们转换为所需的数据类型，例如 int 或 float .

Then we make a sanity check and look at the number of substrings that we got after splitting up the string. If the count is OK, then we do either store the strings directly, or convert them to the required data type, for example an int or a float.

由于使用 std :: getline 读取一行很简单，因此我们首先将重点放在拆分字符串上.这也称为标记字符串.

Since the reading of a line with std::getline is simple, we will first concentrate on splitting up a string. This is also called tokenizing a string.

我将向您展示几种不同的方法来标记字符串:

I will show you several different approaches on how to tokenize a string:

将字符串拆分为标记是一项非常古老的任务.有许多可用的解决方案.全部具有不同的属性.有些很难理解，有些很难开发，有些更复杂，更慢或更快，或者更灵活.

Splitting a string into tokens is a very old task. There are many many solutions available. All have different properties. Some are difficult to understand, some are hard to develop, some are more complex, slower or faster or more flexible or not.

替代品

1. 使用指针或迭代器手工制作的许多变体，可能难以开发并且容易出错.
2. 使用旧式 std :: strtok 函数.也许不安全.也许不应该再使用
3. std :: getline .最常用的实现.但是实际上是滥用".不太灵活
4. 使用专门为此目的而开发的专用现代功能，该功能最灵活且最适合STL环境和算法环境.但是比较慢.

1. Handcrafted, many variants, using pointers or iterators, maybe hard to develop and error prone.
2. Using old style std::strtok function. Maybe unsafe. Maybe should not be used any longer
3. std::getline. Most used implementation. But actually a "misuse" and not so flexible
4. Using dedicated modern function, specifically developed for this purpose, most flexible and good fitting into the STL environment and algortithm landscape. But slower.

请在一个代码中查看4个示例.

Please see 4 examples in one piece of code.

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <regex>
#include <algorithm>
#include <iterator>
#include <cstring>
#include <forward_list>
#include <deque>

using Container = std::vector<std::string>;
std::regex delimiter{ "," };


int main() {

    // Some function to print the contents of an STL container
    auto print = [](const auto& container) -> void { std::copy(container.begin(), container.end(),
        std::ostream_iterator<std::decay<decltype(*container.begin())>::type>(std::cout, " ")); std::cout << '\n'; };

    // Example 1:   Handcrafted -------------------------------------------------------------------------
    {
        // Our string that we want to split
        std::string stringToSplit{ "aaa,bbb,ccc,ddd" };
        Container c{};

        // Search for comma, then take the part and add to the result
        for (size_t i{ 0U }, startpos{ 0U }; i <= stringToSplit.size();   i) {

            // So, if there is a comma or the end of the string
            if ((stringToSplit[i] == ',') || (i == (stringToSplit.size()))) {

                // Copy substring
                c.push_back(stringToSplit.substr(startpos, i - startpos));
                startpos = i   1;
            }
        }
        print(c);
    }

    // Example 2:   Using very old strtok function ----------------------------------------------------------
    {
        // Our string that we want to split
        std::string stringToSplit{ "aaa,bbb,ccc,ddd" };
        Container c{};

        // Split string into parts in a simple for loop
#pragma warning(suppress : 4996)
        for (char* token = std::strtok(const_cast<char*>(stringToSplit.data()), ","); token != nullptr; token = std::strtok(nullptr, ",")) {
            c.push_back(token);
        }

        print(c);
    }

    // Example 3:   Very often used std::getline with additional istringstream ------------------------------------------------
    {
        // Our string that we want to split
        std::string stringToSplit{ "aaa,bbb,ccc,ddd" };
        Container c{};

        // Put string in an std::istringstream
        std::istringstream iss{ stringToSplit };

        // Extract string parts in simple for loop
        for (std::string part{}; std::getline(iss, part, ','); c.push_back(part))
            ;

        print(c);
    }

    // Example 4:   Most flexible iterator solution  ------------------------------------------------

    {
        // Our string that we want to split
        std::string stringToSplit{ "aaa,bbb,ccc,ddd" };


        Container c(std::sregex_token_iterator(stringToSplit.begin(), stringToSplit.end(), delimiter, -1), {});
        //
        // Everything done already with range constructor. No additional code needed.
        //

        print(c);


        // Works also with other containers in the same way
        std::forward_list<std::string> c2(std::sregex_token_iterator(stringToSplit.begin(), stringToSplit.end(), delimiter, -1), {});

        print(c2);

        // And works with algorithms
        std::deque<std::string> c3{};
        std::copy(std::sregex_token_iterator(stringToSplit.begin(), stringToSplit.end(), delimiter, -1), {}, std::back_inserter(c3));

        print(c3);
    }
    return 0;
}

因此，在拥有诸如"abc，12345，hello"之类的初始字符串之后，我们现在将拥有一个 std :: string s的容器，例如包含子字符串的 std :: vector :和"hello".

So, after having an initial string, like "abc,12345,hello", we will now have a container of std::strings, e.g. a std::vector containing the substrings: So, "abc","12345" and "hello".

"abc"和你好"可以直接存储(分配给)类的字符串变量中." 12345"必须使用现有函数(例如 std :: stoi )转换为 int 并分配给成员变量.

"abc" and "hello" can directly be stored (assigned to) in a string variable of your class. "12345" must be converted using an existing function, like for example std::stoi, to an int and assigned to a member variable.

最后一步是在类(或结构)中使用所有这些内容.

The last step is to use all of this in a class (or struct).

这看起来像这样:

struct MyData {
    // Our data
    std::string item1{};
    int value{};
    std::string item2{};
    
    // Overwrite extractor operator
    friend std::istream& operator >> (std::istream& is, MyData& md) {
        if (std::string line{};std::getline(is, line)) {

            // Here we will store the sub strings
            std::vector<std::string> token{};

            // Put in an istringstream for further extraction
            std::istringstream iss{ line };
            
            // Split
            for (std::string part{}; std::getline(iss, part, ','); c.push_back(part))
                ;

            // Sanity check
            if (token.size() == 3) {
            
                // Assigns value to our data members
                md.item1 = token[0];
                md.value = std::stoi(token[1]);
                md.item2 = token[2];
            }

        }
        return is;
    }
};

很抱歉，但这是未编译的，未经测试的代码.它应该为您提供一个有关如何实施的想法.

Sorry to say, but this is uncompiled, not tested code. It shoud give you an idea, on how it could be implemented.

现在您可以使用 std :: iostream 将数据获取到您的结构中.

And now you can use std::iostream to get data into your struct.

MyData md;
std::cin >> md;

我希望我能回答你的问题.如果没有，请询问.

I hope I could answer your question. If not, then please ask.

这篇好文章是转载于：学新通技术网