ofstream doesn't write buffer to file

Question

I'm trying to write the contents of buf pointer to the file created by ofstream.

For some reason the file is empty, however the contents of buf is never empty... What am I doing wrong?

void DLog::Log(const char *fmt, ...)
{
    va_list varptr;

    va_start(varptr, fmt);

    int n = ::_vscprintf(fmt, varptr);
    char *buf = new char[n + 1];
    ::vsprintf(buf, fmt, varptr);

    va_end(varptr);

    if (!m_filename.empty())
    {

        std::ofstream ofstr(m_filename.c_str(), ios::out);

        ofstr << *buf; // contents of *buf are NEVER empty, however nothing is in file??

        ofstr.close();
    }


    delete [] buf;
}

Answer 1

You should check that the ofstream is open for writing after being created.

Answer 2

Is your stream opened before writing on it ? Could be anything from not-enough disk space to unsufficient permissions.

Also you may have an error:

ofstr << *buf;

Should be something like:

ofstr << buf;

Since buf is a char*, *buf gives a char, not a char*.

This is where using std::string instead of raw buffers/pointers makes sense ;)

Answer 3

the error is in line

ofstr << *buf;

it should be

ofstr << buf;

Answer 4

You need to flush the ofstream before closing it. Try ofstr.flush(); before ofstr.close(); I had this error some time ago when I thought that closing the stream automatically flushes it but, as it turned out, it doesn't.

Answer 5

Many problems can be solved by getting rid of the hairy stuff, like manual allocation management.

Never use new T[N] in your code: instead use std::vector<T> v(N);. Simply this alone might solve your problem, because the pointer stuff isn't in the way:

void DLog::Log(const char *fmt, ...)
{
    va_list varptr;
    va_start(varptr, fmt);

    int n = ::_vscprintf(fmt, varptr);
    std::vector<char> buf(n + 1);

    ::vsprintf(&buf[0], fmt, varptr);

    va_end(varptr);

    if (!m_filename.empty())
    {
        std::ofstream ofstr(m_filename.c_str(), ios::out);
        if (!ofstr) 
        {
            // didn't open, do some error reporting here
        }

        // copy each character to the stream
        std::copy(buf.begin(), buf.end(), std::ostream_iterator<char>(ofstr));

        // no need to close, it's done automatically
    }

    // no need to remember to delete
}

Much easier to read and maintain. Note even better would be a std::string buf(n + 1);, then you could just do ofstr << buf;. Sadly, std::string isn't currently required to store its elements contiguously, like std::vector. This means the line with &buf[0] isn't guaranteed to work. That said, I doubt you'll find an implementation where it wouldn't work. Still, it's arguably better to maintain guaranteed behavior.

I do suspect the issue was you dereferencing the pointer, though.