如何将输入读取到C++；按相反顺序编程？ 假设我给C++程序输入如下：

1234567891011213141415

C++代码：

int n;
for (int i = 0; i < 15; i++)
{
    std::cin >> n;
    // use the value of n to make changes
}

intn；
对于（int i=0；i<15；i++）
{
标准：cin>>n；
//使用n的值进行更改
}

在上面的代码中，我可以按顺序读取输入， i、 e.

12345678910112131415

有没有一种方法可以直接从输入流中读取输入（不使用C++程序中的额外内存）：

5423211098761514131211

前五位按相反顺序排列

54321

，后五位按相反顺序排列

109876

，…

否

您需要在数据流入输入流时读取数据

然后，在您的程序中，您可以按自己喜欢的方式重新订购。

否

您需要在数据流入输入流时读取数据

---

在你的程序中，你可以用你喜欢的任何方式对它们重新排序。

如评论中所述，最好的方法是按照给定的顺序阅读它们，然后再对它们进行排序

// vector to hold the values
std::vector<int> values;
values.reserve(15); // reserve for better performance

int n;
for (int i = 0; i < 15; i++)
{
    std::cin >> n;
    values.push_back(n); // add value to back of vector
}

// sort the vector
std::sort(values.begin(), values.end());

// use the values in ascending order...
for (int i = 0; i < 15; i++) {
    std::cout << values[i];    
}

//用于保存值的向量
std：：向量值；
价值。保留（15）；//保留更好的性能
int n；
对于（int i=0；i<15；i++）
{
标准：cin>>n；
value.push_back（n）；//将值添加到向量的后面
}
//对向量排序
排序（values.begin（），values.end（））；
//按升序使用这些值。。。
对于（int i=0；i<15；i++）{
std：：cout如评论中所述，最好的方法是按照给出的顺序阅读它们，然后对它们进行排序

// vector to hold the values
std::vector<int> values;
values.reserve(15); // reserve for better performance

int n;
for (int i = 0; i < 15; i++)
{
    std::cin >> n;
    values.push_back(n); // add value to back of vector
}

// sort the vector
std::sort(values.begin(), values.end());

// use the values in ascending order...
for (int i = 0; i < 15; i++) {
    std::cout << values[i];    
}

//用于保存值的向量
std：：向量值；
values.reserve（15）；//保留以获得更好的性能
int n；
对于（int i=0；i<15；i++）
{
标准：cin>>n；
value.push_back（n）；//将值添加到向量的后面
}
//对向量排序
排序（values.begin（），values.end（））；
//按升序使用这些值。。。
对于（int i=0；i<15；i++）{
是的，这是可能的，但是它增加了代码的运行时间复杂性

首先，您可以在上面的测试用例中为它插入了多少个系列创建外部循环

第二，你可以做一个内环，把数字相加

我不确定代码是否正在运行，但逻辑对您有帮助

我正在使用堆栈实现psuedo代码

int n=5;
for(int count = 1 ; count <= 3 ;count++)
{
   for(int i=n ; i > n-5 ; i++)
    {
      push_on_stack(i);
    }
 n=n+5;
}

int n=5；
对于（整数计数=1；计数n-5；i++）
{
将_推到_堆栈上（i）；
}
n=n+5；
}
是的，这是可能的，但会增加代码的运行时间复杂性

首先，您可以在上面的测试用例中为它插入了多少个系列创建外部循环

第二，你可以做一个内环，把数字相加

我不确定代码是否正在运行，但逻辑对您有帮助

我正在使用堆栈实现psuedo代码

int n=5;
for(int count = 1 ; count <= 3 ;count++)
{
   for(int i=n ; i > n-5 ; i++)
    {
      push_on_stack(i);
    }
 n=n+5;
}

int n=5；
对于（整数计数=1；计数n-5；i++）
{
将_推到_堆栈上（i）；
}
n=n+5；
}
您需要在一些功能中包装您的输入，以便为您重新排序值。您可能可以在程序之外执行此操作，即，通过另一个程序对输入流进行管道传输，以重新排序值。那么您的代码可能已经可以像现在这样工作了

