Calling function when last instance of class is destructed / overwrited - c++

Question

I'm trying to create a class wrapping fopen() / fclose() / f* methods. I want to use this method for other purposes, that's why I don't want to use smart pointers.
The problem is I don't know when to call fclose() or other 'end of life' functions. Destructor could be called but in the meantime FILE * was copied to another object for example by copy constructor.
I tried writing 'Reference Counter' class (that will be base class of all classes) but unfortunately I'm not able to call pure virtual methods from constructor / destructor.
This is what I've tried:
class ReferenceCounter
{
public:
ReferenceCounter()
{
ReferenceCount = new unsigned int(0);
AddRef();
}
ReferenceCounter(const ReferenceCounter & CopyFrom)
{
ReferenceCount = CopyFrom.ReferenceCount;
AddRef();
}
ReferenceCounter & operator = (const ReferenceCounter & AssignFrom)
{
RemoveRef();
ReferenceCount = AssignFrom.ReferenceCount;
AddRef();
return *this;
}
~ReferenceCounter()
{
RemoveRef();
}
virtual void OnInit() = 0;
virtual void OnDestruct() = 0;
private:
unsigned int * ReferenceCount;
void AddRef()
{
if(++*ReferenceCount == 1)
OnInit();
}
void RemoveRef()
{
if(--*ReferenceCount == 0)
{
OnDestruct();
delete ReferenceCount;
}
}
};
Maybe there is a way to 'overwrite' or 'overlay' one class over another?
Example:
class File
{
public:
File(std::string FileName)
{
F = fopen(FileName.c_str(), ...);
}
~File()
{
fclose(F);
}
private:
FILE * F;
};
int main()
{
File File1("a.txt");
auto File2 = File1;
//SegFault = fclose called twice for File1 and File2
}

Answer 1

There are two solutions here, which work in tandem.
First, don't allow assignment or copying of your "file handle" class.1
class File
{
// C++11 solution: use =delete
public:
File(File & const) = delete;
File & operator=(File & const) = delete;
// C++ < 11 solution: make them private and *don't implement them*:
private:
File(File & const);
File & operator=(File & const);
};
Second, consider only passing references to a single File object. (The compiler won't let you copy File objects anymore, so if you are doing this by accident you will get a compiler error -- this is good, because it will help you identify areas you need to fix.)
If it's too difficult to establish a single point of ownership, then consider instead passing instances using std::shared_ptr<File> which does exactly the kind of reference counting you are trying to implement -- the File will be deleted (and therefore its destructor called) when the last std::shared_ptr is itself destructed.
auto file = std::make_shared(new File{"a.txt"});
auto file2 = file;
// file.use_count() and file2.use_count() are now both 2.
//
// When file2 is destructed this will drop to 1; when file is destructed this will
// drop to 0, and the File object will be deleted.
1 Note that you could probably implement copying using dup(), though semantics for assignment may be a bit trickier -- should assignment close the existing handle and dup() the handle being assigned? If you do implement dup() functionality I would be more inclined to make it a member function instead so that its usage is explicit instead of happening automatically when you may not intend it to.

Answer 2

You can use a shared pointer with fclose as deleter:
#include <cstdio>
#include <memory>
#include <stdexcept>
class File
{
private:
typedef std::shared_ptr<FILE> shared_file;
public:
// You might consider const char*
File(const std::string& FileName, const std::string& Mode)
: F(std::fopen(FileName.c_str(), Mode.c_str()), fclose)
{
if( ! F.get()) {
throw std::runtime_error("File Open Failure");
}
}
private:
shared_file F;
};
int main()
{
File File1("/tmp/test.txt", "r");
auto File2 = File1;
}