出于不同目的重复读取由空格（或其他分隔符）分隔的双精度列表

Question

我对 C++ 非常陌生，遇到了以下问题。

我的目标： 我想要一个执行以下操作的代码：

1. 用户输入包含以某种方式分隔的双精度数的行
2. 双精度数被解析为双精度数数组
3. 对数组进行计算（*）。例如，它的总和
4. 如果用户不停止循环，它会读取一个新行，然后循环回到 1。
5. 一旦用户中断第一个循环（通过输入空行或类似的内容），就会开始一个新循环。
6. 用户输入包含以某种方式分隔的双精度数的行
7. 双精度数将被解析为双精度数数组
8. 对数组进行计算（**）。例如它的平均值。
9. 用户制动第二个循环。
10. 程序退出。

我的代码：

#include <iostream>

int main()
{
    do {
        double x1, x2, x3, y1, y2, y3;
        std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
        if (!std::cin){   
            break;
        }
        std::cout << "\n The sum is: " << (x1+y1+x2+y2+x3+y3) << "\n";
    } while (1);

    do {
        double x1, x2, x3, y1, y2, y3;
        std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
        if (!std::cin){   
            break;
        }
        std::cout << "\n The average is: " << (x1+y1+x2+y2+x3+y3)/6 << "\n";
    } while (1);
    return 0;
}

问题： 当我尝试停止第一个循环，并通过按 CTRL-D 或给出一个字母作为输入移动到第二个循环时，程序将退出并跳过第二个循环。我意识到这与cin机制有关，但我未能治愈它。

问题：我应该如何编程？解决这个问题最痛苦的方法是什么？提前致谢！

Answer 1

问题：当我尝试停止第一个循环，并通过按 CTRL-D 或给出一个字母作为输入移动到第二个循环时，程序将退出并跳过第二个循环。我意识到这与cin机制有关，但我未能治愈它。

这是因为当您尝试读取字母或 EOF (Ctrl-D) 时，这会将流的状态设置为错误状态。一旦发生这种情况，流上的所有操作都会失败（直到您重置它）。这可以通过调用clear()来完成

std::cin.clear();

问题：我应该如何编程？解决这个问题最痛苦的方法是什么？

我不会使用这种技术。
我会使用类似空行的东西作为循环之间的分隔符。因此，代码如下所示：

while(std::getline(std::cin, line) && !line.empty())
{
      // STUFF
}
while(std::getline(std::cin, line) && !line.empty())
{
      // STUFF
}

试试这个：
注意：在 C++ 中，当数字以空格分隔时，流效果最佳。因此，只需使用空格或制表符来分隔数字即可。

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

struct Average
{
    Average(): result(0.0), count(0)            {}
    void operator()(double const& val)          { result  += val;++count;}
    operator double()                           { return (count == 0) ? 0.0 : result/count;}
    double  result;
    int     count;
};
struct Sum
{
    Sum(): result(0.0)                          {}
    void operator()(double const& val)          { result  += val;}
    operator double()                           { return result;}
    double result;
};

int main()
{
    std::string line;

    // Read a line at a time.
    // If the read fails or the line read is empty then stop looping.
    while(std::getline(std::cin, line) && !line.empty())
    {
        // In C++ we use std::Vector to represent arrays.
        std::vector<double>     data;
        std::stringstream       lineStream(line);

        // Copy a set of space separated integers from the line into data.
        // I know you wanted doubles (I do this next time)
        // I just wanted to show how easy it is to change between the types being
        // read. So here I use integers and below I use doubles.
        std::copy(  std::istream_iterator<int>(lineStream),
                    std::istream_iterator<int>(),
                    std::back_inserter(data));

        // Sum is a functor type.
        // This means when you treat it like a function then it calls the method operator()
        // We call sum(x) for each member of the vector data
        Sum sum;
        sum = std::for_each(data.begin(), data.end(), sum);
        std::cout << "Sum: " << static_cast<double>(sum) << "\n";
    }

    // Read a line at a time.
    // If the read fails or the line read is empty then stop looping.
    while(std::getline(std::cin, line) && !line.empty())
    {
        // In C++ we use std::Vector to represent arrays.
        std::vector<double>     data;
        std::stringstream       lineStream(line);

        // Same as above but we read doubles from the input not integers.
        // Notice the sleigh difference from above.
        std::copy(  std::istream_iterator<double>(lineStream),
                    std::istream_iterator<double>(),
                    std::back_inserter(data));

        // Average is a functor type.
        // This means when you treat it like a function then it calls the method operator()
        // We call average(x) for each member of the vector data
        Average average;
        average = std::for_each(data.begin(), data.end(), average);
        std::cout << "Average: " << static_cast<double>(average) << "\n";
    }
}

// 或者我们可以稍微模板化代码：

template<typename T, typename F>
void doAction()
{
    std::string line;

    // Read a line at a time.
    // If the read fails or the line read is empty then stop looping.
    while(std::getline(std::cin, line) && !line.empty())
    {
        std::stringstream       lineStream(line);

        // F is a functor type.
        // This means when you treat it like a function then it calls the method operator()
        // We call action(x) for each object type 'T' that we find on the line.
        // Notice how we do not actual need to store the data in an array first
        // We can actually processes the data as we read it from the line
        F action;
        action = std::for_each(  std::istream_iterator<T>(lineStream),
                                 std::istream_iterator<T>(),
                                 action);
        std::cout << "Action Result: " << static_cast<double>(action) << "\n";
    }
}

int main()
{
    doAction<int, Sum>();
    doAction<double, Average>();
}

Answer 2

使用 std::cin.get()。它将在第一个输入的字符后返回。在这种情况下，您不需要循环，而是需要一些东西。像这样：

double x1, x2, x3, y1, y2, y3;
std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
std::cin.get();
std::cout << "\n The sum is: " << (x1+y1+x2+y2+x3+y3) << "\n";

double x1, x2, x3, y1, y2, y3;
std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
std::cin.get();
std::cout << "\n The average is: " << (x1+y1+x2+y2+x3+y3)/6 << "\n";

Answer 3

如果 std::cin 收到错误类型的输入，它将进入失败状态 - 您可以使用 (!std::cin) 进行测试。但输入数据也保留在流中。

因此，除了检查失败状态之外，您还必须清除失败状态（std::cin.clear();）并从输入流中删除未读数据（std:: cin.ignore();)：

  #include <iostream>

  int main()
  {
     do {
        std::cout << "\nInsert 6 Numbers for sum or anything else to break:\n";
        double x1, x2, x3, y1, y2, y3;
        std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
        if (!std::cin){
           std::cin.clear();
           std::cin.ignore();
           break;
        }
        std::cout << "\n The sum is: " << (x1+y1+x2+y2+x3+y3) << "\n";
     } while (1);

     do {
        std::cout << "\nInsert 6 Numbers for average or anything else to break:\n";
        double x1, x2, x3, y1, y2, y3;
        std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
        if (!std::cin){   
           std::cin.clear();
           std::cin.ignore();
           break;
        }
        std::cout << "\n The average is: " << (x1+y1+x2+y2+x3+y3)/6 << "\n";
     } while (1);

     return 0;
  }

我还添加了一个 cout，它显示了实际循环的可用性。

Answer 4

您确实需要重新考虑您的用户界面。

怎么样

SUM 1.9 1.3
AVERAGE 1 4 6
DONE

使用cout>> aString 来获取关键字，然后像现在一样获取数字。