或者在程序中进行这种包装。例如，使用一个自定义的类流来缓冲中间的值

如果不使用额外内存来缓冲您还不需要的值，就无法完成此操作

例如：

#include <iostream>
#include <stack>

struct reader {
    std::stack<int> data;
    reader& operator>>(int & i) {
        if (data.empty()) {
            while (data.size() < 5) {
                data.push(0);
                std::cin >> data.top();
            }
        }
        i = data.top();
        data.pop();
        return *this;
    }
    explicit operator bool() const { return bool(std::cin); }
};

int main () {
    reader r;
    int i;
    while (r >> i) {
        std::cout << i << std::endl;
    }
}


更直接的方法可能是这样的：

#include <iostream>
#include <vector>

int main () {
    std::vector<int> buffer;
    for (int i; std::cin >> i; ) {
        buffer.push_back(i);
        if (buffer.size() == 5) {
            // do something with buffer
            //std::vector<int> reversed(buffer.rbegin(), buffer.rend());
            while (!buffer.empty()) {
                std::cout << buffer.back() << "\n";
                buffer.pop_back();
            }
        }
    }
}

#包括
#包括
int main（）{
向量缓冲区；
对于（inti；std:：cin>>i；）{
缓冲器。推回（i）；
if（buffer.size（）==5）{
//对缓冲区做些什么
//std:：vector reversed（buffer.rbegin（），buffer.rend（））；
而（！buffer.empty（））{
std:：cout您需要在一些功能中包装您的输入，以便为您重新排序值。您可能可以在程序外部执行此操作，即，通过另一个程序对输入流进行管道处理，以重新排序值。然后，您的代码可能已经可以像现在这样工作了

或者在程序中进行包装。例如，使用一个自定义的类流来缓冲中间的值

如果不使用额外内存来缓冲您还不需要的值，就无法完成此操作

例如：

#include <iostream>
#include <stack>

struct reader {
    std::stack<int> data;
    reader& operator>>(int & i) {
        if (data.empty()) {
            while (data.size() < 5) {
                data.push(0);
                std::cin >> data.top();
            }
        }
        i = data.top();
        data.pop();
        return *this;
    }
    explicit operator bool() const { return bool(std::cin); }
};

int main () {
    reader r;
    int i;
    while (r >> i) {
        std::cout << i << std::endl;
    }
}


更直接的方法可能是这样的：

#include <iostream>
#include <vector>

int main () {
    std::vector<int> buffer;
    for (int i; std::cin >> i; ) {
        buffer.push_back(i);
        if (buffer.size() == 5) {
            // do something with buffer
            //std::vector<int> reversed(buffer.rbegin(), buffer.rend());
            while (!buffer.empty()) {
                std::cout << buffer.back() << "\n";
                buffer.pop_back();
            }
        }
    }
}

#包括
#包括
int main（）{
向量缓冲区；
对于（inti；std:：cin>>i；）{
缓冲器。推回（i）；
if（buffer.size（）==5）{
//对缓冲区做些什么
//std:：vector reversed（buffer.rbegin（），buffer.rend（））；
而（！buffer.empty（））{
std:：cout是否需要以这种方式读取，或者是否可以读入然后重新排序？逆流游动…..听起来您想将它们放入数组（
std:：vector
），然后使用自定义排序函数对数组排序（使用
std:：stort
）可能是这样的？您可以按原样读取，以后再重新排序。无法从
std:：cin
中按与作为输入提供的顺序不同的顺序读取值。读取五个值，对它们进行排序，输出它们。重复两次。某些内容（例如数组、对象或容器）需要内存保存五个值。是否需要以这种方式读取，或者是否可以读入然后重新排序？逆流游动…..听起来您想将它们放入数组（
std:：vector
），然后使用自定义排序函数（使用
std:：stort
）对数组进行排序可能是这样的？您可以按原样读取，以后再重新排序。无法从
std:：cin
中以与作为输入提供的顺序不同的顺序读取值。读取五个值，对它们进行排序，然后输出。重复两次