Newsgroup: it.comp.lang.c++
Titolo: Template con restrizioni

Ispirato da una caratteristica riscontrata nell'architettura 
.net relativo alle classi generiche (la clausola Of), vorrei 
chiedere se conoscente qualche sistema non troppo complesso per 
emulare questa caratteristica nei normali template del C++ standard.
In altre parole si tratta di creare templates non universali ma 
a generalità ridotta, restringendo il campo degli oggetti 
"templanti" al sottoinsieme di oggetti che supportano 
nativamente o hanno implementato alcune caratteristiche (su 
questo punto sono stato vago, ci tornerò fra poco).
Per il quali caratteristiche, si potrebbero ad esempio 
richiedere il fatto di supportare che so, assegnazione e 
confronto, o altro, o la implementazione di operatori.
Mi sono trovato nella situazione, probabilmente dovuta a un 
design non buono, di due classi che volevano essere entrambe 
piuttosto generiche ma si trovavano anche a collaborare 
abbastanza strettamente. Essendo grosse fonderle mi spaventava, 
e la mutua friendship di fatto non libera dal conoscere l'una i 
dettagli dell'altra, anzi, è quasi di fatto come avere fuso le 
logiche di funzionamento se non i dati interni. Era questo che 
volevo evitare : pur dovendo collaborare, essenzialmente 
dovevano rimanere inconsapevoli l'una dell'altra, eccetto una 
sorta di limitata interfaccia di servizi che l'una chiede e 
l'altra deve garantire.
Volendo mantenere separati i codici e i dettagli interni, ho 
creato una classe di interfaccia arbitraria, che altro non fa 
che dichiarare i tipi ed istanze di puntatori a funzioni che una 
classe dovrà popolare a mano mettendoci i propri metodi interni, 
e l'altra classe dovrà usare (e il costruttore stesso richiede).
Rimane il fatto che, malgrado la codifica abbastanza ordinata e 
la suddivisione chiara dei rispettivi compiti e la separazione 
mantenuta, la tenuta del sistema non è suffragata da controlli 
del compilatore, e la coerenza tra domanda dell'una e servizi 
offerti dell'altra rimane arbitraria ed esclusivamente affidata 
alla buona volontà del programmatore (sono un po' diffidente di 
questo ordine "debole" che può essere aggirato facilmente, e in 
ogni modo cerco di appoggiarmi su controlli statici).
Se invece si potesse emulare in qualche modo la richiesta forte 
di supportare certi operatori e altri metodi (su .net sono dette 
interfacce, tipo IComparable, IFormattable, etc), il compilatore 
stesso potrebbe collaborare con il raccordo tra le due classi.
Grazie di ogni dritta
ciao
Soviet

 implementazione di operatori.
Mi sembra ci fosse qualcosa del genere nelle boost, ma non ricordo quale 
specifica libreria fosse. Prova a guardare li'.
  bye
	av.

 potrebbe collaborare con il raccordo tra le due classi.
L'unica cosa che penso possa aiutare è lo SFINAE (Substitution failure 
is not an error). Per es. ho provato a implementare una funzione che 
dice se un tipo T è costruibile a partire dall'argomento (7, in questo 
caso).
=====================
typedef char yes;
typedef char (&no)[2];
template <class T>
static yes isConstructibleFrom(T);
template <class T>
static no isConstructibleFrom(...);
struct A
{
};
struct B
{
	B(int);
};
static bool const ris1 = sizeof(isConstructibleFromT<int>(7)) == 
sizeof(yes);
static bool const ris2 = sizeof(isConstructibleFromT<A>(7)) == sizeof(yes);
static bool const ris3 = sizeof(isConstructibleFromT<B>(7)) == sizeof(yes);
=====================
Nell'esempio, ris2 = 0, mentre ris3 = 1. Bene, funziona.
Kiuhnm

 static bool const ris3 = sizeof(isConstructibleFromT<B>(7)) == sizeof(yes);
Non è "isConstructibleFromT", ma "isConstructibleFrom".
Inoltre non è neanche inglese corretto ;)
Kiuhnm

 Kiuhnm
Spero che tu abbia tempo di commentare ulteriormente il codice 
(come dire, scrivi con lo stile di un matematico puro, e come 
avrai capito fatico a seguire quello che forse dovrebbe essere 
palese ma rimane un po' implicito).
ciao
Soviet_Mario

 specifica libreria fosse. Prova a guardare li'.
Trovata: 
http://boost.org/libs/concept_check/concept_check.htm
.
  bye
	av.