---

Hejsa,

Jeg har lavet en klasse, som giver lidt problemer.
Da den er inkluderet i et library og bliver benyttet af andre en mine egne
programmer, er jeg løbet ind i nogle sjove ting.

Klassen er meget speciel og vil nok dumpe fælt til en eksamen i OOA/D. Men
da det er reallife, kunne det nu ikke være anderledes.

Jeg har behov for at implementere en metode, der sikrer at klassen kun
bliver instansieret én gang. Hvis der bliver forsøgt at lave en ny instans
af klassen vil jeg smide en exception.

Gode råde/metoder søges. Klassen bliver brugt på diverse unix systemer som
HP/UX, Linux, Compaq.

På forhånd tak for hjælpen.

Peter

---

"Ace" <pvi@mail.sonofon.dk> writes:

> Hejsa,
>
> Jeg har lavet en klasse, som giver lidt problemer.
> Da den er inkluderet i et library og bliver benyttet af andre en mine egne
> programmer, er jeg løbet ind i nogle sjove ting.
>
> Klassen er meget speciel og vil nok dumpe fælt til en eksamen i OOA/D. Men
> da det er reallife, kunne det nu ikke være anderledes.
>
> Jeg har behov for at implementere en metode, der sikrer at klassen kun
> bliver instansieret én gang. Hvis der bliver forsøgt at lave en ny instans
> af klassen vil jeg smide en exception.

Der findes et design pattern til netop det der hedder Singleton ..

Proev at google efter "Singleton design pattern", saa finder du sikkert
ogsaa nogle naive C++ implementationer .

(Men, pas paa i en eksamens-situation, singleton patternet har nogle
faldgruber, f.eks. ifbm. traad-sikkerhed).


Mvh,

--
___
Soren Davidsen / o\
Math student, ICSMA (_____)
__ http://www.tanesha.net/ _________________________________(___)_______

---

> Jeg har behov for at implementere en metode, der sikrer at klassen kun
> bliver instansieret én gang. Hvis der bliver forsøgt at lave en ny instans
> af klassen vil jeg smide en exception.

Du skal såmænd bare lave en singleton. Jeg har et lille eksempel her - koden
kan ikke compile, for den er taget ud af en størrere samhæng - jeg har også
kortet koden lidt af.

Princippet er, at du laver en statisk metode til at konstruere objektet
med - og een til at destruere det med.
Din constructor og destructor skal være protected eller private - således at
man tvinges til at bruge de 2 statiske metoder.

Hvergang du skal bruge dit objekt, kalder du den Instance() på dit objekt,
som returnerer en pointer til dig.
Når du er færdig med objektet kalder du Destroy () .

Simpelt, men effektivt.

Du må lige sige til hvis der er noget du ikke forstår i koden.

// ------------ MorboFactory.h ------------------ //

class MorboFactory
{
private:

static Morbo2D *instance;

public:

static Morbo2D *Instance();
static Morbo2D *Destroy ();

};

// ------------ MorboFactory.cpp ------------------ //

#include "MorboFactory.h"

Morbo2D *MorboFactory::instance = 0;

Morbo2D *MorboFactory::Instance ()
{
return MorboFactory::instance;
};

Morbo2D *MorboFactory::Instance ()
{
if (MorboFactory::instance == 0)
MorboFactory::instance = new SingletonObjekt ();
}else { // kast exception f.eks. // }

return MorboFactory::instance;
};

Morbo2D *MorboFactory::Destroy ()
{
if (MorboFactory::instance != 0)
delete MorboFactory::instance;

return MorboFactory::instance;
};

---

Tak for hjælpen, Søren og Klaus.
Jeg vil forsøge med denne metode.