1

我需要编写两个程序write.cpp并read.cpp同时运行。其中一个写入（覆盖）文件，另一个从文件中读取。

基本上，文件中总是只有一行。

write.cpp成功执行操作但read.cpp不显示任何内容。使用tail -f也显示不正确的结果。

写.cpp：

#include <stdio.h>
#include <ctime>
#include <unistd.h>
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main () {
  ofstream myfile;
  int i = 70;
  char c;
  while(i <85)
  {
      myfile.open ("example.txt");
      c = i++;
      myfile << c << endl;
      myfile.close();
      sleep(1);
  }
  return 0;
}

读取.cpp：

#include <iostream>
#include <fstream>
#include <string>
#include <unistd.h>

using namespace std;

int main () {
  string line;
  ifstream myfile ("example.txt");
  if (myfile.is_open())
  {
    while ( myfile.good() )
    {
      sleep(1);
      getline (myfile,line);
      cout << line << endl;
    }
    myfile.close();
  }

  else cout << "Unable to open file";

  return 0;
}

我可以知道这两个程序的哪一部分导致了问题，我该如何解决？

4

2 回答 2

3

您在编写器中做的是正确的事情，但是一旦您读取到文件末尾，输入流将变得不可用，直到fail条件设置好。最好的解决方案可能是完全按照您在编写器中所做的事情：每次在读取循环中打开和关闭文件。

请注意，文件有时会为空；当您在 writer 中打开要写入的文件时，它会被截断，如果 reader 恰好在这个时刻尝试读取，它会找到一个空文件。（这不是什么大问题；只要注意它，sleep如果你发现一个空行，可能会跳过。）

于 2013-02-20T10:30:37.343 回答
2

为了在我对您之前的问题的回答中添加一些细节，如果您坚持使用文件，您可以使用Boost 的进程间通信来实现这一点。

作家可能看起来像这样：

#include <boost/interprocess/sync/file_lock.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>
#include <fstream>
#include <iostream>

int main()
{
    using namespace boost::interprocess;
    std::string line, shared_filename = "shared";

    {
        std::ofstream create_shared_file(shared_filename.c_str());
    }

    for (;;)
    {
        std::cout << "Enter some text: ";
        std::cin >> line;

        try
        {
            file_lock lock(shared_filename.c_str());
            scoped_lock<file_lock> lock_the_file(lock);

            std::ofstream shared_file(shared_filename.c_str(), std::ofstream::trunc);
            shared_file << line << std::endl;
            shared_file.flush();
        }
        catch (interprocess_exception const& e)
        {
            std::cerr << e.what() << std::endl;
        }
    }
}

对应的阅读器：

#include <boost/interprocess/sync/file_lock.hpp>
#include <boost/interprocess/sync/sharable_lock.hpp>
#include <fstream>
#include <iostream>
#include <unistd.h>

int main()
{
    using namespace boost::interprocess;
    std::string line, shared_filename = "shared";

    for (;;)
    {
        try
        {
            file_lock lock(shared_filename.c_str());
            std::cout << "Waiting for file lock..." << std::endl;
            sharable_lock<file_lock> lock_the_file(lock);
            std::cout << "Acquired file lock..." << std::endl;

            std::ifstream shared_file(shared_filename.c_str());
            shared_file >> line;

            if (line.empty())
            {
                std::cout << "Empty file" << line << std::endl;
            }
            else
            {
                std::cout << "Read: " << line << std::endl;
            }
        }
        catch (interprocess_exception const& e)
        {
            std::cerr << "Could not lock " << shared_filename << ": " << e.what() << std::endl;
        }

        std::cout << "Sleeping..." << std::endl;
        sleep(2);
    }
}
于 2013-02-21T05:22:09.873 回答