Cách đọc cho đến khi EOF từ cin trong C ++

Tôi đang viết mã một chương trình đọc dữ liệu trực tiếp từ đầu vào của người dùng và tự hỏi làm cách nào tôi có thể (không có vòng lặp) đọc tất cả dữ liệu cho đến khi EOF từ đầu vào chuẩn. Tôi đã xem xét sử dụng cin.get( input, '\0' )nhưng '\0'không thực sự là ký tự EOF, chỉ đọc cho đến khi EOF hoặc '\0', tùy điều kiện nào đến trước.

Hay sử dụng vòng lặp là cách duy nhất để làm điều đó? Nếu vậy, cách tốt nhất là gì?

Cách duy nhất bạn có thể đọc một lượng dữ liệu khác nhau stdinlà sử dụng các vòng lặp. Tôi luôn thấy rằng std::getline()chức năng hoạt động rất tốt:

std::string line;
while (std::getline(std::cin, line))
{
    std::cout << line << std::endl;
}

Theo mặc định getline()đọc cho đến một dòng mới. Bạn có thể chỉ định một ký tự kết thúc thay thế, nhưng bản thân EOF không phải là một ký tự nên bạn không thể chỉ thực hiện một lệnh gọi đến getline().

Sử dụng vòng lặp:

#include <iostream>
using namespace std;
...
// numbers
int n;
while (cin >> n)
{
   ...
}
// lines
string line;
while (getline(cin, line))
{
   ...
}
// characters
char c;
while (cin.get(c))
{
   ...
}

nguồn

Bạn có thể làm điều đó mà không có vòng lặp rõ ràng bằng cách sử dụng trình vòng lặp luồng. Tôi chắc chắn rằng nó sử dụng một số loại vòng lặp nội bộ.

#include <string>
#include <iostream>
#include <istream>
#include <ostream>
#include <iterator>

int main()
{
// don't skip the whitespace while reading
  std::cin >> std::noskipws;

// use stream iterators to copy the stream to a string
  std::istream_iterator<char> it(std::cin);
  std::istream_iterator<char> end;
  std::string results(it, end);

  std::cout << results;
}

Sau khi nghiên cứu giải pháp của KeithB bằng cách sử dụng std::istream_iterator, tôi phát hiện ra std:istreambuf_iterator.

Chương trình kiểm tra để đọc tất cả đầu vào được ghép vào một chuỗi, sau đó viết lại:

#include <iostream>
#include <iterator>
#include <string>

int main()
{
  std::istreambuf_iterator<char> begin(std::cin), end;
  std::string s(begin, end);
  std::cout << s;
}

Có thể là đơn giản nhất và thường hiệu quả:

#include <iostream>
int main()
{
    std::cout << std::cin.rdbuf();
}

Nếu cần, hãy sử dụng luồng thuộc các loại khác như std::ostringstreambộ đệm thay vì luồng đầu ra tiêu chuẩn ở đây.

Bạn có thể sử dụng hàm std :: istream :: getline () (hoặc tốt hơn là phiên bản hoạt động trên hàm std :: string ) để lấy toàn bộ dòng. Cả hai đều có phiên bản cho phép bạn chỉ định dấu phân cách (ký tự cuối dòng). Mặc định cho phiên bản chuỗi là '\ n'.

Lưu ý phụ đáng buồn: Tôi quyết định sử dụng C ++ IO để phù hợp với mã dựa trên tăng cường. Từ câu trả lời cho câu hỏi này tôi đã chọn while (std::getline(std::cin, line)). Sử dụng g ++ phiên bản 4.5.3 (-O3) trong cygwin (mintty), tôi nhận được thông lượng 2 MB / s. Microsoft Visual C ++ 2010 (/ O2) đã làm cho nó 40 MB / s cho cùng một mã.

Sau khi viết lại IO thành C thuần túy while (fgets(buf, 100, stdin)), thông lượng đã tăng lên 90 MB / s trong cả hai trình biên dịch được thử nghiệm. Điều đó tạo ra sự khác biệt cho bất kỳ đầu vào nào lớn hơn 10 MB ...

while(std::cin) {
 // do something
}

Chờ đã, tôi hiểu bạn có đúng không? Bạn đang sử dụng cin để nhập bàn phím và bạn muốn dừng đọc đầu vào khi người dùng nhập ký tự EOF? Tại sao người dùng lại nhập ký tự EOF? Hay ý của bạn là bạn muốn ngừng đọc từ một tệp tại EOF?

Nếu bạn thực sự đang cố gắng sử dụng cin để đọc một ký tự EOF, thì tại sao không chỉ định EOF làm dấu phân cách?

// Needed headers: iostream

char buffer[256];
cin.get( buffer, '\x1A' );

Nếu bạn muốn dừng đọc từ một tệp tại EOF, thì chỉ cần sử dụng getline và một lần nữa chỉ định EOF làm dấu phân cách.

// Needed headers: iostream, string, and fstream

string buffer;

    ifstream fin;
    fin.open("test.txt");
    if(fin.is_open()) {
        getline(fin,buffer,'\x1A');

        fin.close();
    }

Một tùy chọn là sử dụng một thùng chứa, ví dụ:

std::vector<char> data;

và chuyển hướng tất cả đầu vào vào bộ sưu tập này cho đến khi EOFnhận được, tức là

std::copy(std::istream_iterator<char>(std::cin),
    std::istream_iterator<char>(),
    std::back_inserter(data));

Tuy nhiên, vùng chứa đã sử dụng có thể cần phân bổ lại bộ nhớ quá thường xuyên, hoặc bạn sẽ kết thúc với một std::bad_allocngoại lệ khi hệ thống của bạn hết bộ nhớ. Để giải quyết những vấn đề này, bạn có thể dự trữ một lượng Nnguyên tố cố định và xử lý riêng lẻ lượng nguyên tố này, tức là

data.reserve(N);    
while (/*some condition is met*/)
{
    std::copy_n(std::istream_iterator<char>(std::cin),
        N,
        std::back_inserter(data));

    /* process data */

    data.clear();
}