Newsgroup: it.comp.lang.c++
Titolo: Distruttori parametrizzati

Potrebbero servire a qualcosa? O sarebbero solo superflui? In Object Pascal
se non sbaglio si possono avere (o forse si possono avere solo distruttori
multipli ma non parametrizzati... in ogni caso in OP sono dotati di nome, in
C++ per l'overload bisognerebbe parametrizzarli).
Grazie
--
Noixe
Posted from X-Privat Free NNTP server - 
www.x-privat.org

 Potrebbero servire a qualcosa? O sarebbero solo superflui? 
Superflui. Se ne è parlato recentemente in comp.lang.c++.moderated, mi 
pare...
-- 
---
*************** | Have you ever retired a human by mystake?
*** Azathot *** |
*************** | To contact me, ask me gently. Thanks.

 pare...
Potresti riassumermi in poche righe il perchè? Io pensavo che ad es potesse
essere utile definire 2 distuttori diversi per deallocare 2 array allocati
dinamicamente in maniera indipendente.
Ciao


 allocati dinamicamente in maniera indipendente.
Questo già mi sembra un pessimo esempio: primo, chi usa uno o l'altro 
distruttore deve conoscere che la classe che sta distruggendo ha due array 
allocati dinamicamente (e questo viola il principio di "information 
hiding"); secondo, il distruttore deve togliere tutte le risorse allocate, 
e farlo nella maniera più pulita e sicura possibile... averne due 
significherebbe introdurre una ambiguità... quali dei due il compilatore 
deve chiamare? E se il programmatore dimentica di chiamare l'altro, che 
succede?
A me pare, francamente, un po' troppo pericoloso.


 succede?
Ma se si volesse rendere indipendete l'allocazione di 2 array? In ogni caso,
un Dtor dovrebbe essere sempre di default, e la classe chiamerebbe quello.
Magari il Dtor che dealloca le risorse che sono allocate più spesso... non
vedo ambiguità. Magari si viola l'informazion hiding, ma io avevo pensato ad
un eventuale garbage collection tipo quello di Java. Ma forse si può
implementare solo per i linguaggi interpretati (o compilati a livello di
bytecode)? In questo modo, quello che il programmatore non libera
esplicitamente è liberato dal GC. Invece, potrebbe essere utile avere il
Dtor parametrizzato, non a scopo di averne tanti, ma piuttosto per l'utilità
che può avere passare uno o più parametri, in questo modo si può scegliere
cosa deallocare e ciò che deve essere sempre deallocato, potrebbe essere
messo come parametro di default.


 Ma se si volesse rendere indipendete l'allocazione di 2 array?
[...]
forse ho capito cosa vorrebbe fare ... e quello che vorrebbe fare e' molto piu' 
facile veloce e semplice ottenerlo con ereditarieta' e sigleton statici o 
sottoclassi statiche che vengono create alla chiamata di alcune funzioni ...
ciao

 potrebbe essere messo come parametro di default.
Se vuoi distinguere tra ciò che viene allocato una-tantum e ciò che viene 
allocato esclusivamente nel corso dell'istanziazione di nuovi oggetti, ti 
consiglio di rivolgerti ai singleton.
Ciaoooo!!!


 consiglio di rivolgerti ai singleton.
Ok. In pratica io volevo sapere solo perchè non esistono i Dtor
parametrizzati. Fino ad ora non ho fatto altro che esporre le mie idee sulla
loro eventuale utilità. Ma se non ne hanno, pazienza :)


 sulla loro eventuale utilità. 
Hai fatto benissimo. ;-)


 Hai fatto benissimo. ;-)
Grazie! Sarebbe bello trovare qualcosa di utile che non è stato ancora
implementato.


 inutili.
