dynamic array or vector?

  
class ResourceManager
{
public:
  Resource LoadFile( const std::string& filename );

private:
  std::vector< std::string > mLoadedFiles;
};

Resource ResourceManager::LoadFile( const std::string& filename ) {
  // do loading processing here

  std::vector< std::string >::iterator file = mLoadedFiles.begin();
  std::vector< std::string >::iterator end = mLoadedFiles.end();
  for( ; file != end; ++file ) {
    if( stricmp( filename.c_str(), file->c_str() ) == 0 ) {
      // file''s already been loaded, return previous instance

      return Resource( filename ); // or something

    }
  }
  // load new Resource

  mLoadedFiles.push_back( filename );
}
  

    
        texture_s new_texture;

	static int f = 0;
	
	Log->Write(LOG_ERROR, "loop %d", f);
	f++;
        if(textures.size() == 0)
	{
		Log->Write(LOG_ERROR, "texture vector is empty, creating first texture.");
	}
	else
	{
		for(int j = 0; j < textures.size(); j++)
		{
		   Log->Write(LOG_ERROR, "sFileName = %s, textures[%d].location = %s", sFileName, j, textures[j].location);
		   if(strcmp(sFileName, textures[j].location) == 0) // sFileName is passed into the function we're in

		   {
				new_texture.BPP = textures[j].BPP;
				new_texture.width = textures[j].width;
				new_texture.height = textures[j].height;
				new_texture.size = textures[j].size;
				sprintf(new_texture.location, textures[j].location);
				textures.push_back(new_texture);
				Log->Write(LOG_ERROR, "width1 %d, width2 %d", new_texture.width, textures[ textures.size() - 1].width);
				return true;
		   }
		   j++;
		}
	}
    

        
#include <iostream>
#include <vector>
#include <string>

using namespace std;

class texture_s
{
public:
	unsigned int	width,

					height,
					BPP,
					ID,
					size;			// size in bytes

	string			location;		// where was the original file located? this will help us avoid redundancy and bloating

	
	texture_s() { }
	texture_s(const texture_s&) { }
	texture_s& operator =(const texture_s&) { return *this; }
	~texture_s() {}

};
vector <texture_s> textures;

bool LoadTGA(string sFileName)
{
	if(textures.size() == 0)
	{
		cout << "First pass, texture vector is empty" << endl;
	}
	for(int i = 0; i < textures.size(); i++)
	{
		cout << "textures[" << i << "].location = " << textures[i].location << ", sFileName = " << sFileName << endl;
		if(textures[i].location == sFileName)
		{ 
			textures.push_back(textures[i]); // this should add a copy of textures[i] to the end of the vector

			cout << "[" << sFileName << "] already loaded, adding a reference of ID " << textures[i].ID << " to element " << textures.size() - 1 << endl;
			return true;
		}
	}
	cout << "-------------------------------------------------------------------------\n";
	textures.insert(textures.end());
	textures[textures.size() - 1].BPP		= 32;
	textures[textures.size() - 1].width		= 128;
	textures[textures.size() - 1].height	= 128;
	textures[textures.size() - 1].size		= 48000;
	textures[textures.size() - 1].location  = sFileName;
	textures[textures.size() - 1].ID		= textures.size();
	//cout << "Adding texture [" << textures[textures.size() - 1].location << "] with ID " << textures[textures.size() - 1].ID << endl;

	return true;
}

int main()
{
	LoadTGA("Test1.tga");
	LoadTGA("Test2.tga");
	LoadTGA("Test3.tga");
	LoadTGA("Test4.tga");
	LoadTGA("Test5.tga");
	LoadTGA("Test4.tga");
	LoadTGA("Test6.tga");
	return 0;
}
    

  
texture_s::texture_s(const texture_s& r) : width(r.width),
                                           height(r.height),
                                           BPP(r.BPP),
                                           ID(r.ID),
                                           size(r.size),
                                           location(r.location)
{
}
  
texture_s& texture_s::operator =(const texture_s& r)
{
    if(this != &r)
    {
        width  = r.width;
        height = r.height;
        BPP    = r.BPP;
        ID     = r.ID;
        size   = r.size;
        location = r.location;
    }
      
    return *this;
}