HandBooks Professional Java-C-Scrip-SQL part 49 docx

lexical_cast
Header:
"boost/lexical_cast.hpp"
Lexical conversions are performed in virtually all applications. We convert strings
to numeric values and vice versa. Many user-defined types can be converted to
strings or created from strings. It is all too common to write the code for these
conversions each time you need it, which suggests that it is very much suited for a
reusable implementation. That's lexical_cast's purpose. Think of
lexical_cast as using a std::stringstream as an interpreter between
the string and other representation of a value. That means that it will work for any
source with an appropriate output operator<< and any target with an
appropriate operator<<. That's true for all of the built-in types and many user-
defined types (UDTs).
Usage
lexical_cast makes a conversion between types look like any other type-
converting cast. Of course, there must be a conversion function somewhere to
make it work, but conceptually, it can be thought of as a cast. Rather than calling
one of a number of conversion routines, or even coding the conversion locally,
lexical_cast does that job for any types that meet its requirements. The
source type must be OutputStreamable and the destination type must be
InputStreamable. In addition, both types need to be CopyConstructible, and the
target also DefaultConstructible and Assignable. OutputStreamable means that
there's an operator<< defined for the type, and InputStreamable mandates an
operator>>. This is true for many types, including the built-in types and the
string classes from the Standard Library. To use lexical_cast, include
"boost/lexical_cast.hpp".
Putting
lexical_cast to Work
I won't bore you by producing conversion code manually to show how much code
lexical_cast saves you, because I'm sure you've written these conversions

yourself, and quite probably done so more than once. Instead, the example just
uses lexical_cast for a number of common (lexical) type conversions.
#include <iostream>
#include <string>
#include "boost/lexical_cast.hpp"
int main() {
// string to int
std::string s="42";
int i=boost::lexical_cast<int>(s);
// float to string
float f=3.14151;
s=boost::lexical_cast<std::string>(f);
// literal to double
double d=boost::lexical_cast<double>("2.52");
// Failed conversion
s="Not an int";
try {
i=boost::lexical_cast<int>(s);
}
catch(boost::bad_lexical_cast& e) {
// The lexical_cast above will fail,
// and we'll end up here
}
}
This example shows only a few of many scenarios where lexical conversion are
performed, and I think you'll agree that it usually takes a few more lines of code
than this to get the job done. Whenever there's uncertainty that the conversion is
valid, the lexical_cast should be protected by a TRy/catch block, as you
see in the preceding example. You'll note that there is no way of controlling the
formatting of these conversions; if you need that level of control, use

std::stringstream!
If you were to manually convert between types, you'd need to handle the
conversions and possible failures in different ways for different types. This is not
only inconvenient; it also stands in the way of any attempt to perform the
conversions in generic code. We'll see how lexical_cast can help with that in just a
moment.
The conversions in the example are fairly simple to do by hand, and although
lexical_cast makes it look that much simpler, there's a chance that you
missed the beauty and elegance of this cast. But it's there. Consider again the
simple requirements that need to be fulfilled for any class to work with
lexical_cast. Think about the fact that a conversion can be done in one line
for all of those classes meeting the requirements. Combine this with the fact that
the implementation relies on the Standard Library's stringstream to do the
grunt work,
[15]
and you can see that lexical_cast is more than a convenient way of
performing lexical conversions; it's also a display of the art of programming in
C++.
[15]
Actually, there are optimizations that avoid the overhead of using
std::stringstream for some conversions. Indeed, you can customize its
behavior for your own types, if necessary.
Generic Programming with lexical_cast
As a simple example of using lexical_cast for solving generic programming
tasks, consider what it would take to create a to_string function. The function
would accept any type of argument (adhering to certain requirements, of course)
and return a string representing the value. Users of the Standard Library would
no doubt be able to do this in a few lines of code, with the help of
std::stringstream. In this case, we'll just use lexical_cast for most of
the implementation, with just a forwarding function and some error handling.

#include <iostream>
#include <string>
#include "boost/lexical_cast.hpp"
template <typename T> std::string to_string(const T& arg) {
try {
return boost::lexical_cast<std::string>(arg);
}
catch(boost::bad_lexical_cast& e) {
return "";
}
}
int main() {
std::string s=to_string(412);
s=to_string(2.357);
}
This handy function is not only easy to implement, it also adds value, elegantly
enabled by virtue of lexical_cast.
Enabling Classes for Use with
lexical_cast
Because lexical_cast only requires that operator<< and operator>>
be
suitably defined for the types it operates on, it's straightforward to add support for
lexical conversions to user-
defined types. A simple UDT that can be both the target
and source when used with lexical_cast might look like this:
class lexical_castable {
public:
lexical_castable() {};
lexical_castable(const std::string s) : s_(s) {};
friend std::ostream operator<<

(std::ostream& o, const lexical_castable& le);
friend std::istream operator>>
(std::istream& i, lexical_castable& le);
private:
virtual void print_(std::ostream& o) const {
o << s_ <<"\n";
}
virtual void read_(std::istream& i) const {
i >> s_;
}
std::string s_;
};
std::ostream operator<<(std::ostream& o,
const lexical_castable& le) {
le.print_(o);
return o;
}
std::istream operator>>(std::istream& i, lexical_castable& le) {
le.read_(i);
return i;
}
The lexical_castable class can now be used like so:
int main(int argc, char* argv[]) {
lexical_castable le;
std::cin >> le;
try {
int i = boost::lexical_cast<int>(le);
}
catch(boost::bad_lexical_cast&) {
std::cout << "You were supposed to enter a number!\n";

}
}
Of course, the input and output operators allow the class to be used with other
streams as well. If you're using IOStreams from the Standard Library, or another
library that uses operator<< and operator>>, you probably have many
classes that are ready for lexical_cast in place. These do not have to be
modified at all. Just lexically cast them!
Summary

lexical_cast is a reusable and reasonably efficient tool for lexical
conversions, those between string and other types. With its combination of
functionality and elegance, it is a great example of what a creative programmer can
do.
[16]
Rather than implementing small conversion functions whenever the need
arises, or worse, implementing that logic directly in other functions, a generic tool
like lexical_cast should be used. It helps make the code clearer and allows
programmers to focus on solving the problem at hand.
[16]
I've always feltpresumptuously, I knowthat we, The Programmers, work
simultaneously with mathematics, physics, engineering, architecture, sculpturing,
and a few other arts and disciplines. This is daunting, but also endlessly rewarding.

When to use lexical_cast:
 For conversions from string types to numeric types
 For conversions from numeric types to string types
 For all lexical conversions that are supported by your user-defined types