Kalle destruksjonsfunksjon for forskjellige typer

[☀ ❄]

Heisann,

 

Jeg har en template-klasse (la oss kalle den Resource) som blant annet inneholder en peker til en gitt type T. Jeg ønsker å avlede en klasse (som vi kan kalle Image) fra denne klassen. (Merk: "Avlede" betyr ikke nødvendigvis arv!) I den avledede klassen, Image, ønsker jeg å kunne spesifisere en funksjon som destruktøren kaller med T*-en som argument. Jeg har ikke kodet noe særlig på ganske lenge, og husker ikke lenger helt nøyaktig hvordan en del "language features" fungerer, og trenger derfor noen råd.

 

Vil det virke å bruke template specializations? Hvordan blir koden for det?

 

Min fremste idé: Hvordan blir det å arve Image fra Resource, og så overskrive destruktøren? Vil da først ~Image() kjøres, og deretter ~Resource()? Det er et viktig poeng at ~Resource() kaller delete på T*-en, men det gjør ingenting så lenge ~Image() setter T*-en til 0 når den er ferdig. Har jeg allerede løsningen her?

 

Takker på forhånd for all hjelp

 

Edit: Image skal ikke være en template, og skal bare gjelde for Resource<T> med én spesiell T

Endret 19. januar 2005 av Myubi

[kjetil7]

Litt usikker på hva du mener med avlede, men går ut fra at du enten ønsker å arve fra resource<T> eller ha resource<T> som medlemsvariabel i image-klassen? Eller ønsker du bare å ha medlemsfunksjoner i image som bruker resource<T> objekter?

 

Hvis du ønsker et av de to første må du enten gjøre image til en template-klasse ellers må T være forhåndsbestemt i image, som f.eks. resource<bitmap>.

 

Eksempler:

// kun for illustrasjon
class bitmap { };

template <class T>
class resource
{
};


// alternativ 1a
template <class T>
class image : public resource<T>
{
};

// alternativ 1b
class image : public resource<bitmap>
{
};

//alternativ 2a
template <class T>
class image
{
   resource<T> _res;
};

//alternativ 2b
class image
{
   resource<bitmap> _res;
};


// evenutelt...
class image
{
public:
   template <class T>
   void cleanup(resource<T> & res)
   {
       //...
   }

   // resource<T> kan ikke være medlemsvariabel...
};

 

D'tor spørsmålet:

 

Hvis image arver fra resource vil d'toren til image kjøres før d'toren til resource hvis du sletter et image objekt eller om resource d'toren er virtual.

 

Eks:

 

// kun for å illustrasjon
class bitmap 
{ 
};

// med non-virtual d'tor
template <class T>
class resource1
{
public:
   ~resource1()
   {
       std::cout << "~resource1" << std::endl;
   }
};

// med virtual d'tor
template <class T>
class resource2
{
public:
   virtual ~resource2()
   {
       std::cout << "~resource2" << std::endl;
   }
};


class image1 : public resource1<bitmap>
{
public:
   ~image1()
   {
       std::cout << "~image1" << std::endl;
   }
};


class image2 : public resource2<bitmap>
{
public:
   ~image2()
   {
       std::cout << "~image2" << std::endl;
   }
};


int main()
{
   image1*            img1a = new image1;
   resource1<bitmap>* img1b = new image1;
   
   image2*            img2a = new image2;
   resource2<bitmap>* img2b = new image2;


   delete img1a;
   std::cout << "-----" << std::endl;
   delete img1b;
   std::cout << "-----" << std::endl;
   delete img2a;
   std::cout << "-----" << std::endl;
   delete img2b;
}

 

Dette skulle demonstrere hvordan d'torene blir kalt og hva som er poenget med virtual d'tor. I de fleste tilfeller hvor du bruker arv skal du bruke virtual d'tor.

 

Håper dette ga noen svar.

 

Tar forbehold om småfeil i koden (har ikke kompilert den).

Endret 19. januar 2005 av kjetil7

[☀ ❄]

Ypperlig, det ga løsningen på alle problemstillingene jeg vurderte!

 

Jeg regner med at jeg vil velge løsningen der jeg arver fra "Resource" (min klasse heter noe annet, men samme det), og legger til en virtuell destruktør. Ville bare få forsikret meg om at begge destruktører ble kalt, og at de ble det i den rekkefølgen jeg regnet med.

 

Var forresten nettopp det jeg mente med at Image ikke skulle være en template og at den skulle gjelde for bare én type T i Resource<T> -- Altså: class Image : public Resource<something> {};

 

Takker for hjelpen