[C++] Classi

[ing82]

Prova n° 2

#include <iostream>
#include <stdlib.h>
#include <memory>

using namespace std;

  class Prova
  {
    public:
      Prova(){cout<<"\nCreato l'oggetto Prova!";};
      ~Prova(){cout<<"\nDistrutto l'oggetto Prova!";};
      void run(){cout<<"\nProva is running!";};
      void pause(){cout<<"\nProva is paused!";};
      void termin(){cout<<"\nProva is terminated!";};
  };

  class Oggetto
  {
    public:
      Oggetto(){cout<<"\nCreato l'oggetto Oggetto!";};
      Oggetto(shared_ptr<Prova> puntatore):mProva(puntatore){cout<<"\nCreato l'oggetto Oggetto!";};
      ~Oggetto(){cout<<"\nDistrutto l'oggetto Oggetto!";};
      void run(){cout<<"\nOggetto is running!";mProva->run();};
      void pause(){cout<<"\nOggetto is paused!";mProva->pause();};
      void termin(){cout<<"\nOggetto is terminated!";mProva->termin();};
    private:
      shared_ptr<Prova> mProva;
  };

int main()
{
  {
    shared_ptr<Prova> prova(new Prova);
    prova->run();
    prova->pause();
    prova->run();
    prova->termin();
    system("pause");
    {
      unique_ptr<Oggetto> oggetto(new Oggetto(prova));
      oggetto->run();
      oggetto->pause();
      oggetto->run();
      oggetto->termin();
    }
    system("pause");
  }
  system("pause");
  return 0;
}

E così vedo che ad ogni fuori scope viene richiamato il distruttore corretto.

[ing82]

Prova n° 3

#include <iostream>
#include <stdlib.h>
#include <memory>

using namespace std;

  class Prova
  {
    public:
      Prova(){cout<<"\nCreato l'oggetto Prova!";};
      ~Prova(){cout<<"\nDistrutto l'oggetto Prova!";};
      void run(){cout<<"\nProva is running!";};
      void pause(){cout<<"\nProva is paused!";};
      void termin(){cout<<"\nProva is terminated!";};
  };

  class Oggetto
  {
    public:
      Oggetto(){cout<<"\nCreato l'oggetto Oggetto!";};
      Oggetto(shared_ptr<Prova> puntatore):mProva(puntatore){cout<<"\nCreato l'oggetto Oggetto!";};
      ~Oggetto(){cout<<"\nDistrutto l'oggetto Oggetto!";};
      void run(){cout<<"\nOggetto is running!";mProva->run();};
      void pause(){cout<<"\nOggetto is paused!";mProva->pause();};
      void termin(){cout<<"\nOggetto is terminated!";mProva->termin();};
    private:
      shared_ptr<Prova> mProva;
  };

int main()
{
  {
    shared_ptr<Prova> prova(new Prova);
    prova->run();
    prova->pause();
    prova->run();
    prova->termin();
    system("pause");
    {
      unique_ptr<Oggetto> oggetto(new Oggetto(prova));
      oggetto->run();
      oggetto->pause();
      oggetto->run();
      oggetto->termin();
      prova.reset();
      oggetto->run();
    }
    system("pause");
  }
  system("pause");
  return 0;
}

In questo modo vedo che dopo il reset, l'area puntata tramite prova, è comunque accessibile, perchè "shared" con oggetto, e alla prima chiusura di parentesi, vengono chiamati entrambi i distruttori.

Restano da studiare i weak_ptr, ma buone vacanze.

Auguri di un buon S. Natale a tutti!

[ing82]

#include <iostream>
#include <stdlib.h>
#include <memory>

using namespace std;

  class Prova
  //Rappresenta un qualsiasi classe di cui deve essere creata un'istanza all'interno del programma
  {
    public:
      Prova(){numero=0;cout<<"\nProva is created!\nNumero = "<<numero<<"\n";};
      ~Prova(){cout<<"\nProva is destroyed!\nNumero = "<<numero<<"\n";};
      void run(){numero++;cout<<"\nProva is running!\nNumero = "<<numero<<"\n";};
      void pause(){cout<<"\nProva is paused!\nNumero = "<<numero<<"\n";};
      void termin(){numero=0;cout<<"\nProva is terminated!\nNumero = "<<numero<<"\n";};
    private:
      int numero;
  };

  class Oggetto
  //Rappresenta una classe di cui deve essere creata un'istanza all'interno del programma, ma in cui
  //uno dei dati membro è un puntatore a un altro oggetto.
  {
    public:
      Oggetto(){cout<<"\nOggetto is created!\n";};
      Oggetto(shared_ptr<Prova> puntatore){cout<<"\nOggetto is created!\n";mProva=puntatore;};
      ~Oggetto(){cout<<"\nOggetto is destroyed!\n";};
      void run(){cout<<"\nOggetto is running!";if(mProva.expired()){cout<<" But not Prova!\n";}else{auto temp=mProva.lock();cout<<"\n";temp->run();}};
      void pause(){cout<<"\nOggetto is paused!";if(mProva.expired()){cout<<" But not Prova!\n";}else{auto temp=mProva.lock();cout<<"\n";temp->pause();}};
      void termin(){cout<<"\nOggetto is terminated!";if(mProva.expired()){cout<<" But not Prova!\n";}else{auto temp=mProva.lock();cout<<"\n";temp->termin();}};
      void check(){if(mProva.expired()){cout<<"\nOggetto e' vuoto\n";}else{cout<<"\nOggetto e' pieno\n";}};
      void setWeakPointer(shared_ptr<Prova> puntatore){mProva=puntatore;};
    private:
      weak_ptr<Prova> mProva;
  };

