smart pointer on field of struct - c++

Question

I have read that one must not store std::auto_ptr in std::vector and that boost::ptr_vector could be used instead. I have been able to do so, I don't know however how to use ptr_vector, when I don't want to store pointers, but a struct, which has a pointer member.
In this example, I want to open some files and store the associated ofstream object with some additional data, for later use. I would like to replace the file field of struct data with a smart pointer. Since the vector<data> v should be the owner, I think that a shared_ptr would work, but wouldn't be appropriate.
What should I replace the naked pointer file with?
#include <iostream>
#include <fstream>
#include <vector>
struct data {
std::string filename;
std::ofstream* file;
data(const std::string filename, std::ofstream* file)
: filename(filename), file(file)
{
}
};
std::vector<data> open_files()
{
std::vector<data> v;
v.push_back(data("foo", new std::ofstream("foo")));
return v;
}
int main()
{
std::vector<data> v = open_files();
/* use the files */
*(v[0].file) << "foo";
delete v[0].file; // either rely on dtor to close(), or call it manually
}
Update:
I feel I have done a sub optimal job in describing my problem, let me try with another example. Also I am looking for a C++03 solution:
#include <memory>
#include <vector>
#include <boost/ptr_container/ptr_vector.hpp>
struct T {
std::auto_ptr<int> a;
};
int main()
{
// instead of
// std::vector<std::auto_ptr<int> > v;
// use
boost::ptr_vector<int> v;
// what to use instead of
// std::vector<T> w;
}

Answer 1

Concerning your data class, I would suggest using an std::unique_ptr<std::ofstream>. This is not to save you from an accidental memory leak, since you are deleting the pointer in the constructor, but rather to make the ownership explicit. A user of your code would have to know what data is doing with the pointer it takes in the constructor:
std::ofstream ofs;
{
data d1("crash", &ofs);
} // error! d1 will attempt to delete stack allocated object
std::ofstream* pOfs = new std::ofstream(....);
data d2("crash again", pOfs);
delete pOFs; // user thinks data makes a deep copy
However, with unique_ptr the intend is clear, hence it is harder to make mistakes:
data d3("OK", std::unique_ptr<std::ofstream>(new std::ofstream(....)));
std::unique_ptr<std::ofstream> pOfs2(new std::ofstream(....));
data d4("OK", pOfs2); // safe, pOfs's contents have been safely moved
// we can check pOfs2 after the move
if (pOfs2) { /* */ }

Answer 2

You can delete pointer in destructor:
struct data
{
std::string filename;
std::ofstream* file;
data(const std::string filename, std::ofstream* file)
: filename(filename), file(file)
{
}
~data()
{
delete file;
}
};
Or use std::unique_ptr to wrap that pointer but its unnecessary in your case.

Answer 3

You don't need to have an ofstream* as a member.
#include <iostream>
#include <fstream>
#include <vector>
struct data {
std::string filename;
data(const std::string filename) : filename(filename)
{}
};
std::vector<data> open_files()
{
std::vector<data> v;
v.push_back(data("foo"));
return v;
}
If you want to append to the file, specify the app file mode.
void print_files(const std::vector<data>& v)
{
for(std::vector<data>::const_iterator it = v.begin(); it != v.end(); ++it)
{
std::ofstream os(it->filename, std::ostream::app);
os << "bar";
}
}
int main()
{
std::vector<data> v = open_files();
print_files(v);
}