Newsgroup: it.comp.lang.c++
Titolo: Costruttori e template

Ecco una domanda semplice semplice.
Ho un template
    template<class T> { /* ... */ };
in cui e' presente un costruttore T (). Nel caso in cui T sia un float,
un int, un bool, un char, come avviene l'inizializzazione? Il mio
compilatore, nel caso dei float, usa il valore 0.0, ma non so se questa
e' una caratteristica che posso trovare altrove.
Ho cercato la risposta nella documentazione dello standard c++ draft,
nel capitolo relativo hai template, ma non l'ho trovata (in compenso ho
scoperto altre cose). Ho guardato male oppure la risposta e' altrove?
Grazie.

 e' una caratteristica che posso trovare altrove.
Viene inizializzato con il valore che il compilatore da a tutte le
variabili di quel tipo al momento della creazione, quindi molti
compilatori assegnano 0 a int e char e 0.0 a float e double.
Questo avviene per problemi di sicurezzza nei sistemi multiprogrammati
ma non e' uno standard (almeno a quanto ne so io) quindi meglio non
fidarsi.
-- 
     (ZZZ)       Filippo Salotti, Bagni di Lucca, Lucca, Italy.
    //   \\  _                 E-mail : 
fil...@humnet.unipi.it
   /Y\    ZD<_o===============================================o
 .oZZZZZo.     | Studente Ingegneria Informatica Automatica  |
<OXXXXXXXO>    | Dip. Sistemi Elettrici Universita' di Pisa. |

fidarsi.
Fortunatamente, oggi (e da Luglio scorso, ma quello che e`
stato approvato come Standard e` esattamente l'ultimo draft,
lo stesso che era stato approvato in Novembre 1997) non e`
piu` cosi`: *E`* uno standard, e quindi ci si puo` fidare di esso
(e dei compilatori, presumibilmente in versioni recenti e bene
aggiornate, che lo implementano, almeno in buona parte).
Lo standard puo` oggi essere acquistato, in rete, per 10
dollari mi pare, al sito dell'American National Standards
Institute; non e` opera di consultazione agevole, e averla
messa in formato PDF (Acrobat Reader) non migliora
certo le cose, sigh.  Comunque, la sezione 8.5 recita,
in parte e tradotta...:
[8.5.5] 
"Zero-inizializzare" un oggetto di tipo T significa...:
    -- se T e` un tipo scalare (3.9), la memoria e` posta
        al valore di 0 (zero) convertito a T
    [snip]
"Default-inizializzare" un oggetto di tipo T significa...:
    [snip] -- altrimenti, la memoria dell'oggetto e`
                  zero-inizializzata
[8.5.7]
Un oggetto il cui inizializzatore e` una coppia vuota
di parentesi, cioe` (), sara` default-inizializzato
(Questo e` ben diverso da [8.5.9] "Se nessun
inizializzatore e` specificato per un oggetto"; in
questo caso, si cadrebbe nella specifica "ha
valore indeterminato").
Riassumendo, dunque, oggi, in C++ Standard,
qualsiasi nome di tipo (anche i built-in, come
int, float, ecc) puo` essere usato, seguito da una
coppia vuota di parentesi, per richiedere in modo
esplicito l'inizializzazione di default per quel tipo,
che per gli scalari (int, float, ecc) coincide con
la zero-inizializzazione.
Questo, naturalmente, e` stato aggiunto proprio
(nel draft del 1996, se ben ricordo, quindi la
stragrande maggioranza dei compilatori C++ si
dovrebbe gia` essere adeguata!) per comodita`
di chi scrive template, che grazie a questa
naturale estensione del concetto di "costruttore
di default" puo` permettersi in molti piu` casi di
evitare di dovere specializzare un dato template
per i casi di tipi built-in.  Notare, e questo e`
molto importante, che nulla, invece, cambia se
*nessun inizializzatore e` specializzato*: il
costruttore di default in questo caso e` chiamato
solo per oggetti-classe e oggetti statici e globali,
mentre oggetti built-in auto e membri di classi
sono NON-inizializzati (cosa assai scomoda,
sigh, ma necessaria per garantire il massimo
assoluto delle prestazioni in certi casi -- come
sappiamo, il linguaggio C++ non impone _mai_,
di per se`, dei costi di run-time superiori a quelli
del linguaggio C, e questa linea-guida di progetto
non viene mai violata, neppure dove gli overhead
sarebbero minimi e la comodita` tanta).
Alex

 fidarsi.
Forse sarebbe meglio definire il template cosi'?
template <class T = float, T ZERO = 0.0>
Mi pare sia possibile farlo, ma il compilatore non lo accetta. Che sia
perche' il supporto dei template non e' completo?

 —end example]
Ciao.