std::transform doesnt always work

Well this code:

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>

using namespace std;

int comp(const string& s1, const string& s2)
{
string i1 = s1;
transform(i1.begin(),i1.end(),i1.begin(),_toupper);
string i2 = s2;
transform(i2.begin(),i2.end(),i2.begin(),_toupper);
return i1.compare(i2);

}

int main ( void )
{
vector<string> theList;
theList.push_back("alice");
theList.push_back("Hello");
theList.push_back("below");
theList.push_back("hello");
sort(theList.begin(),theList.end(),comp);
vector<string>::iterator it;
for(it = theList.begin(); it != theList.end(); it++)
cout << *it << endl;

system("PAUSE");

return 0;
}

Got me the following output:

hello
below
Hello
alice

Pass a const reference instead of a non-const.

I could not reproduce the character truncation problem.

I would recommend the following sort predicate:

// Sort lexicographically...
bool comp (string& s1,string& s2)
{
const char* pszString1 = s1.c_str ();
const char* pszString2 = s2.c_str ();

return (stricmp (pszString1, pszString2) < 0);

};

1) why use "_toupper" instead of "toupper"

2) the predicate should return a bool , not an int ... so it should be

bool comp(const string& s1, const string& s2)
{
string i1 = s1;
transform(i1.begin(),i1.end(),i1.begin(),toupper);
string i2 = s2;
transform(i2.begin(),i2.end(),i2.begin(),toupper);
return i1.compare(i2) < 0;
}

3) stricmp() is not standard (I don't think anyway) ... here is a standard
way to do it ...

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <cctype>

using namespace std;

namespace
{

struct case_insensitive_less : public std::binary_function< char,char,bool >
{
bool operator () (char x, char y)
{
return toupper( static_cast< unsigned char >(x)) <
toupper( static_cast< unsigned char >(y));
}
};


bool NoCaseLess(const std::string &a, const std::string &b)
{
return std::lexicographical_compare( a.begin(),a.end(),
b.begin(),b.end(), case_insensitive_less() );
}
}

int main()
{
vector<string> theList;
theList.push_back("alice");
theList.push_back("Hello");
theList.push_back("below");
theList.push_back("hello");
sort(theList.begin(),theList.end(),NoCaseLess);
vector<string>::iterator it;
for(it = theList.begin(); it != theList.end(); it++)
cout << *it << endl;

return 0;
}

return i1.compare(i2) < 0;
I understand that this is a binary predicate.
Kurt

I understand that this is a binary predicate.A binary predicate is defined as one that take two input parameters and returns bool (not int).

I really like the algorithm in post #6 -- seems to work better with both printable and non-printable characters.I liked it very much as well... And would rather address it as Philip's post, and not "post #6"... :rolleyes:

;)

But at least my compiler knows how to convert the expression ... into a bool. ( so the example does work )Interesting.

Mine did not (MSVC 6.0)... :D

Finally I replaced _toupper with toupper. This version again works with MSVC 6.0.True - toupper is standard compliant.

So, with this tiny modification your predicate is absolutely OK (hopefully on your compiler as well... ? Let me know... )
// Sort lexicographically...
bool comp(const string& s1,const string& s2)
{
string i1 = s1;
transform(i1.begin(),i1.end(),i1.begin(),toupper);

string i2 = s2;
transform(i2.begin(),i2.end(),i2.begin(),toupper);

return i1.compare(i2) < 0;
}

True, stricmp it is not in the standard, but it is widely implemented (certainly on MSVC compiler as used by the Stober).

Agreed, the standard form is a good (albeit, longer) alternative... ;)

Which is why one put the definition into a function that can be reused through-out the project in a very simple way:

if( NoCaseLess("test", "TEST") )
{
// ...
}

If I would do anything different it would be adding the possibility to pass a locale to the case insensitive predicate:

(Phillip's code modified, my changes in bold)

#include <cstddef>
#include <cstdlib>

#include <algorithm>
#include <functional>
#include <iostream>
#include <locale>
#include <string>
#include <vector>

namespace
{

struct case_insensitive_less
: public std::binary_function< char,char,bool >
{

case_insensitive_less()
: m_locale(std::locale::empty())
{
}

case_insensitive_less(std::locale const & l)
: m_locale(l)
{
}

bool operator () (char x, char y)
{

return
std::toupper(x, m_locale) <
std::toupper(y, m_locale);

}

private:
std::locale const m_locale;

};

bool NoCaseLess(
const std::string &a,
const std::string &b)
{
return std::lexicographical_compare(
a.begin(),
a.end(),
b.begin(),
b.end(),
case_insensitive_less() );
}

bool NoCaseLessGermanLocale(
const std::string &a,
const std::string &b)
{
return std::lexicographical_compare(
a.begin(),
a.end(),
b.begin(),
b.end(),
case_insensitive_less(std::locale("German_germany")) );
}

}

int main()
{
std::vector<std::string> theList;

theList.push_back("alice");
theList.push_back("Hello");
theList.push_back("below");
theList.push_back("hello");

std::sort(theList.begin(),theList.end(),NoCaseLessGermanLocale);

std::vector<std::string>::iterator it;

for(it = theList.begin(); it != theList.end(); it++)
{
std::cout << *it << std::endl;
}

return EXIT_SUCCESS;
}

Now it sorts using german locale (doesn't produce any difference in this case but it could have).

Hope this helps

Making comp return bool doesn't make any difference using MSVC6.0.
It works using toupper and fails using _toupper.
Using g++ 3.3.3 (cygwin special) the version using toupper fails to compile. Must have something to do with the #includes. Right now I don't have the time for further investigation. I'll continue in the evening.
Kurt

You can try the German example using some letters with umlat characters. If anyone German posts here, do those get placed alphabetically at the end or after their non-accented version?