int main()
{
  cout<<"\nCostruisco Oggetto come unique_ptr:\n";
  unique_ptr<Oggetto> oggetto(new Oggetto);
  cout<<"\nTesto l'oggetto Oggetto\n";
  oggetto->check();
  oggetto->run();
  oggetto->pause();
  oggetto->run();
  oggetto->termin();
  cout<<"\n";
  system("pause");
  {
    cout<<"\nCostruisco Prova:\n";
    shared_ptr<Prova> prova(new Prova);
    cout<<"\nTesto l'oggetto Prova\n";
    prova->run();
    prova->pause();
    prova->run();
    prova->termin();
    system("pause");
    cout<<"\nVerifico puntatore di oggetto:\n";
    oggetto->check();
    if(prova)
    {
      cout<<"\nProva e' pieno\n";
    }
    else
    {
      cout<<"\nProva e' vuoto\n";
    }
    system("pause");
    cout<<"\nProva.get "<<prova.get();
    cout<<"\nPasso Prova a Oggetto\n";
    oggetto->setWeakPointer(prova);
    cout<<"\nVerifico che ora oggetto abbia il riferimento a Prova\n";
    oggetto->check();
    system("pause");
    oggetto->run();
    oggetto->pause();
    oggetto->run();
    oggetto->termin();
    system("pause");
  }
  cout<<"\nLa parentesi e' stata chiusa\n";
  system("pause");
  cout<<"\nVerifico che oggetto abbia ancora il riferimento a Prova\n";
  oggetto->check();
  system("pause");
  oggetto->run();
  oggetto->pause();
  oggetto->run();
  oggetto->termin();
  system("pause");

Pensavo di gestire la cosa in questo modo...consigli? Grazie

[shodan]

Scusa ma inizio ad avere le idee un po' confuse su quello che stai facendo (a meno di esperimenti perfettamente leciti su come usare cosa), per cui quoto il tuo post iniziale.

mi serve creare un oggetto che mi permetta di gestire la sezione e relative caratteristiche di elementi.

Per iniziare diciamo che avrò a che fare con tre tipi di sezioni, che poi aumenteranno: sezione rettangolare, circolare, generica.

Durante l'esecuzione del programma, l'utente potrebbe decidere di variare la sezione, passando ad esempio da sezione rettangolare a sezione circolare.

a cui ho risposto al mio primo intervento.
Introdurre una classe Oggetto, che da quanto ho visto è solo un proxy del dato interno, è inutile: basta usare shared_ptr o unique_ptr.
E usare weak_ptr come membro di classe è una pessima idea dato che non si può sapere quando verrà invalidato.

[ing82]

Scusa ma inizio ad avere le idee un po' confuse su quello che stai facendo (a meno di esperimenti perfettamente leciti su come usare cosa)

In effetti sono andato abbastanza off topic.
Diciamo che il problema iniziale è risolto, ma si è aperta la strada degli smart pointer, mai sentiti prima.
Quindi ho sfruttato la disussione già aperta per chiedere chiarimenti a riguardo.
Quanto postato a riguardo degli smart pointer sono prove esattamente "didattiche", non rappresentano niente di reale e/o collegato con la prima richiesta di aiuto.

Per quanto riguarda l'aver usato un weak_ptr come dato membro di una classe, è legato al seguente problema (ripeto, slegato dal primo):
ho un oggetto, che potrebbe essere Prova, fatto per gestire un determinato aspetto del programma.
Nel programma, poi, creo l'oggetto Oggetto, che deve gestire altre cose, ma necessita di "interagire" con Prova, o meglio, ha bisogno di alcune informazioni/dati membro/metodi presenti in Prova.

Pensavo quindi di memorizzare il puntatore a Prova all'interno di Oggetto, e attraverso gli smart pointer, riuscire a controllare la situazione, ma credo che a questo punto siamo completamente off topic...ma anche fuori strada per quanto riguarda l'impalcatura del mio programma.

[shodan]

Diciamo che il problema iniziale è risolto, ma si è aperta la strada degli smart pointer, mai sentiti prima.
Quindi ho sfruttato la disussione già aperta per chiedere chiarimenti a riguardo.

Ok, comunque è sempre meglio aprire una discussione dedicata piuttosto che continuare su una già esistente, altrimenti chi legge fa solo confusione.

[ing82]

In caso di ereditarietà, molto meglio la seconda soluzione (pattern Strategy http://www.vincehuston.org/dp/strategy.html)

......

Notare che quello che viene fatto nel main può essere a sua volta incapsulato in una classe secondo il pattern State:
http://www.vincehuston.org/dp/state.html

A suo tempo, quando avevo guardato i due link, non ne avevo capito l'importanza: in inglese, senza codici di esempio, li avevo lasciati perdere...

Solo ora ho capito che fanno parte del "Design Patterns", mondo a me sconosciuto!

Per gli ignoranti come me, forse anche questo link può dare una mano a capire l'argomento, c'è qualche riga di codice di esempio.

Grazie infinite ancora Shodan, ma non avevo compreso l'aiuto fornito...ora sotto con lo studio

(e poi tornerò alla ribalta con tutti i miei dubbi)

Grazie