Newsgroup: it.comp.lang.c++
Titolo: switch {} case ... perplessità

Ho una piccola procedura dentro un metodo di una classe
che ha come scopo quello di sostituire ad alcuni valori numerici
la corrispettiva descrizione
esempio
0 -> CANE
10 -> GATTO
500 -> UOMO ...
dato che questi numeri sono una 10na ...
e non stanno in una sequenza numerica ben determinata...
a me non piace lo
switch ( .....)
{
	case x:	copia;
		break;
	case y:	copia;
		break;
	default:.....
		break;
};
ora immaginate a copia l'assegnazione della stringa ...
questa soluzione non mi piace ...
però non voglio sovraccare il tutto adoperando una classe
template simile alla CArray di MFC ...
avete qualche idea al riguardo ?
grazie
cod

 ha scritto nel messaggio
news:mfe8rtcushek86huf...@4ax.com...

Potresti usare una mappa (std::map dichiarata nell'header <map>)
std::map<int, std::string> mappa_nomi;
mappa_nomi[0] = "CANE";
mappa_nomi[10] = "GATTO";
mappa_nomi[500] = "UOMO";
Ciao  Manlio Perillo

 avete qualche idea al riguardo ?
se i numeri sono solo una decina forse la cosa migliore e' proprio lo 
switch. Un'altra soluzione plausibile potrebbe essere quella di usare una 
tabella di hash o un albero binario di ricerca, ma per dieci elementi non 
credo che ne valga la pena. Oppure puoi usare anche std::map<>
void foo() {
  std::map<int,std::string> m;
  m[0] = "CANE";
  m[10] = "GATTO";
  m[500] = "UOMO";
}
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

 avete qualche idea al riguardo ?
Se ti 'piacciono' i templates puoi provare una soluzione di questo tipo,
nota che gli elementi devono essere inseriti nel vettore in modo che il
numero sia in ordine (visto che li inserivi in uno switch dovrebbe essere
possibile) in questo modo puoi effettuare una ricerca binaria, il BCB5 lo
compila senza errori, spero che sia cosi` anche con gli altri.
#include <iostream>
#include <ctime>
struct item { char*   descr_;  int     i_; }
  const items_s[] = { { "ZERO",   0}, {"UNO"    ,101},{ "DUE",202},
                      { "TRE",  303}, {"QUATTRO",504},{ "SEI",606},
                      { "SETTE",607}, {"OTTO"   ,608},{"NOVE",609},
                      { "DIECI",909 }};
const char non_trovato[] = "Non trovato";
template <int S>
inline const char* descrS( int desired_i, const item* i0 )
  { enum { half = S/2 };
    return i0[half].i_  < desired_i ? descrS<half>( desired_i,i0+half+1) :
           i0[half].i_  > desired_i ? descrS<half>( desired_i,i0) :
           i0[half].i_ == desired_i ? i0[half].descr_: non_trovato; }
template <>
inline const char* descrS<0>( int, const item* )
  { return non_trovato; }
template <>
inline const char* descrS<1>( int desired_i, const item* i0 )
  { return i0->i_ == desired_i ? i0->descr_ : non_trovato ; }
template <>
inline const char* descrS<2>( int desired_i, const item* i0 )
  { return i0->i_ == desired_i ? i0->descr_:
       (++i0)->i_ == desired_i ? i0->descr_: non_trovato; }
const char* descrizione( int desired_i, const item* i0 )
  { switch( desired_i )
    { default : return non_trovato;
      case   0: return i0[0].descr_;
      case 101: return i0[1].descr_;
      case 202: return i0[2].descr_;
      case 303: return i0[3].descr_;
      case 504: return i0[4].descr_;
      case 606: return i0[5].descr_;
      case 607: return i0[6].descr_;
      case 608: return i0[7].descr_;
      case 609: return i0[8].descr_;
      case 909: return i0[9].descr_; } }
int main()
  { enum { size = sizeof items_s/sizeof items_s[0] };
    std::clock_t t2, t1, t0 = std::clock();
    for ( int j=0; j<20000000; ++j )
      descrS<size>(  j, items_s );
    t1 = std::clock();
    for ( int j=0; j<20000000; ++j )
      descrizione(  j, items_s );
    t2 = std::clock();
    std::cout <<"template "<< ( t1 - t0 ) / CLOCKS_PER_SEC << '\n'
              << "switch " << ( t2 - t1 ) / CLOCKS_PER_SEC << '\n' ;
    std::cin.get(); }
ciao
Massimo


ciao
Massimo