Newsgroup: it.comp.lang.c++
Titolo: nuovo operatore: valueof ??

Ciao, come accennato in un altro thread mi sono imbattuto
(in un programma a cui sto lavorando) in un problema
che a mio avviso richiederebbe l'introduzione di un
nuovo operatore in C++ (leggi: non sono riuscito a trovare
una soluzione in C++ standard).
Ecco il codice 'incriminato':
template<short ControllerId> struct foo
{
    static const char Id = ControllerId + '0';
    static const char* stringa;
};
template<short ControllerId> const char* foo<ControllerId>::stringa = "! GA102";
                                                                        ^
                                                                        Id
Quello che vorrei č che
foo<1>::stringa = !1GA102";
foo<2>::stringa = !2GA102";
e cosě via.
Esiste un modo per farlo?
Un metodo l'ho trovato(da cui il precedente post), ma ha troppe limitazioni.
Se non fosse possibile, sarebbe utile un nuovo operatore:
valueof.
In pratica questo operatore prende come argomento una variabile
integrale costante e ne restituisce il suo valore numerico
(nulla di eccezionale, credo implementabile senza fatica).
A questo punto si potrebbe fare:
#define str(s) #s
template<short ControllerId> const char*
foo<ControllerId>::stringa = "!" valueof(str(Id)) "GA102";
Che ne pensate?
Ciao e grazie  Manlio Perillo

 "! GA102";
non ho tempo di provare, ma una std::bind con una funzione che 
sostituisca il secondo carattere di una stringa condivisa e ne ritorni 
una copia?

 Esiste un modo per farlo?
#include <iostream>
template<short ControllerId>
struct foo
{
  static char const stringa[];
};
template<short ControllerId>
char const foo<ControllerId>::stringa[] =
{ '!','0' + ControllerId,'G','A','1','0','2', '\0'};
int main()
{
 std::cout << foo<1>::stringa << std::endl;
 std::cout << foo<2>::stringa << std::endl;
 std::cin.get();
return 0;
}
ciao
Massimo

 foo<ControllerId>::stringa = "!" valueof(str(Id)) "GA102";
Non sono certo di aver capito. Forse intendevi scrivere
    str( valueof( Id ) )
?
Ma perchč funzioni una cosa del genere, valueof() dovrebbere essere
risolto dal precompilatore. 
Max

 #define str(s) #s
Non č fattibile. L'operatore # non fa parte del parser ma del
preprocessore. Nel preprocessore non esiste una symbol table per cui non
č possibile prendere "il valore di una variabile" neppure se č costante.
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556


Mi sono accorto, usado sizeof, che la macro replacement avviene
prima dell'azione di tale operatore, quindi...
P.S:
Riguardo a 'interazione' fra macro e sizeof, ho notato una
sorta di 'asimmetria'.
Infatti l'operatore #if agisce **dopo** l'azione di sizeof:
#include <iostream>
int main()
{
#if (sizeof(short) == 2)
  std::cout << "OK\n";
#else
  std::cout << "NO\n";
#endif
}
Questo, con il BCC 5.5 mi stampa
OK.
Tuttavia ciň mi lascia dei dubbi:
1) Il DJGPP non lo compila, mi da errore sulla riga del #if
2) Nel Kernigham e Ritcher c'č scritto che #if accetta una constant-integral
   expression, a parte sizeof (e qualcos'altro);
   Nel l'ultimo draft dello Standard non mi pare ci sia questa limitazione.


    Nel l'ultimo draft dello Standard non mi pare ci sia questa limitazione.
Nel draft (16.1) c'è questa nota:
 __________________
 131) Because the controlling constant expression is evaluated during
 translation phase 4, all identifiers either are or are not macro
 names - there simply are no keywords, enumeration constants, and so on.
Max