namespace in C++ when using c function [duplicate]

Question

Possible Duplicate:
unresolved overloaded function type c++

Consider the code snippet below:

#include <algorithm>
#include <cctype>
#include <string>
using namespace std;
void test(){
    std::string str = "Hello World!";
    std::transform(str.begin(), str.end(), str.begin(), tolower);
}

There is an error about tolower when compiling with G++: unresolved overloaded function.

If using namespace std; is removed, the code works fine.

Then, my questions are:

• What is the relationship between namespace std with C functions?
• What is the difference between #include<ctype.h> and #include<cctype>? Although both of them don't work in the example above.
• Why std::tolower also doesn't work? What's the difference between std::tolower and tolower?

Answer 1

There is no relationship between namespace std and C functions. But your code isn't C, it's C++, so you also have to consider C++ functions. Like std::tolower, for example, in <locale>. Your problem is due to a concurrence of things:

• One of the headers you include includes <locale>. C++ headers are allowed to include other C++ headers, and which header includes which other header may vary from one implementation to the other, so the code you've written might compile with one compiler, and not with another.

• You're trying to pass the function as a pointer to function argument, to a function template where the argument is a template type parameter. Simply put, in order to do overload resolution on tolower here, the compiler must match it to the type of the argument, and in order to know the type of the argument, the compiler must do template type deduction based on the exact type of the function, which it can only know once it has done overload resolution.

If you want the function in <ctype.h> (which you don't, since it would result in undefined behavior), you can get it either by including <ctype.h> (which guarantees that it is present in the global namespace) and using ::tolower, or by explicitly specifying the overload you want, e.g. static_cast<int (*)(int)>( tolower ) (In this particular case, static_cast doesn't mean type conversion, but explicit overload resolution.)

In practice, of course, you don't do this sort of thing. If you're doing any text processing at all, you'll define all of the necessary functions as functional object types, which avoid undefined behavior by either converting the input to unsigned char:

struct ToLower
{
    char operator()( char ch ) const
    {
        return ::tolower( static_cast<unsigned char>( ch ) );
    }
};

or by using the functions in <locale> which do work with char:

class ToLower
{
    std::locale myLocale;   //  necessary to guarantee the lifetime of the facet.
    std::ctype const* myCType;
public:
    ToLower( std::locale const& loc = std::locale() )
        ; myLocal( loc )
        , myCType( &std::use_facet<std::ctype>( loc ) )
    {
    }

    bool operator()( char ch ) const
    {
        return myCType->tolower( ch );
    }
};

Finally, WRT your second question: the difference depends on the version of C++ you're using and the compiler. Globally, however: <ctype.h> will introduce the functions into the global namespace; <cctype> will introduce them into the namespace std::, and maybe (or maybe not) into the global namespace. (And your third question has already been answered above: std::tolower refers to a set of overloaded functions defined in <locale> and <cctype>; ::tolower refers to a single function defined in <ctype.h>, and just tolower is the equivalent of ::tolower, unless you've done using namespace std, in which case, it will refer to the overload set of all of the functions mentionned above.