Thread: yes, file streams are not file pointers

This seems to work:

Code:

#include <iostream>
#include <vector>
#include <fstream>


int main()
{
    std::vector<std::ofstream*> v;


    v.push_back(new std::ofstream("data1.txt"));
    v.push_back(new std::ofstream("data2.txt"));


    int n = 42;
    *v[0] << n;
    *v[1] << n;


    delete v[0];
    delete v[1];


    return 0;
}

In C++11 it's better to do:

Code:

#include <vector>
#include <fstream>
#include  <memory> 
 
int main()
{
    std::vector<std::unique_ptr<std::ofstream>> v{};
 
    v.emplace_back(new std::ofstream("data1.txt"));
    v.emplace_back(new std::ofstream("data2.txt"));
 
    int n = 42;
    *v[0] << n;
    *v[1] << n;
 
    return 0;
}

In C++14 you could use make_unique, which is even better.

First of all, vector<ofstream> wasn't right until C++11. Since C++11, vector<ofstream> and vector<vector<ofstream>> are both valid.

In C++03 there were no move semantics and STL containers required their values to be CopyConstructible and CopyAssignable. Currently, std::vector primarily requires its values to be only MoveConstructible and MoveAssignable, and std::ofstream certainly is. The only problem is that its move construction may throw exception, and thus certain vector modifications do not guarantee strong exception safety (unlike vector of unique_ptrs).

If you plan to store your container somewhere and/or you want more abstraction, consider using std::vector<std::unique_ptr<std::ostream>> (it will work not only on files, but also with other streams, e.g., console).

Code:

std::vector<std::ofstream> v1; // valid in C++11

std::vector<std::unique_ptr<std::ofstream>> v2;

std::vector<std::unique_ptr<std::ostream>> v3;

If you don't know what to choose, answer the following:
1. Are vectors only temporaries which work only on files? Use v1.
2. Are vectors only temporaries which work on different types of streams? Use v3.
3. Are vectors stored somewhere (e.g., in an object) and work only on files? Use v1 or v2 (v2 - stronger exception safety).
4. Are vectors stored somewhere (e.g., in an object) and work on different types of streams? Use v3.

Note: v3 can be used in all of the above situations, because it provides higher abstraction and guarantees stronger exception safety.

Thank you for the help, but now i have another question. I don't know when each file will pop-up therefore i need to create a d2 vector that captures all possible combinations that will eventually come up and as they appear open a file and write to it. Therefore, pushing or emplacing is not an option unless there is a way to push it to a specific position. so is it possible to do something like this :

Code:

int main()
{
    std::vector<std::unique_ptr<std::ofstream>> v1{};
    std::vector<std::vector<std::unique_ptr<std::ofstream>>> v(1,v1);
    v[0][0] = new std::ofstream("data1.txt")); // segmentation fault here
  
    int n = 42;
    *v[0][0] << n;
  
 
    return 0;
}

Are you using a C++11 compiler? Have you #include'd all the necessary headers?

The problem is two-fold:

First, streams are only moveable, but vector does not have a constructor that move constructs a sequence. It can only copy construct a sequence. What does this mean? It means that it does something like this:

AllocSpace();
m_elem[0] = arg[0];
// ...

This makes copies of the arguments you pass to it which is not allowed. Therefore, this cannot work.

Second, unique_ptr's constructor is explicit, therefore, this does not work:

std::unique_ptr<int> p;
p = new int;

You must explicitly create a new unique_ptr and move it into the new one:

std::unique_ptr<int> p;
p = std::unique_ptr<int>(new int);

Another problem that can bite you in the ass is that you use arrays unsafely. Use .at() instead of the index operator. It will prevent undefined behaviour, allowing you to find bugs at an earlier stage. You can read more here: http://sourceforge.net/apps/mediawik..._arrays_in_Cpp
Putting all this together, you get (which I tested):

Code:

int main()
{
	typedef std::unique_ptr<std::ofstream> Val_t;
	typedef std::vector<Val_t> InnerVector_t;

	std::vector<InnerVector_t> v;
	v.emplace_back();
	v.at(0).emplace_back(new std::ofstream("data1.txt"));

	int n = 42;
	*v.at(0).at(0) << n;


	return 0;
}

@baxy,
In your code in post #6 you've left out the all important delete but included a completely unnecessary close.

When you delete the fstream object its destructor will be called which will close the file.

The possibility of forgetting to delete the object is why people are telling you to use unique_ptr, whose constructor will call delete.