Static Parameter Class

Environment: Should run under any OS

The problem:


The other day I was caught with a dilemma. You see I had a group of
several threads that required access to parameters that are currently
stored in a file. My first instinct was to just make a class to load
the data so that each thread could instantiate a copy of this. This
however just sort of rubbed me the wrong way. There had to be a
better way.


My Solution:


I came up with an idea, which I don’t think is all that new, but it
did catch a few people off guard. I put a little twist on the old
Singleton object. You see I decided to create a Singleton object with
a series of static member functions and member variables. This way I
never have to either instantiate or cleanup the object. And all of my
threads have access to the data without obtaining a referance to it,
because all of the data is availabile through static methods.


My example has all of the thread synchronization removed for clarity,
also I used only the Standard Template Library objects to make
this class portable.


#include <iostream>
using namespace std;

#include “Parameters.h”

void main(int argc, char* argv[])
{
//**************************************************************
//* The parameters are accessed without an instance of the class
//**************************************************************
cout << "Name: " << CParameters::getName().c_str() << endl; cout << "Version " << CParameters::getVersion() << endl; }


The Header File:



class CParameters
{
public:
static string getName();
static int getVersion();
static void load(string fileName);
virtual ~CParameters();
private:
CParameters();
static string m_ProgramName;
static int m_Version;
static CParameters instance;
};

The .cpp File



#include <string>
#include <fstream>
using namespace std;

#include “Parameters.h”

////////////////////////////////////////////////////////////////
// Construction/Destruction
////////////////////////////////////////////////////////////////

//**************************************************************
//* Here I set default values to my static variables
//**************************************************************
string CParameters::m_ProgramName = “Undefined”;
int CParameters::m_Version = 0;

//**************************************************************
//* Here I invoke my constructor and load my variables
//**************************************************************
CParameters CParameters::instance = CParameters();

//**************************************************************
//* Since this is a private method it can only be invoked by the
//* previous line
//**************************************************************
CParameters::CParameters()
{
load(“default.dat”);
}

//**************************************************************
//* No cleanup required since we didn’t make anything on the heap
//**************************************************************
CParameters::~CParameters()
{

}

//**************************************************************
//* I put this in to change the values after the program has
//* started. Mind you in my case this was unnecessary.
//**************************************************************
void CParameters::load(string fileName)
{
// Open the parameters file
ifstream in(fileName.c_str(), ios::in);

// Did it open?
if (in)
{
// Yes, load up our data
in >> m_Version >> m_ProgramName;

// now, close the file
in.close();
}
}

//**************************************************************
//* Access methods incase you don’t want to make your static
//* variable public
//**************************************************************
int CParameters::getVersion()
{
return m_Version;
}

string CParameters::getName()
{
return m_ProgramName.c_str();
}

Downloads

Download source – 2 Kb
Download demo project – 5 Kb

History

More by Author

Must Read