Thread: Should I make this a singleton?

With it still being a singleton, you can have a set parameters function to set the parameters. Then either create the object then or save them for when you need them. If you are creating the object then (because you know the program will always need it and there's no need to wait), then just make a Create function.

No, make a function that will initialize the object and create it with new. Then, make sure you call this function early in the program, before you try to use the singleton. Pass the user input to the function at that time, and that function calls the constructor with the data.

You could have the initialization variables saved in the class itself, but that would only make sense if you wanted to optimize it by not instantiating the class until it is needed.

Either way, the getInstance() method can just return the pointer, and if it hasn't been created then throw some sort of error. It won't need to take any parameters.

I agree with CornedBee on this one. The thing with singletons is that, by design, you will normally know the state in which the object should initially be created.

The approach I would use (if, hypothetically, I wanted to do what you are trying to do) would be something like this;

Code:

clase CObject
{
    public:
        static CObject * getInstance(); //To get the instance of the object and create it if it wasn't already created

        void SetParameters(param A, param B);
        void methodA();
    private:
        static CObject * mTheObject;
}

CObject * CObject::getInstance()
{
  if (mTheObject==0)
          mTheObject=new CObject;
  return mTheObject;
}

void CObject::SetParameters(param A, param B)
{
     // set parameters for current instance
}

If you really must have the parameters as arguments to a constructor (which I would query the value of), then do this;

Code:

clase CObject
{
    public:
        static CObject * getInstance(); //To get the instance of the object and create it if it wasn't already created

        static CObject *SetParameters(param A, param B);

        CObject();
        CObject(param A, param B);

        bool CheckParameters(param A, param B);   // return true if object has the same parameters
        void methodA();
    private:
        static CObject * mTheObject;
}

CObject * CObject::getInstance()
{
  if (!mTheObject)
          mTheObject=new CObject;   // assumes you have supplied a default constructor
  return mTheObject;
}

CObject CObject::SetParameters(param A, param B)
{
      if (!mTheObject)
          mTheObject = new CObject(A, B);
      else if (!mTheObject->CheckParameters(A, B))
      {
            if (we_want_exception_safety_and_can_tolerate_two_objects_existing_temporarily)
            {
                  CObject *temp = new CObject(A, B);
                  delete mTheObject;
                  mTheObject = temp;
            }
            else
            {
                  delete mTheObject;
                  mTheObject = new CObject(A, B);
            }
      }
      return mTheObject;
}

Both approaches require the user of your class to set the parameters once (the first approach does this after creating the first instance). They also allows for those parameters to be reset by the user. The difference is that the second approach does this by destroying any existing object and creating a new one.

If you want to construct your object with parameters, those seem a bit complicated. Why not just use a create function and always do the creation in there instead of inside getInstance.