Newsgroup: it.comp.lang.c++
Titolo: Algoritmi e funzioni

Probabilmente l'errore e' banale, ma non riesco a venirne a capo; cosa 
c'e' di sbagliato in questo?:
#include <algorithm>
#include <cctype>
#include <string>
using namespace std;
int foo(const string& s)
{
        return count_if( s.begin(), s.end(), isalpha );
}
g++ 3 mi da questo errore:
no matching function for call to
   `count_if(std::__normal_iterator<char*, std::basic_string<char,
   std::char_traits<char>, std::allocator<char> > >,
   std::__normal_iterator<char*, std::basic_string<char,
   std::char_traits<char>, std::allocator<char> > >, <unknown type>)'
In pratica, non riesce a ricavare il tipo di "isalpha".
La cosa piu' strana e' che se mi faccio un wrapper:
bool my_isalpha(char c)
{
        return isalpha(c);
}
e poi chiamo
        count_if( s.begin(), s.end(), my_isalpha );
funziona tutto correttamente!
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

   std::char_traits<char>, std::allocator<char> > >, <unknown type>)'
Secondo me dipende dal fatto che 'isalpha' è una macro, non una 
funzione.
-- 
Ciao, Marvin

 c'e' di sbagliato in questo?:
Mumble. Mi posti per cortesia le linee che definiscono isalpha
prendendole dal tuo header ("cctype" o "ctype.h" o che altro viene
incluso da questi)?
--
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

 wrote in message
news:9vdqfu.3...@marvin.gpp.despammed.com...

E' quello che sospetto. Ma nello standard C alcune cose sono definite
come funzioni dallo standard ma POSSONO essere implementato come macro,
viceversa alcune cose sono definite come macro ma POSSONO essere
implementate come funzioni. Quindi isalpha è definita come funzione,
salvo che PUO' essere implementata come macro. In C++ quelle che per il
C sono funzioni DEVONO essere implementate come funzioni e quelle che
per il C sono macro DEVONO essere implementate come macro.
Quindi se nell'header la isalpha è una macro, allora la libreria del
compilatore non è conforme.


per il C sono macro DEVONO essere implementate come macro.
Perché non avrebbe più senso implementarle come funzioni inline?
-- 
                    Marco Barisione (ICQ 84277092)
Se sei interessato alla creazione di un newsgroup generico in cui si
possa parlare di quei linguaggi di programmazione senza un gruppo
apposito vota per it.comp.lang su it.news.votazioni.

funzione.
Se cosi' é la lib.standard del compilatore non é conforme allo
standard. L'header <cctype> non dovrebbe contenere delle macro, ma in
molti compilatori é cosi'. Nel BCC55 per esempio isalpha me la trovo
definita cosi'..
#define isalpha(c)   (__STD _chartype[ (c)+1 ] & (_IS_ALPHA))
secondo StrouStrup dovrebbe essere invece cosi'
int isalpha(int);
Il Ghenio
---------
These are my parting words to you:
those who give up are doomed!

 compilatore non è conforme.
Vero.  Pero' e' sempre meglio nnon fidarsi...  Per questo motivo in
una mia risposta di un paio di giorni fa ho scritto #undef isspace
prima di usare isspace come arcomento.  O sara' che sono troppo
fuorviato dalle mie radici C :-)
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

 compilatore non è conforme.
bene, allora magari lo faccio presente al team di g++.


 
[snip]
isalpha e' una macro, ma, siccome hai incluso <cctype> dovresti usare 
std::isalpha, che e' invece una funzione. 
specificando std::isalpha g++ compila perfettamente.
Questo e' uno dei tanti motivi per cui e' sempre sconsigliato fare un 
"using namespace std;" 
Saluti
Fabio Lopiano
-- 
Posted from 
flopiano.mm.eutelsat.org
 [194.214.173.28] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Perché non avrebbe piů senso implementarle come funzioni inline?
Lo standard C++ dice che se lo standard C le definisce come macro allora
devono essere macro. In altre parole tu puoi fare affidamento sul fatto
che siano macro. Il che, tra l'altro, significa che non stanno in un
namespace.


 "using namespace std;"
Quello che dici è un workaraound. Ma resta vero che secondo lo standard
il codice deve compilare perchè isalpha non può essere una macro (in
C++).


 "using namespace std;"
da notare che io, solitamente, mi metto a digitare diligentemente tutte 
le migliaia di std::, ma questa volta avevo fretta :-(


 stanno in un namespace.
quali idenfiticatori devono essere macro? A naso mi viene in mente EOF, 
ma altri?


 ma altri?
Non ho sottomano lo standard, ma di sicuro stdin/stdout/stderr.  Me lo
ricordo perche' mi sono assai piaciute queste righe dello <stdio.h> di
gcc:
#ifdef __STDC__
/* C89/C99 say they're macros.  Make them happy.  */
#define stdin stdin
#define stdout stdout
#define stderr stderr
#endif


 ma altri?
Queste sono quelle citate nello standard C++ come macro derivanti dalle
librerie C:
NULL, offsetof, EXIT_FAILURE, EXIT_SUCCESS, va_arg, va_end, va_start,
setjmp, CLOCKS_PER_SEC, SIGABRT, SIGILL, SIGSEGV, SIG_DFL, SIG_IGN,
SIGFPE, SIGINT, SIGTERM, SIG_ERR, assert, EDOM, ERANGE, errno, WEOF,
WCHAR_MAX, WCHAR_MIN, MB_CUR_MAX, LC_ALL, LC_COLLATE, LC_CTYPE,
LC_MONETARY, LC_NUMERIC, LC_TIME, HUGE_VAL, RAND_MAX, BUFSIZ, EOF,
FILENAME_MAX, FOPEN_MAX, L_tmpnam, SEEK_CUR, SEEK_END, SEEK_SET,
TMP_MAX, _IOFBF, _IOLBF, _IONBF, stderr, stdin, stdout
Di fatto però lo standard C++ non elenca in toto i contenuti delle
librerie C. Per esempio non elenca il contenuto di limits.h e float.h
(ovviamente in C++ diventano climits e cfloat, e ovviamente elenca i
contenuti di limits che definisce numeric_limits che può essere usato al
posto di quelle macro!).
Dato che non ho lo standard C non posso verificare oltre. Quindi
l'elenco suddetto non è per nulla esaustivo.


 dalle librerie C:
[cut]
ok, grazie.
