Default "NULL" value for an ofstream

Question

I have currently a function

int myfun(const int a) {
    ...
    return rval;
}

that performs several actions.

I mean to adapt it to write debug information on its behaviour or not according to some parameter that I can pass. In the cases I want to write that info, I also want to pass the ofstream to use. And I want applications that were using myfun to still work with no modifications.

So I would ideally change to

int myfun(const int a, ofstream & ofs) {
    ...
    if (!(ofs == NULL)) {
        ofs << ...
    }
    ...
    if (!(ofs == NULL)) {
        ofs << ...
    }
    return rval;
}

with a default value similar to &ofs=NULL. I know NULL is not appropriate.

What is an appropriate way of handling this?

Note 1: I could pass an optional parameter with the output file name, but that is less flexible.

Note 2: I could also change to

int myfun(const int a, const bool debug_info, ofstream & ofs) {
    ...
    if (debug_info) {
        ofs << ...
    }

with a default value debug_info=false. I guess this still requires a default value for ofs as above.

Note 3: The accepted answer in Default ofstream class argument in function proposes an overload without the ofs parameter. In my case that may not work, as I mean to not write anything when "ofs=NULL".

Note 4: This other answer apparently works, but it seems somewhat contrived to me, and I am not sure it provides all the same functionality as with passing an ofs.

Related:

Is there a null std::ostream implementation in C++ or libraries?

Make an abstract Logger class. In one implementation you can write to an ofs, and in the other do something else. Pass in the logger by reference into myfun(). — schteppe, Sep 06 '20 at 10:17
@schteppe - Would this require replicating `myfun`? I mean to modify `myfun`, and doing it at two separate places should be avoided. — sancho.s ReinstateMonicaCellio, Sep 06 '20 at 10:28
no, the implementation would stay the same for myfun. I’ve posted pseudocode in an answer now. — schteppe, Sep 06 '20 at 10:55
You could use a *no-op ostream*, which is very easy to implement. https://stackoverflow.com/questions/11826554/standard-no-op-output-stream/11826787 — Eljay, Sep 06 '20 at 13:36

artm · Accepted Answer · 2020-09-06T10:31:26.763

2

I want applications that were using myfun to still work with no modifications.

If so, use an ofs with default nullptr

int myfun(const int a, ofstream *ofs = nullptr)
{
    if (ofs != nullptr)
    {
        // (*ofs) << ... ;
    }

    // ...
}

You can't use a reference parameter ofstream& ofs for such function because a reference cannot be null.

edited Sep 06 '20 at 10:31

answered Sep 06 '20 at 10:08

artm

17,291
6
38
54

Simple solution! Detail: within `myfun` one should use `(*ofs)` instead, e.g., `(*ofs) << ...;`. – sancho.s ReinstateMonicaCellio Sep 06 '20 at 10:25
that was commented code, but surely it should be `(*ofs)`. Btw, you can also remove the `nullptr` comparison as well by just `if(!ofs)` – artm Sep 06 '20 at 10:32
1

This is what I ended up using. – sancho.s ReinstateMonicaCellio Sep 09 '20 at 18:17

schteppe · Answer 2 · 2020-09-07T15:12:32.603

2

Make an abstract Logger class. It has a method for logging a message. In derived classes you can add logging to file (ofstream) or simply do nothing. You can use any logger, the implementation of myfun() stays the same.

#include <fstream>

class Logger {
public:
    virtual void log(const char*) = 0;
};

class NullLogger: public Logger {
public:
    void log(const char*) override {};
};

class FileLogger: public Logger {
public:
    FileLogger(std::ofstream& s): ofs(s){}
    void log(const char* msg) override {
        ofs << msg;
    }
private:
    std::ofstream& ofs;
};

static NullLogger defaultLogger;
int myfun(const int a, Logger& logger=defaultLogger)
{
    logger.log("hello");
    // ...
    logger.log("asdf");
}

int main(){
    std::ofstream ofs;
    FileLogger fileLogger(ofs);
    NullLogger nullLogger;
    myfun(10,fileLogger); // logs to file
    myfun(10,nullLogger); // logs nothing
    myfun(10); // also logs nothing
    return 0;
}

edited Sep 07 '20 at 15:12

answered Sep 06 '20 at 10:53

schteppe

1,984
13
15

1

Good. You should add the default value for `logger`. As stated in the OP, I want applications that were using `myfun` to still work with no modifications. So `myfun(10)` should still work. – sancho.s ReinstateMonicaCellio Sep 06 '20 at 11:25
@sancho.sReinstateMonicaCellio I have to do some research to make sure that works first. Passing a mutable reference as default parameter seems to be a little bit problematic: https://stackoverflow.com/questions/2816293/passing-optional-parameter-by-reference-in-c?lq=1 – schteppe Sep 06 '20 at 11:54
@sancho.sReinstateMonicaCellio myfun(10) now works. See updated code in my answer. – schteppe Sep 07 '20 at 15:13

score 0 · Answer 3 · answered Sep 06 '20 at 10:28

In C++17 there is a solution involving std::optional but since it requires default constructible types, std::reference_wrapper has to be used too.

#include <fstream>
#include <optional>
#include <functional>

int myfun(const int a, std::optional<std::reference_wrapper<std::ofstream>> ofs)
{
    if (ofs) {
        ofs->get() << "...";
        return 1;
    }
    else{
        return 0;
    }
}
#include <iostream>
int main(){
    std::ofstream file;
    //Calling is quite nice.
    std::cout<<myfun(10,{file})<<'\n'; //Prints 1
    std::cout<<myfun(10,{})<<'\n'; //Prints 0
}

The downside of this solution, although idiomatic, is being verbose and heavy on the syntax in some cases.

As stated in the OP, I want applications that were using `myfun` to still work with no modifications. So `myfun(10)` should still work. — sancho.s ReinstateMonicaCellio, Sep 06 '20 at 11:27

Default "NULL" value for an ofstream

3 Answers3

Linked