Bruce Eckel - Thinking In C++. Volume 2 - Practical Programming

You can use this information to make a new type of stringclass that ignores case. First, we’ll define a new case-insensitive char_traits< >template that inherits from the existing template. Next, we’ll override only the members we need to change to make character-by-character comparison case insensitive. (In addition to the three lexical character comparison members mentioned earlier, we’ll also have to supply a new implementation for the char_traitsfunctions find( )and compare( ).) Finally, we’ll typedefa new class based on basic_string, but using the case-insensitive ichar_traitstemplate for its second argument .

//: C03:ichar_traits.h

// Creating your own character traits

#ifndef ICHAR_TRAITS_H

#define ICHAR_TRAITS_H

#include

#include

#include

#include

#include

using std::toupper;

using std::tolower;

using std::ostream;

using std::string;

using std::char_traits;

using std::allocator;

using std::basic_string;

struct ichar_traits : char_traits {

// We'll only change character-by-

// character comparison functions

static bool eq(char c1st, char c2nd) {

return toupper(c1st) == toupper(c2nd);

}

static bool ne(char c1st, char c2nd) {

return !eq(c1st, c2nd);

}

static bool lt(char c1st, char c2nd) {

return toupper(c1st) < toupper(c2nd);

}

static int compare(const char* str1,

const char* str2, size_t n) {

for(size_t i = 0; i < n; i++) {

if(str1 == 0)

return -1;

else if(str2 == 0)

return 1;

else if(tolower(*str1) < tolower(*str2))

return -1;

else if(tolower(*str1) > tolower(*str2))

return 1;

assert(tolower(*str1) == tolower(*str2));

str1++; str2++; // Compare the other chars

}

return 0;

}

static const char* find(const char* s1,

size_t n, char c) {

while(n-- > 0)

if(toupper(*s1) == toupper(c))

return s1;

else

++s1;

return 0;

}

};

typedef basic_string istring;

inline ostream& operator<<(ostream& os, const istring& s) {

return os << string(s.c_str(), s.length());

}

#endif // ICHAR_TRAITS_H ///:~

We provide a typedefnamed istringso that our class will act like an ordinary stringin every way, except that it will make all comparisons without respect to case. For convenience, we’ve also provided an overloaded operator<<( )so that you can print istrings. Here’s an example: .

//: C03:ICompare.cpp

#include

#include

#include "ichar_traits.h"

using namespace std;

int main() {

// The same letters except for case:

istring first = "tHis";

istring second = "ThIS";

cout << first << endl;

cout << second << endl;

assert(first.compare(second) == 0);

assert(first.find('h') == 1);

assert(first.find('I') == 2);

assert(first.find('x') == string::npos);

} ///:~

This is just a toy example, of course. To make istringfully equivalent to string, we’d have to create the other functions necessary to support the new istringtype .

The header provides a wide string class via the following typedef:

typedef basic_string wstring;

Wide string support also reveals itself in wide streams ( wostreamin place of ostream, also defined in ) and in the header , a wide-character version of . This along with the wchar_tspecialization of char_traitsin the standard library allows us to do a wide-character version of ichar_traits:

//: C03:iwchar_traits.h

//{-bor}

//{-g++}

// Creating your own wide-character traits

#ifndef IWCHAR_TRAITS_H

#define IWCHAR_TRAITS_H

#include

#include

#include

#include

#include

using std::towupper;

using std::towlower;

using std::wostream;

using std::wstring;

using std::char_traits;

using std::allocator;

using std::basic_string;

struct iwchar_traits : char_traits {

// We'll only change character-by-

// character comparison functions

static bool eq(wchar_t c1st, wchar_t c2nd) {

return towupper(c1st) == towupper(c2nd);

}

static bool ne(wchar_t c1st, wchar_t c2nd) {

return towupper(c1st) != towupper(c2nd);

}

static bool lt(wchar_t c1st, wchar_t c2nd) {

return towupper(c1st) < towupper(c2nd);

}

static int compare(const wchar_t* str1,

const wchar_t* str2, size_t n) {

for(size_t i = 0; i < n; i++) {

if(str1 == 0)

return -1;

else if(str2 == 0)

return 1;

else if(towlower(*str1) < towlower(*str2))

return -1;

else if(towlower(*str1) > towlower(*str2))

return 1;

assert(towlower(*str1) == towlower(*str2));

str1++; str2++; // Compare the other wchar_ts

}

return 0;

}

static const wchar_t* find(const wchar_t* s1,

size_t n, wchar_t c) {

while(n-- > 0)

if(towupper(*s1) == towupper(c))

return s1;

else

++s1;

return 0;

}

};

typedef basic_string iwstring;

inline wostream& operator<<(wostream& os,

const iwstring& s) {

return os << wstring(s.c_str(), s.length());

}

#endif // IWCHAR_TRAITS_H ///:~

As you can see, this is mostly an exercise in placing a ‘w’ in the appropriate place in the source code. The test program looks like this:

//: C03:IWCompare.cpp

//{-g++}

#include

#include

#include "iwchar_traits.h"

using namespace std;

int main() {

// The same letters except for case:

iwstring wfirst = L"tHis";

iwstring wsecond = L"ThIS";

wcout << wfirst << endl;

wcout << wsecond << endl;

assert(wfirst.compare(wsecond) == 0);

assert(wfirst.find('h') == 1);

assert(wfirst.find('I') == 2);

assert(wfirst.find('x') == wstring::npos);

} ///:~

Unfortunately, some compilers still do not provide robust support for wide characters .

If you’ve looked at the sample code in this book closely, you’ve noticed that certain tokens in the comments surround the code. These are used by a Python program that Bruce wrote to extract the code into files and set up makefiles for building the code. For example, a double-slash followed by a colon at the beginning of a line denotes the first line of a source file. The rest of the line contains information describing the file’s name and location and whether it should be only compiled rather than fully built into an executable file. For example, the first line in the previous program above contains the string C03:IWCompare.cpp, indicating that the file IWCompare.cppshould be extracted into the directory C03 .

The last line of a source file contains a triple-slash followed by a colon and a tilde. If the first line has an exclamation point immediately after the colon, the first and last lines of the source code are not to be output to the file (this is for data-only files). (If you’re wondering why we’re avoiding showing you these tokens, it’s because we don’t want to break the code extractor when applied to the text of the book!) .

Bruce’s Python program does a lot more than just extract code. If the token " {O}"follows the file name, its makefile entry will only be set up to compile the file and not to link it into an executable. (The Test Framework in Chapter 2 is built this way.) To link such a file with another source example, the target executable’s source file will contain an " {L}"directive, as in .