Newsgroup: it.comp.lang.c++
Titolo: Funzioni template

Sto creando un po' di funzioni template che potrei riutilizzare all'esame
di c++ che avrň tra qualche settimana, perň avrei bisogno di un
chiarimento:
template <class tipo> tipo minimo(tipo a, tipo b)
{
 if (a > b)
  return b;
 return a;
}
template <class tipo> tipo minimo(tipo a, tipo b, tipo c)
{
 tipo temp = minimo(a,b);
 if(temp<c)
  return temp;
 return c;
}
questi template (anche in overloading per fare lo sborone) possono essere
comodamente chiamati in main come minimo(num, num, num) e funzionano
correttamente. Ho un problema con un template piů avanzato...
template <class tipo> tipo** allocamatrice(int righe, int colonne)
{
 tipo** temp = new tipo*[righe];
 for(int i = 0; i < righe; i++)
  temp[i] = new tipo[colonne];
 return temp;
}
questo template funziona correttamente solo se chiamo la funzione  con
allocamatrice<tipochevogliousarealmomento>(righe,colonne);
il compilatore non č in grado di determinare in automatico quale tipo sto
utilizzando... se chiamo allocamatrice(righe, colonne) mingw mi dice "no
matching function blablalba".  Perchč? 

 matching function blablalba".  Perchč? 
Se io ti scrivessi:
allocamatrice(3,5)
Tu mi sapresti dire a che tipo di dato template mi riferisco? :). Bene, 
neanche il compilatore ;). Per "aiutarlo", pero', puoi scrivere:
allocamatrice<tipo>(3,5)
-- 
/**
  * Mattia Belletti - Undergraduate student @ 
cs.unibo.it
  * ICQ: 33292311   - email: 
mbel...@cs.unibo.it
  * IRC: BluShine   - site(s): 
http://cs.unibo.it/~mbellett
  * Linux registered user 299762 @ Linux registered machine 213003
  */

 allocamatrice<tipo>(3,5)
ok, se scrivessi allocamatrice(3,5) ti darei ragione... ma io scrivo
double** array = allocamatrice(3,5)...
ma il mistero si infittisce: guarda
queste due funzioni template...
template <class tipo> void distruggimatrice(tipo** &matrice, int righe)
{
 for(int i = 0; i < righe; i++)
  delete [] matrice[i];
 delete [] matrice;
 matrice = NULL;
}
template <class tipo> void inizializzamatrice(tipo** matrice, int righe, int colonne, tipo valore = 0)
{
 for(int i = 0; i < righe; i++)
  for(int k = 0; k < colonne; k++)
   matrice[i][k] = valore;
}
la prima non č ambigua (la chiamo senza specificare il dato) mentre per
la seconda <tipo> č necessario anche nella chiamata. Io non so che logica
usi il compilatore per definire un template come ambiguo, ma queste due
funzioni sono similissime! Perņ una č ambigua e l'altra no...

 no...
E' proprio un mistero, perche' a me (gcc 3.2.2) non risulta necessario
specificare il tipo in nessuna delle due chiamate di funzione. Sospetto
che il tuo compilatore sia carente.
-- 
	Carlo Milanesi
 
http://digilander.libero.it/carlmila

 matching function blablalba".  Perchč?
Perche' la scelta della funzione da chiamare si basa esclusivamente
sui parametri che la funzione prende.
Ciao,
Nicola

 funzioni sono similissime! Però una è ambigua e l'altra no...
inizializzamatrice ha due paramentri "tipo" e "tipo**" e risulta
ambigua se i valori passati non corrispondono.
Esempio:
  int** m_int = 0;
  int** m_float = 0;
  struct Test {};
  Test** m_test = 0;
 
  inizializzamatrice(m_int, 0, 0);           // ok, tipo=int
  inizializzamatrice(m_int, 0, 0, 1);        // ok, tipo=int
  inizializzamatrice(m_float, 0, 0, 1);      // errore, tipo=float/int
  inizializzamatrice(m_float, 0, 0, 1.0f);   // ok, tipo=float
  inizializzamatrice(m_float, 0, 0);         // ok, tipo=float
  inizializzamatrice(m_test, 0, 0);   // errore, 0 non e` un Test
Per evitare l'ultimo errore e usare la funzione anche con tipi che non
possono essere inizializzati con un intero, puoi dichiarare l'ultimo
parametro come "tipo valore = tipo()".
        Mauro