Special type of singleton needed

[BigMan]

I need to design a class that meets the following requirements:

-the class may not have more that one instance;
-the instance needs arguments for initialization;
-accessing the instance must not require any arguments;

Any ideas and comments are welcome.

 

[msalters]

I need to design a class that meets the following requirements:

-the class may not have more that one instance;
-the instance needs arguments for initialization;
-accessing the instance must not require any arguments;

How do you plan to provide the arguments? It's of course easy
to provide a static setArguments(...) method for your Singleton
class which you must call before calling the canonical
static Singleton& getInstance().

The private ctor/public static getInstance pattern guarantees
your first and third conditions, but there's no way to enforce
at compile time that setArguments is called. At best you can
throw from getInstance().

HTH,
Michiel Salters

 

[smreddy]

I need to design a class that meets the following requirements:

-the class may not have more that one instance;
-the instance needs arguments for initialization;
-accessing the instance must not require any arguments;

Any ideas and comments are welcome.

class myClass
{

private:
static myClass *_instance;
int pID;
protected:
public:
myClass(int processID) id(processID){
}
static myClass* Instance (int processID) {
try {
_instance = new myClass(processID)
return _instance;
}catch (...)
{
}
}

static myClass* Instance () {
return _instance;
}
};

int main()
{
myClass *OBJ = myClass::Instance(10003);


//
//
//
}

hope this is what you are looking for.

 

[smreddy]

I need to design a class that meets the following requirements:

-the class may not have more that one instance;
-the instance needs arguments for initialization;
-accessing the instance must not require any arguments;

Any ideas and comments are welcome.

class myClass
{

private:
static myClass *_instance;
int pID;
protected:
public:
myClass(int processID) id(processID){
}
static myClass* Instance (int processID) {
try {
_instance = new myClass(processID)
return _instance;
}catch (...)
{
}
}

static myClass* Instance () {
return _instance;
}
};

int main()
{
myClass *OBJ = myClass::Instance(10003);


//
//
//
}

hope this is what you are looking for.

 

[Ioannis Vranos]

I need to design a class that meets the following requirements:

-the class may not have more that one instance;
-the instance needs arguments for initialization;
-accessing the instance must not require any arguments;

Any ideas and comments are welcome.

That's very easy, you will just use a static data member.

 

[BigMan]

Could you please provide us with some code to demonstrate your idea?

 

[Ioannis Vranos]

Could you please provide us with some code to demonstrate your idea?

class SomeClass
{
static SomeClass obj;

// The rest of your code

public:
SomeClass(int) { /* ... */}


};

SomeClass SomeClass:bj(4);


or


class SomeClass
{
static SomeClass *p;

// The rest of your code

public:
SomeClass(int) { /* ... */}


};

SomeClass *SomeClass:= new SomeClass(4);

 

[BigMan]

OK, I can make at least 2 instances of SomeClass. Here's how:

SomeClass Instance1( 1 );
SomeClass Instance2( 2 );

And hence this is not a singleton.

 

[Ioannis Vranos]

OK, I can make at least 2 instances of SomeClass. Here's how:

SomeClass Instance1( 1 );
SomeClass Instance2( 2 );

And hence this is not a singleton.

Make the constructor private. I did not provide a complete solution but
only a way to start. Because it looks like a homework, that's why.


class SomeClass
{
static SomeClass *p;

private:
SomeClass(int x)
{
// Process x
}

// The rest of your code

};


SomeClass *SomeClass:= new SomeClass(4);

 

[Default User]

OK, I can make at least 2 instances of SomeClass. Here's how:

SomeClass Instance1( 1 );
SomeClass Instance2( 2 );

And hence this is not a singleton.

Please include quotes with your post to provide context for your
replies.



Brian

 

[BigMan]

OK, this is all fine. There is, however, one minor peculiarity: I must
initialize the object in the main function.

 

[Ioannis Vranos]

OK, this is all fine. There is, however, one minor peculiarity: I must
initialize the object in the main function.

class SomeClass
{
static SomeClass *p;

static bool activated;

int x;

SomeClass(int newValue):x(newValue) {}


public:

static void initialise(int newValue)
{
if(!activated)
{
p= new SomeClass(newValue);

activated=true;
}
}

// The rest of your code

};


SomeClass * SomeClass:= 0;
bool SomeClass::activated= false;


int main()
{
SomeClass::initialise(4);
}




That's the last piece of code that I provide. If you do not try
yourself, how will you learn?