我正在尝试读取大约2000行的数据文件，该文件看起来像
1.1 1.2 1.3 1.4 1.5
1.6 1.7 1.8 1.9
2.0
2.1 2.2 2.3 2.4 2.5
实际上有一个空白（空格）和1.3 / 1.7在同一列
我将它设置为存储的方式是结构的向量
struct num
{
double d1, d2, d3, d4, d5;
};
我想要实现的是
num A;
vector<num> data
for (int i = 0; i < 4; i++)
{
File >> A.d1 >> A.d2 >> A.d3 >> A.d4 >> A.d5;
data.push_back(A);
}
并找到识别第二行空白空间的逻辑并存储d1 = 1.6，d2 = 0，d3 = 1.7等等。第三行为d1 = 2.0和d2，d3，d4， D5 = 0 如果可能的话，我只是对如何测试/获取实现它的逻辑感到困惑 我在C ++ VS2010 在查看第一个答案之后我认为我应该提供更多信息，文件中的每一行都属于一个卫星，每个数字代表一个特定波长的观察，所以如果它是空白的，则意味着它没有对该波长的观察。
所以详细说明，第一行代表卫星1对所有5个波长进行观测，第2行代表satelittle 2并且对波长1,3,4,5进行观测，对波长4进行观测。
这就是为什么我试图将它作为一个单独的结构分成每一行，因为每一行都是一个单独的卫星
答案 0 :(得分：2)
观察您的数据：
这就是我提出的：
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <iomanip>
#include <cctype>
using namespace std;
//note all the lines are stored WITH newlines at the end of them.
//This is merely an artifact of the methodology I am using,
//as the newline is a flag that truncates output (as per your problem)
vector<string> preparse_input(const std::string& filename) {
vector<string> lines;
ifstream ifile;
ifile.open(filename.c_str(), ios::in);
if (!ifile.is_open()) {
exit(1);
}
string temp, chars, line;
char ch;
while(getline(ifile, temp)) {
temp += "\n";//getline removes the newline: because we need it, reinsert it
istringstream iss(temp);
//first read in the line char by char
while(iss >> noskipws >> ch) {
chars += ch;
}
bool replaced_newline = false;
int nargs = 0;
//I could have used iterators here, but IMO, this way is easier to read. Modify if need be.
for (int i = 0; i < chars.size(); ++i) {
if (isdigit(chars[i]) && chars[i+1] == ' ') {
nargs += 1;
}
else if(isspace(chars[i]) && isspace(chars[i+1])) {
if (chars[i+1] == '\n') {
replaced_newline = true;
}
//this means that there is no value set
//hence, set the value to 0 for the value part:
chars[i+1] = '0';
line += chars[i];
++i;//now, skip to the next character since 1 is for spacing, the other is for the value
nargs += 1;
}
//now rebuild the line:
line += chars[i];
if(isdigit(chars[i]) && chars[i+1] == '\n') {
nargs += 1;
//check nargs:
for (int i = nargs; i < 5; ++i) {
line += " 0";
nargs += 1;
}
}
if (replaced_newline) {
line += '\n';
}
replaced_newline = false;
}
lines.push_back(line);
chars.clear();
line.clear();
}
ifile.close();
return lines;
}
//this way, it's much easier to adapt to any type of input that you may have
template <typename T>
vector< vector<T> > parse_input (const vector<string>& lines) {
vector< vector<T> > values;
T val = 0;
for(vector<string>::const_iterator it = lines.begin(); it != lines.end(); ++it) {
vector<T> line;
istringstream iss(*it);
string temp;
while(getline(iss, temp, ' ')) {
if (istringstream(temp) >> val) {
line.push_back(val);
}
else {
line.push_back(0);//this is the value that badly parsed values will be set to.
//you have the option of setting it to some sentinel value, say -1, so you can go back and correct it later on, if need be. Depending on how you want to treat this error - hard or soft (stop program execution vs adapt and continue parsing), then you can adapt it accordingly
//I opted to treat it as a soft error but without a sentinel value - so I set it to 0 (-1 as that is probably more applicable in a general case), and informed the user that an error occurred
//The flipside of that is that I could have treated this as a hard error and have `exit(2)` (or whatever error code you wish to set).
cerr << "There was a problem storing:\"" << temp << "\"\n";
}
}
values.push_back(line);
}
return values;
}
int main() {
string filename = "data.dat";
vector<string> lines = preparse_input(filename);
vector < vector<double> > values = parse_input<double>(lines);
for (int i = 0; i < values.size(); ++i) {
for (int j = 0; j < values[i].size(); ++j) {
cout << values[i][j] << " ";
}
cout << endl;
}
return 0;
}
总之，我通过逐个字符地读取每一行来分解字符串，然后通过用0替换空格来重建每一行以便于解析。为什么？因为没有这样的值，所以无法确定存储或跳过哪个参数（使用默认的ifstream_object >> type方法）。
这样，如果我然后使用stringstream个对象来解析输入，我可以正确地确定设置或未设置哪个参数;然后，存储结果，一切都很花哨。这就是你想要的。
并且，在以下数据上使用它：
1.1 1.2 1.3 1.4 1.5
1.6 1.7 1.8 1.9
2.0
2.0
2.1 2.2 2.3 2.4 2.5
2.1 2.4
给你输出：
1.1 1.2 1.3 1.4 1.5
1.6 0 1.7 1.8 1.9
2 0 0 0 0
2 0 0 0 0
2.1 2.2 2.3 2.4 2.5
2.1 0 0 2.4 0
注意：第3行有8个空格（1表示无数据，1表示间距）。第4行是原始数据的行。第6行包含5个空格（遵循引用的模式）。
最后，请允许我说到目前为止，这是我遇到过的最疯狂的数据保存方法之一。
答案 1 :(得分：1)
鉴于您的文件格式是以空格分隔的，您可以使用正则表达式提取列。我假设您可以使用C ++ 11或者不使用Boost正则表达式。
然后，您可以使用以下函数将字符串拆分为标记。
std::vector<std::string> split(const std::string& input, const std::regex& regex) {
// passing -1 as the submatch index parameter performs splitting
std::sregex_token_iterator
first(input.begin(), input.end(), regex, -1),
last;
return std::vector<std::string>(first, last);
}
例如，假设您的数据位于“data.txt”中，我以这种方式使用它来获取值：
#include <iostream>
#include <fstream>
#include <string>
#include <regex>
#include <vector>
using namespace std;
std::vector<std::string> split(const string& input, const regex& regex) {
// passing -1 as the submatch index parameter performs splitting
std::sregex_token_iterator
first(input.begin(), input.end(), regex, -1),
last;
return vector<std::string>(first, last);
}
int main()
{
ifstream f("data.txt");
string s;
while (getline(f, s))
{
vector<string> values = split(s, regex("\\s"));
for (unsigned i = 0; i < values.size(); ++i)
{
cout << "[" << values[i] << "] ";
}
cout << endl;
}
return 0;
}
其中给出了以下结果：
[1.1] [1.2] [1.3] [1.4] [1.5]
[1.6] [] [1.7] [1.8] [1.9]
[2.0] [] [] []
[2.1] [2.2] [2.3] [2.4] [2.5]
请注意，第4行中缺少一列，但那是因为我不太确定该行上有多少个空格。如果您知道列数不超过输出阶段可以纠正的列数。
希望您觉得这种方法很有帮助。
答案 2 :(得分：0)
为什么不使用std:vector来保存一系列花车。
要向您使用的矢量添加新元素：
当您阅读每个角色时，请查看它是数字还是句号。
如果是，请将其添加到std::string，然后使用atof并将mystring.c_str()作为参数将其转换为浮点数。
这也可能有助于将字符串转换为float：
std::string to float or double
因此，读入一个字符串，然后将浮动按到一个向量，然后重复，跳过不是数字或句点的字符。
在该行的末尾，您的向量包含所有浮点数，如果您想将它们连接到带有自定义分隔符的字符串，您可以查看此问题的答案：