Question

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

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

write.cpp成功执行操作，但read.cpp未显示任何内容。使用tail -f也会显示错误的结果。

write.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;
}

read.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;
}

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

Answer 1

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

请注意文件为空时会有一段时间;当您在编写器中打开文件进行写入时，它将被截断，如果读者恰好在此刻尝试读取，则会找到一个空文件。（这不是什么大问题;只要注意它，如果你找到一个空行，可能会跳过sleep。）

Answer 2

要将一些详细信息添加到my answer到your previous question，如果您坚持使用Boost's interprocess communication文件，可以使用ipc来实现此目的。

作家可能看起来像这样：

#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);
    }
}

如何在C ++中同时写入和读取文件

write.cpp：

read.cpp：

2 个答案: