将 std::string 标记为结构

Question

假设我有以下字符串，我想根据分隔符“>”对其进行标记化：

std::string veg = "orange>kiwi>apple>potato";

我希望字符串中的每一项都放在具有以下格式的结构中：

struct pack_item
{
    std::string it1;
    std::string it2;
    std::string it3;
    std::string it4;
};

我知道怎么做了：

pack_item pitem;

std::stringstream veg_ss(veg);
std::string veg_item;

std::getline(veg_ss, veg_item, '>')
pitem.it1 = veg_item;
std::getline(veg_ss, veg_item, '>')
pitem.it2 = veg_item;
std::getline(veg_ss, veg_item, '>')
pitem.it3 = veg_item;
std::getline(veg_ss, veg_item, '>')
pitem.it4 = veg_item;

有没有更好的单行方式？

Answer 1

像这样：

#include <string>
#include <vector>
#include <sstream>
#include <iostream>

std::string veg = "orange>kiwi>apple>potato";

typedef std::vector<std::string> it_vec;

int main(int argc, char* argv[]) {
    it_vec vec;
    
    std::stringstream veg_ss(veg);
    std::string veg_item;

    while (std::getline(veg_ss, veg_item, '>')) {
        vec.push_back(veg_item);
    }
    
    for (const std::string& vec_item : vec) {
        std::cout << vec_item << std::endl;
    }
}

Answer 2

正如评论中所建议的，您可以这样使用 for 循环：

pack_item a;
std::array<std::reference_wrapper<std::string>, 4> arr{a.it1, a.it2, a.it3, a.it4};

constexpr std::string_view veg = "orange>kiwi>apple>potato";
std::istringstream ss(veg.data());

std::string str;

for(std::size_t idx = 0; std::getline(ss, str, '>'); ++idx){
    arr[idx].get() = std::move(str);
}

如果你的意思是真正意义上的“one-liner”，那么你可能会很讨厌并使用：

std::getline(std::getline(std::getline(std::getline(ss, a.it1, '>'), a.it2, '>'), a.it3, '>'), a.it4, '>');

Answer 3

您不需要中间变量。

pack_item pitem;

std::stringstream veg_ss(veg);

std::getline(veg_ss, pitem.it1, '>');
std::getline(veg_ss, pitem.it2, '>');
std::getline(veg_ss, pitem.it3, '>');
std::getline(veg_ss, pitem.it4, '>');

您可能希望将其设为一个函数，例如operator >>（与operator <<相似）

std::istream& operator >>(std::istream& is, pack_item & pitem) {
    std::getline(is, pitem.it1, '>');
    std::getline(is, pitem.it2, '>');
    std::getline(is, pitem.it3, '>');
    std::getline(is, pitem.it4, '>');
    return is;
}

std::ostream& operator <<(std::ostream& os, pack_item & pitem) {
    return os << pitem.it1 << '>'
              << pitem.it2 << '>'
              << pitem.it3 << '>'
              << pitem.it4 << '>';
}

int main() {
    std::stringstream veg_ss("orange>kiwi>apple>potato>");
    pack_item pitem;
    veg_ss >> pitem;
}

Is there a better and one-liner kind of way to do it?

您可以创建一个 >> 的类型，它读取一个字符串直到一个分隔符，并在一个语句中读取所有四个元素。那真的“更好”了吗？

template <bool is_const>
struct delimited_string;

template<>
struct delimited_string<true> {
    const std::string & string;
    char delim;
};

template<>
struct delimited_string<false> {
    std::string & string;
    char delim;
};

delimited_string(const std::string &, char) -> delimited_string<true>;
delimited_string(std::string &, char) -> delimited_string<false>;

std::istream& operator >>(std::istream& is, delimited_string<false> s) {
    return std::getline(is, s.string, s.delim);
}

template <bool is_const>
std::ostream& operator <<(std::ostream& os, delimited_string<is_const> s) {
    return os << s.string << s.delim;
}

std::istream& operator >>(std::istream& is, pack_item & pitem) {
    return is >> delimited_string { pitem.it1, '>' }
              >> delimited_string { pitem.it2, '>' }
              >> delimited_string { pitem.it3, '>' }
              >> delimited_string { pitem.it4, '>' };
}

std::ostream& operator <<(std::ostream& os, const pack_item & pitem) {
    return os << delimited_string { pitem.it1, '>' }
              << delimited_string { pitem.it2, '>' }
              << delimited_string { pitem.it3, '>' }
              << delimited_string { pitem.it4, '>' };
}

Answer 4

确实：

#include <iostream>
#include <sstream>
#include <string>

struct pack_item
{
    std::string it1;
    std::string it2;
    std::string it3;
    std::string it4;
};

pack_item pack( const std::string & s )
{
  pack_item p;
  getline(getline(getline(getline(std::istringstream(s), p.it1,'>'), p.it2,'>'), p.it3,'>'), p.it4);
  return p;
}

int main()
{
  auto pitem = pack( "orange>kiwi>apple>potato" );
  
  std::cout << pitem.it4 << "<" << pitem.it3 << "<" << pitem.it2 << "<" << pitem.it1 << "\n";
}

顺便说一句，多行代码没有错。对 one-liner 的追求通常会分散人们对正确行事™ 的注意力。

Answer 5

我要做的是创建一个以 std::string_view 作为参数的构造函数（第二个是预定义的，将是分隔符），然后使用 find 函数。

这里贴出使用std::string_view的原因：

struct pack_item
{
    std::string it1;
    std::string it2;
    std::string it3;
    std::string it4;

    pack_item():it1(){}

    pack_item(std::string_view in, char sep = '>'){
        
        auto ptr = in.begin();
        auto l_ptr = ptr;
        ptr = std::find(ptr, in.end(), sep);
        it1 = std::string(l_ptr, ptr++);
        l_ptr = ptr;
        ptr = std::find(ptr, in.end(), sep);
        it2 = std::string(l_ptr, ptr++);
        l_ptr = ptr;
        ptr = std::find(ptr, in.end(), sep);
        it3 = std::string(l_ptr, ptr++);
        l_ptr = ptr;
        ptr = std::find(ptr, in.end(), sep);
        it4 = std::string(l_ptr, ptr++);
        
        
    }

};

你可以在这里看到，如果你愿意，这可以很容易地转换成一个循环，并通过检查来停止它：

if(ptr == in.end()) break;

将 std::string 标记为结构

Tokenize a std::string to a struct

c++

tokenize

data-structures