Non è vero, perché le classi (intese come astrazioni ovvero come 
interfaccie) sono uno strumento potente, che permette di esprimere logiche 
algoritmiche complesse senza imporre aprioristicamente il campo di 
applicazione delle stesse. 
Sebbene io possa ottenere la stessa cosa con il C (o altri linguaggi 
tipizzati e/o dotati di puntatori) utilizzando in maniera corretta 
costrutti come "switch()" e "if", oppure con concetti come "puntatori a 
funzione", non puoi non esser d'accordo con me che il meccanismo messo a 
disposizione dal linguaggio C++ sia molto più potente. Per esempio, pensa 
solo alla risoluzione delle ambiguità laddove vi sia una struttura 
complessa di derivazione: il C++ ti garantisce alcune invarianze che un 
linguaggio imperativo non può perché sei "sceso di livello" nella 
rappresentazione.
Spero di essermi capito. ;-)


 rappresentazione.
Si, certamente, ma se il programmatore è abbastanza abile se la può cavare
manualmente... il C ad es. non pone ostacoli... basta conoscere bene cosa si
fa. Ovviamente non c'è paragone da un punto di vista della velocità di
stesura del codice e della possibilità di commettere errori.


 stesura del codice e della possibilità di commettere errori.
In ogni caso, continua a sfuggirmi il vantaggio di utilizzare un distruttore 
parametrico... :-?
Per esempio, una delle cose di cui sento la mancanza è qualcosa del genere:
        std::string s = "Derivata";
        Base * b = new s;
Cioè un qualche modo per effettuare il new utilizzando il nome della classe 
definita a run-time. Questo permetterebbe, ad esempio, di serializzare con 
molta più comodità oggetti anche complessi...
Ciaooo!!!


 
O.o
Scusa ma non ho capito e sono curioso.
Te prendi una striga s e la inizializzi a "Derivata".
Adesso Base con std::string cosa potrà mai avere a che fare ?
Almeno dovresti specificare in che modo Base e std::string potrebbero 
essere legate...

 Scusa ma non ho capito e sono curioso.
Scusa tu, sono stato un po' troppo sintetico. ;-)
class Base {
        // Interfaccia per qualcosa di molto utile
};
class Derivata1 : public Base {
        // Una implementazione di Base
};
class Derivata2 : public Base {
        // Altra implementazione di Base
};
Supponiamo che io voglia inizializzare un puntatore a Base con un oggetto 
allocato sull'heap, ma il cui tipo non conosco al momento della 
compilazione ma solo a run time. Cioè, non posso scrivere:
        Base * b = new Derivata1;
ad esempio, perché non so se devo allocare un oggetto del tipo "Derivata1" o 
"Derivata22. Dovrei scrivere qualcosa del tipo:
        if ( tipo == "Derivata1" )
                b = new Derivata1;
        else if ( tipo == "Derivata2" )
                b = new Derivata2;
Ma come puoi intuire, questo comporta che io devo prevedere un modo per cui, 
partendo da una stringa, si arrivi all'oggetto. Se ci fosse qualcosa del 
tipo:
        b = new tipo;
dove "tipo" è una stringa che contiene il nome della classe da allocare, 
avrei un codice più sintetico e dove posso aggiungere "al volo" nuove 
classi... ;-)
Mi scuso in anticipo per errori di compilazione... ma è solo per farvi 
capire il punto... ;-)
Ciao!


 molta più comodità oggetti anche complessi...
Eh eh, tra le mie (strane) idee avevo pensato al tipo di dato "Keyword". Ti
faccio un'esempio:
Keyword T = "int";
T x = 1;
T = "double"; // e la precedente istruzione diventa double x = 1;
Tutto questo dovrebbe essere fattibile anche a run time.
Nel tuo caso:
Keyword T = F();  // F() considerala come una funzione per ottenere il
qualche modo il nome della classe
Base* b = new T;
Inoltre avevo pensato anche al tipo di dato "Symbol" per poter assegnare gli
operatori alle variabili. Es.:
Symbol s = '+';
x = 3 s 5; // x = 8
s = '|';
x = 3 s 5; // x = 7
Adoro i linguaggi flessibili :)
