Difficulty with program which has to open hundreds of files at a time.

Hello, at the moment I am writing a program which needs to open, close and modify many different files at the same time (typically over 100 at a given time). Because of this requirement of the project, I decided to make a class which contains a vector of pointers to the different fstream instances for the files. That way I have a simple and 'clean' way to handle this many files. The fact that I am using vectors also means I can easily add new fstream instances (open new files) just by using the push_back method etc.

For some reason, I'm having a bit of difficulty getting it to open a new file (it shouldn't be this hard). The program compiles it just doesn't do what I want it to, and I can't work out where the problem is.

Code:

#include <fstream>
#include <vector>
#include <string.h>

using namespace std;

class CFileManage
{
      private:
              CFileManage();
              virtual ~CFileManage();
              
              vector<fstream *> m_file;
              static CFileManage * hcInstance;
              
      public:
             /* Make sure only one instance of this class is generated */
             static CFileManage * GetClassInstance();
             static void GenerateClassInstance();
             
             void DeleteClassInstance();
             
             /* Make use of the i/o filestream vectors */
             bool CreateNewFileInstance(char * filename);
             void CreateNewFileInstance(string filename);
             
             void CloseFileInstance(unsigned int vec_idx);
             void CloseAllFileInstances();
             
             unsigned int GetNumberOfFileInstances();
             
             fstream * GetFileInstance(unsigned int vec_idx);
};

Code:

bool CFileManage::CreateNewFileInstance(char * filename)
{
     m_file.push_back( new fstream );

     m_file.back()->open(filename);
     
     if( m_file.back()->is_open() )
     {
         return false;
     }
     
     return true;
}

void CFileManage::CloseAllFileInstances()
{
     int idx;
     
     for(idx=0; idx < m_file.size(); idx++)
     {
                m_file[idx]->close();
                delete m_file[idx];
     }
     
     m_file.clear();
     
     return;
}

For some reason, the code compiles, but it doesn't work as expected when it comes to making a new file.

At a later date I plan to change the CreateFile Methods so that it allows support for binary files aswell as different modes, e.g. app, ate, trunc etc.

Many systems limit the number of open files a process is allowed to have open at one time.
"hundreds" is pushing (or exceeded) such limits.

Also, shouldn't you make sure that the fstream is opened successfully before pushing it into the vector? What good will it do in the vector if it isn't actually open?

If your program is also creating these files, you should think of archiving them (.pak, .zip, .tar, .7z, etc.) into one file. It's faster and you shouldn't have this problem.

I'm going to echo what Salem stated b/c it was my understanding that file handles were precious resources in most operating systems. I certainly doubt the OS would let you open hundreds of files at one time. You will have to open a few at a time, do your operations on them, close them, wash, rinse, repeat for the number of files you need to work on.