Writing to a file from multiple functions and replacing the values C++ - c++

Question

I have a file example.txt which will be updated with values by different functions at seperate lines. And the mentioned three functions will be in a timer loop so it will continuously calling the three functions again and again so the three functions will need to write the file with their updated values calculated in it.
For better understanding please see the example scenario,
First time when the functions called,
*Function1 is writing value of 1 at first line of the file.
*Function2 is writing value of 5 at second line of the file.
*Function3 is writing value of 7 at third line of the file.
Now again timer function calling the above three functions again and i am expecting the below output in the file to be written.
*Function1 should write value of 8 at first line of the file.
*Function2 should write value of 9 at second line of the file.
*Function3 should write value of 10 at third line of the file.
Sample program :
#include <iostream>
#include <fstream>
using namespace std;
void writeToFile(int seq)
{
fstream myfile;
myfile.open("example.txt",fstream::in | fstream::out | fstream::app );
myfile << seq <<endl;
myfile.close();
}
void A()
{
writeToFile(5);
}
void B()
{
writeToFile(2);
}
void C()
{
writeToFile(4);
}
//assume timer function called for every 20secs;
void timer_func()
{
A();
B();
C();
}
int main()
{
timer_func();
return 0;
}
Please suggest me some possible ways to attain it.

Answer 1

Consider keeping the file in memory in a class and writing it as soon as something changes. And remember thread safety, if applicable.

Answer 2

It is bad idea to do things in that way, but if you want so...
#include <string> // string
#include <fstream> // fstream
#include <cstdio> // snprintf
#include <cassert> // assert
#include <cstring> // memset
#define INITIAL_LINE_COUNT 3
#define INITIAL_FILE_NAME "example.txt"
// singleton class that provides writing to the file
class LineWriter
{
private:
std::fstream m_file;
int m_line_count;
// common singleton implementation
LineWriter() = delete;
~LineWriter() = default;
LineWriter(const LineWriter&) = delete;
LineWriter& operator = (const LineWriter&) = delete;
LineWriter(LineWriter&&) = delete;
LineWriter& operator = (LineWriter&&) = delete;
LineWriter(const std::string& filename, int line_count)
{
m_file.exceptions(std::fstream::badbit);
m_file.open(
filename,
std::fstream::out | std::fstream::binary
);
// fill the file with empty 16-byte length strings ended by CRLN
{
for (int i = 0; i < line_count; ++i)
{
m_file.write(" \r\n", 16);
}
}
m_line_count = line_count;
}
public:
void write(int line, int value)
{
// just to check that everything is ok
assert(m_file.is_open());
assert(line <= m_line_count && line > 0);
char buffer[14];
int size = std::snprintf(buffer, 14, "%d", value);
// calculate position of line
// just simple (line - 1) * 16
int pos = (line - 1) << 4;
// clear previous value
m_file.seekp(pos);
m_file.write(" ", 14);
// write new one
m_file.seekp(pos);
m_file.write(buffer, size);
}
static LineWriter& get_instance()
{
static LineWriter instance(INITIAL_FILE_NAME, INITIAL_LINE_COUNT);
return instance;
}
};
void write_to_file(int line, int value)
{
LineWriter::get_instance().write(line, value);
}
void call_a() { write_to_file(1, 5); }
void call_b() { write_to_file(2, 13); }
void call_c() { write_to_file(3, 2); }
void timer_func()
{
call_a();
call_b();
call_c();
}
int main()
{
while (true)
{
timer_func();
}
}
As mentioned #n.m. it is much better to just cache result of all functions and write them single time (if there are not so many lines).
If there are a lot of values and strings, so it is better to use database engines like sqlite as mentioned #JesperJuhl in coments.
Also this example is not thread safe, if you need call this writer from multiple threads just add member mutex lock at the top of LineWriter::write method: