mirror of
https://github.com/boostorg/conversion.git
synced 2026-08-06 13:34:14 +02:00
Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Beman Dawes
|
a018eeb617 |
@@ -9,29 +9,22 @@
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
|
||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||
|
||||
<title>Header boost/polymorphic_cast.hpp Documentation</title>
|
||||
<style>
|
||||
.copyright
|
||||
{
|
||||
color: #666666;
|
||||
font-size: small;
|
||||
}
|
||||
</style>
|
||||
<title>Header boost/cast.hpp Documentation</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align=
|
||||
"middle" width="277" height="86">Header <a href=
|
||||
"../../boost/polymorphic_cast.hpp">boost/polymorphic_cast.hpp</a></h1>
|
||||
"../../boost/cast.hpp">boost/cast.hpp</a></h1>
|
||||
|
||||
<h2><a name="Cast Functions">Cast Functions</a></h2>
|
||||
|
||||
<p>The header <a href="../../boost/polymorphic_cast.hpp">boost/polymorphic_cast.hpp</a> provides <code>
|
||||
<p>The header <a href="../../boost/cast.hpp">boost/cast.hpp</a> provides <code>
|
||||
<a href="#Polymorphic_cast">polymorphic_cast</a> and</code> <a href=
|
||||
"#Polymorphic_cast"><code>polymorphic_downcast</code></a> function templates designed to
|
||||
complement the C++ built-in casts.</p>
|
||||
|
||||
<p>The program <a href="test/cast_test.cpp">cast_test.cpp</a> can be used to
|
||||
<p>The program <a href="cast_test.cpp">cast_test.cpp</a> can be used to
|
||||
verify these function templates work as expected.</p>
|
||||
|
||||
<h3><a name="Polymorphic_cast">Polymorphic casts</a></h3>
|
||||
@@ -110,7 +103,7 @@ inline Derived polymorphic_downcast(Base* x);
|
||||
<h3>polymorphic_downcast example</h3>
|
||||
|
||||
<blockquote>
|
||||
<pre>#include <boost/polymorphic_cast.hpp>
|
||||
<pre>#include <boost/cast.hpp>
|
||||
...
|
||||
class Fruit { public: virtual ~Fruit(){}; ... };
|
||||
class Banana : public Fruit { ... };
|
||||
@@ -138,9 +131,10 @@ void f( Fruit * fruit ) {
|
||||
-->June 23, 2005<!--webbot bot="Timestamp" endspan i-checksum="30348"
|
||||
--></p>
|
||||
|
||||
<p class="copyright">© Copyright boost.org 1999.
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)
|
||||
</p>
|
||||
<p>© Copyright boost.org 1999. Permission to copy, use, modify, sell
|
||||
and distribute this document is granted provided this copyright notice
|
||||
appears in all copies. This document is provided "as is" without express
|
||||
or implied warranty, and with no claim as to its suitability for any
|
||||
purpose.</p>
|
||||
</body>
|
||||
</html>
|
||||
</html>
|
||||
@@ -14,7 +14,13 @@
|
||||
// 3 Aug 99 Initial Version
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/polymorphic_cast.hpp>
|
||||
#include <climits>
|
||||
#include <cfloat> // for DBL_MAX (Peter Schmid)
|
||||
#include <boost/cast.hpp>
|
||||
|
||||
# if SCHAR_MAX == LONG_MAX
|
||||
# error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
|
||||
# endif
|
||||
|
||||
using namespace boost;
|
||||
using std::cout;
|
||||
@@ -0,0 +1,16 @@
|
||||
# Copyright Antony Polukhin 2011. Use, modification, and distribution are
|
||||
# subject to the Boost Software License, Version 1.0. (See accompanying
|
||||
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
using quickbook ;
|
||||
import boostbook : boostbook ;
|
||||
|
||||
xml lexical_cast : lexical_cast.qbk ;
|
||||
boostbook standalone
|
||||
:
|
||||
lexical_cast
|
||||
:
|
||||
<xsl:param>boost.root=../../../..
|
||||
<format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
|
||||
;
|
||||
|
||||
@@ -0,0 +1,607 @@
|
||||
[library Boost.Lexical_Cast
|
||||
[quickbook 1.5]
|
||||
[version 1.0]
|
||||
[copyright 2000-2005 Kevlin Henney]
|
||||
[copyright 2006-2010 Alexander Nasonov]
|
||||
[copyright 2011 Antony Polukhin]
|
||||
[category String and text processing]
|
||||
[category Miscellaneous]
|
||||
[license
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
[@http://www.boost.org/LICENSE_1_0.txt])
|
||||
]
|
||||
]
|
||||
|
||||
[def __numericcast__ [@boost:libs/numeric/conversion/doc/html/boost_numericconversion/improved_numeric_cast__.html `boost::numeric_cast`]]
|
||||
[def __proposallong__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1973.html Lexical Conversion Library Proposal for TR2, N1973 by Kevlin Henney and Beman Dawes]]
|
||||
[def __proposalshort__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1973.html Lexical Conversion Library Proposal for TR2, N1973]]
|
||||
|
||||
[section Motivation]
|
||||
Sometimes a value must be converted to a literal text form, such as an [c++] `int` represented as a `std::string`, or vice-versa, when a `std::string` is interpreted as an `int`. Such examples are common when converting between data types internal to a program and representation external to a program, such as windows and configuration files.
|
||||
|
||||
The standard C and C++ libraries offer a number of facilities for performing such conversions. However, they vary with their ease of use, extensibility, and safety.
|
||||
|
||||
For instance, there are a number of limitations with the family of standard C functions typified by `atoi`:
|
||||
|
||||
* Conversion is supported in one direction only: from text to internal data type. Converting the other way using the C library requires either the inconvenience and compromised safety of the `sprintf` function, or the loss of portability associated with non-standard functions such as `itoa`.
|
||||
* The range of types supported is only a subset of the built-in numeric types, namely `int`, `long`, and `double`.
|
||||
* The range of types cannot be extended in a uniform manner. For instance, conversion from string representation to complex or rational.
|
||||
|
||||
The standard C functions typified by `strtol` have the same basic limitations, but offer finer control over the conversion process. However, for the common case such control is often either not required or not used. The `scanf` family of functions offer even greater control, but also lack safety and ease of use.
|
||||
|
||||
The standard C++ library offers `stringstream` for the kind of in-core formatting being discussed. It offers a great deal of control over the formatting and conversion of I/O to and from arbitrary types through text. However, for simple conversions direct use of `stringstream` can be either clumsy (with the introduction of extra local variables and the loss of infix-expression convenience) or obscure (where `stringstream` objects are created as temporary objects in an expression). Facets provide a comprehensive concept and facility for controlling textual representation, but their perceived complexity and high entry level requires an extreme degree of involvement for simple conversions, and excludes all but a few programmers.
|
||||
|
||||
The `lexical_cast` function template offers a convenient and consistent form for supporting common conversions to and from arbitrary types when they are represented as text. The simplification it offers is in expression-level convenience for such conversions. For more involved conversions, such as where precision or formatting need tighter control than is offered by the default behavior of `lexical_cast`, the conventional `std::stringstream` approach is recommended. Where the conversions are numeric to numeric, __numericcast__ may offer more reasonable behavior than `lexical_cast`.
|
||||
|
||||
For a good discussion of the options and issues involved in string-based formatting, including comparison of `stringstream`, `lexical_cast`, and others, see Herb Sutter's article, [@http://www.gotw.ca/publications/mill19.htm The String Formatters of Manor Farm]. Also, take a look at the [link boost_lexical_cast.performance Performance] section.
|
||||
[endsect]
|
||||
|
||||
[section Examples]
|
||||
The following example treats command line arguments as a sequence of numeric data:
|
||||
``
|
||||
int main(int argc, char * argv[])
|
||||
{
|
||||
using boost::lexical_cast;
|
||||
using boost::bad_lexical_cast;
|
||||
|
||||
std::vector<short> args;
|
||||
|
||||
while(*++argv)
|
||||
{
|
||||
try
|
||||
{
|
||||
args.push_back(lexical_cast<short>(*argv));
|
||||
}
|
||||
catch(bad_lexical_cast &)
|
||||
{
|
||||
args.push_back(0);
|
||||
}
|
||||
}
|
||||
...
|
||||
}
|
||||
``
|
||||
The following example uses numeric data in a string expression:
|
||||
``
|
||||
void log_message(const std::string &);
|
||||
|
||||
void log_errno(int yoko)
|
||||
{
|
||||
log_message("Error " + boost::lexical_cast<std::string>(yoko) + ": " + strerror(yoko));
|
||||
}
|
||||
``
|
||||
[endsect]
|
||||
|
||||
[section Synopsis]
|
||||
Library features defined in [@boost:boost/lexical_cast.hpp boost/lexical_cast.hpp]:
|
||||
``
|
||||
namespace boost
|
||||
{
|
||||
class bad_lexical_cast;
|
||||
template<typename Target, typename Source>
|
||||
Target lexical_cast(const Source& arg);
|
||||
}
|
||||
``
|
||||
|
||||
[section lexical_cast]
|
||||
``
|
||||
template<typename Target, typename Source>
|
||||
Target lexical_cast(const Source& arg);
|
||||
``
|
||||
Returns the result of streaming arg into a standard library string-based stream and then out as a Target object. Where Target is either `std::string` or `std::wstring`, stream extraction takes the whole content of the string, including spaces, rather than relying on the default `operator>>` behavior. If the conversion is unsuccessful, a `bad_lexical_cast` exception is thrown.
|
||||
|
||||
The requirements on the argument and result types are:
|
||||
|
||||
* Source is OutputStreamable, meaning that an `operator<<` is defined that takes a `std::ostream` or `std::wostream` object on the left hand side and an instance of the argument type on the right.
|
||||
* Target is InputStreamable, meaning that an `operator>>` is defined that takes a `std::istream` or `std::wistream` object on the left hand side and an instance of the result type on the right.
|
||||
* Target is CopyConstructible [20.1.3].
|
||||
* Target is DefaultConstructible, meaning that it is possible to default-initialize an object of that type [8.5, 20.1.4].
|
||||
|
||||
The character type of the underlying stream is assumed to be char unless either the Source or the Target requires wide-character streaming, in which case the underlying stream uses `wchar_t`. Source types that require wide-character streaming are `wchar_t`, `wchar_t *`, and `std::wstring`. Target types that require wide-character streaming are `wchar_t` and `std::wstring`.
|
||||
|
||||
Where a higher degree of control is required over conversions, `std::stringstream` and `std::wstringstream` offer a more appropriate path. Where non-stream-based conversions are required, `lexical_cast` is the wrong tool for the job and is not special-cased for such scenarios.
|
||||
[endsect]
|
||||
|
||||
[section bad_lexical_cast]
|
||||
``
|
||||
class bad_lexical_cast : public std::bad_cast
|
||||
{
|
||||
public:
|
||||
... // same member function interface as std::exception
|
||||
};
|
||||
``
|
||||
Exception used to indicate runtime lexical_cast failure.
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Frequently Asked Questions]
|
||||
|
||||
* [*Question:] Why does `lexical_cast<int8_t>("127")` throw `bad_lexical_cast`?
|
||||
* [*Answer:] The type `int8_t` is a `typedef` to `char` or `signed char`. Lexical conversion to these types is simply reading a byte from source but since the source has more than one byte, the exception is thrown.
|
||||
Please use other integer types such as `int` or `short int`. If bounds checking is important, you can also
|
||||
call __numericcast__:
|
||||
`numeric_cast<int8_t>(lexical_cast<int>("127"));`
|
||||
|
||||
[pre
|
||||
]
|
||||
|
||||
* [*Question:] Why does `lexical_cast<unsigned char>("127")` throw `bad_lexical_cast`?
|
||||
* [*Answer:] Lexical conversion to any char type is simply reading a byte from source. But since the source has more than one byte, the exception is thrown.
|
||||
Please use other integer types such as `int` or `short int`. If bounds checking is important, you can also
|
||||
call __numericcast__:
|
||||
`numeric_cast<unsigned char>(lexical_cast<int>("127"));`
|
||||
|
||||
[pre
|
||||
]
|
||||
|
||||
* [*Question:] What does `lexical_cast<std::string>` of an `int8_t` or `uint8_t` not do what I expect?
|
||||
* [*Answer:] As above, note that int8_t and uint8_t are actually chars and are formatted as such. To avoid
|
||||
this, cast to an integer type first: `lexical_cast<std::string>(static_cast<int>(n));`
|
||||
|
||||
[pre
|
||||
]
|
||||
|
||||
* [*Question:] The implementation always resets the `ios_base::skipws` flag of an underlying stream object.
|
||||
It breaks my `operator>>` that works only in presence of this flag. Can you remove code that resets the flag?
|
||||
* [*Answer:] May be in a future version. There is no requirement in
|
||||
__proposallong__ to reset the flag but
|
||||
remember that __proposalshort__ is not yet accepted by the committee. By the way, it's a great opportunity to
|
||||
make your `operator>>` conform to the standard.
|
||||
Read a good C++ book, study `std::sentry` and [@boost:libs/io/doc/ios_state.html `ios_state_saver`].
|
||||
|
||||
[pre
|
||||
]
|
||||
|
||||
* [*Question:] Why `std::cout << boost::lexical_cast<unsigned int>("-1");` does not throw, but outputs 4294967295?
|
||||
* [*Answer:] `boost::lexical_cast` has the behavior of `std::stringstream`, which uses `num_get` functions of
|
||||
`std::locale` to convert numbers. If we look at the Programming languages — C++, we'll see, that `num_get` uses
|
||||
the rules of `scanf` for conversions. And in the C99 standard for unsigned input value minus sign is optional, so
|
||||
if a negative number is read, no errors will arise and the result will be the two's complement.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Changes]
|
||||
* [*boost 1.48.0 :]
|
||||
|
||||
* Added code to work with Inf and NaN on any platform.
|
||||
* Better performance and less memory usage for conversions to float type (and to double type, if `sizeof(double) < sizeof(long double)`).
|
||||
|
||||
* [*boost 1.47.0 :]
|
||||
|
||||
* Optimizations for "C" and other locales without number grouping.
|
||||
* Better performance and less memory usage for unsigned char and signed char conversions.
|
||||
* Better performance and less memory usage for conversions to arithmetic types.
|
||||
* Better performance and less memory usage for conversions from arithmetic type to arithmetic type.
|
||||
* Directly construct Target from Source on some conversions (like conversions from string to string, from char array to string, from char to char and others).
|
||||
|
||||
* [*boost 1.34.0 :]
|
||||
|
||||
* Better performance for many combinations of Source and Target types. For more details refer to Alexander Nasonovs article [@http://accu.org/index.php/journals/1375 Fine Tuning for lexical_cast, Overload #74, August 2006] [@http://www.accu.org/var/uploads/journals/overload74.pdf (PDF)].
|
||||
|
||||
* [*boost 1.33.0 :]
|
||||
|
||||
* Call-by-const reference for the parameters. This requires partial specialization of class templates, so it doesn't work for MSVC 6, and it uses the original pass by value there.
|
||||
* The MSVC 6 support is deprecated, and will be removed in a future Boost version.
|
||||
|
||||
* [*Earlier :]
|
||||
|
||||
* The previous version of lexical_cast used the default stream precision for reading and writing floating-point numbers. For numerics that have a corresponding specialization of `std::numeric_limits`, the current version now chooses a precision to match.
|
||||
* The previous version of lexical_cast did not support conversion to or from any wide-character-based types. For compilers with full language and library support for wide characters, `lexical_cast` now supports conversions from `wchar_t`, `wchar_t *`, and `std::wstring` and to `wchar_t` and `std::wstring`.
|
||||
* The previous version of `lexical_cast` assumed that the conventional stream extractor operators were sufficient for reading values. However, string I/O is asymmetric, with the result that spaces play the role of I/O separators rather than string content. The current version fixes this error for `std::string` and, where supported, `std::wstring`: `lexical_cast<std::string>("Hello, World")` succeeds instead of failing with a `bad_lexical_cast` exception.
|
||||
* The previous version of `lexical_cast` allowed unsafe and meaningless conversions to pointers. The current version now throws a `bad_lexical_cast` for conversions to pointers: `lexical_cast<char *>("Goodbye, World")` now throws an exception instead of causing undefined behavior.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Performance]
|
||||
|
||||
In most cases `boost::lexical_cast` is faster than `scanf`, `printf`, `std::stringstream`. For more detailed info you can look at the tables below.
|
||||
|
||||
[section Tests description]
|
||||
All the tests measure execution speed in milliseconds for 10000 iterations of the following code blocks:
|
||||
[table:legend Tests source code
|
||||
[[Test name] [Code]]
|
||||
[[lexical_cast]
|
||||
[``
|
||||
_out = boost::lexical_cast<OUTTYPE>(_in);
|
||||
``]
|
||||
]
|
||||
[[std::stringstream with construction]
|
||||
[``
|
||||
std::stringstream ss;
|
||||
ss << _in;
|
||||
if (ss.fail()) throw std::logic_error(descr);
|
||||
ss >> _out;
|
||||
if (ss.fail()) throw std::logic_error(descr);
|
||||
``]
|
||||
]
|
||||
[[std::stringstream without construction]
|
||||
[``
|
||||
ss << _in; // ss is an instance of std::stringstream
|
||||
if (ss.fail()) throw std::logic_error(descr);
|
||||
ss >> _out;
|
||||
if (ss.fail()) throw std::logic_error(descr);
|
||||
/* reseting std::stringstream to use it again */
|
||||
ss.str(std::string());
|
||||
ss.clear();
|
||||
``]
|
||||
]
|
||||
[[scanf/printf]
|
||||
[``
|
||||
typename OUTTYPE::value_type buffer[500];
|
||||
sprintf( (char*)buffer, conv, _in);
|
||||
_out = buffer;
|
||||
``]
|
||||
]
|
||||
]
|
||||
Fastest results are highlitened with "!!! *x* !!!".
|
||||
Do not use this results to compare compilers, because tests were taken on different hardware.
|
||||
|
||||
[endsect]
|
||||
|
||||
[/ BEGIN of section, generated by performance measuring program ]
|
||||
|
||||
[section clang-linux-2.8][table:id Performance Table (clang-linux-2.8)
|
||||
[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
|
||||
[[ string->char ][ !!! *<1* !!! ][ 148 ][ 14 ][ 12 ]]
|
||||
[[ string->signed char ][ !!! *<1* !!! ][ 97 ][ 8 ][ 7 ]]
|
||||
[[ string->unsigned char ][ !!! *<1* !!! ][ 90 ][ 8 ][ 13 ]]
|
||||
[[ string->int ][ !!! *4* !!! ][ 102 ][ 19 ][ 15 ]]
|
||||
[[ string->short ][ !!! *4* !!! ][ 105 ][ 20 ][ 15 ]]
|
||||
[[ string->long int ][ !!! *4* !!! ][ 105 ][ 19 ][ 15 ]]
|
||||
[[ string->long long ][ !!! *4* !!! ][ 115 ][ 19 ][ 14 ]]
|
||||
[[ string->unsigned int ][ !!! *4* !!! ][ 102 ][ 18 ][ 14 ]]
|
||||
[[ string->unsigned short ][ !!! *4* !!! ][ 101 ][ 19 ][ 15 ]]
|
||||
[[ string->unsigned long int ][ !!! *3* !!! ][ 107 ][ 20 ][ 14 ]]
|
||||
[[ string->unsigned long long ][ !!! *3* !!! ][ 103 ][ 20 ][ 14 ]]
|
||||
[[ string->bool ][ !!! *<1* !!! ][ 97 ][ 16 ][ 8 ]]
|
||||
[[ string->float ][ !!! *21* !!! ][ 170 ][ 61 ][ 32 ]]
|
||||
[[ string->double ][ !!! *18* !!! ][ 206 ][ 93 ][ 58 ]]
|
||||
[[ string->long double ][ 135 ][ 221 ][ 94 ][ !!! *57* !!! ]]
|
||||
[[ char->string ][ !!! *7* !!! ][ 100 ][ 17 ][ 13 ]]
|
||||
[[ unsigned char->string ][ !!! *7* !!! ][ 99 ][ 18 ][ 16 ]]
|
||||
[[ signed char->string ][ !!! *7* !!! ][ 101 ][ 17 ][ 12 ]]
|
||||
[[ int->string ][ !!! *13* !!! ][ 110 ][ 23 ][ 15 ]]
|
||||
[[ short->string ][ !!! *13* !!! ][ 112 ][ 24 ][ 18 ]]
|
||||
[[ long int->string ][ !!! *13* !!! ][ 119 ][ 23 ][ 17 ]]
|
||||
[[ long long->string ][ !!! *13* !!! ][ 110 ][ 23 ][ 18 ]]
|
||||
[[ unsigned int->string ][ !!! *14* !!! ][ 113 ][ 24 ][ 17 ]]
|
||||
[[ unsigned short->string ][ !!! *13* !!! ][ 108 ][ 24 ][ 17 ]]
|
||||
[[ unsigned long int->string ][ !!! *13* !!! ][ 109 ][ 24 ][ 16 ]]
|
||||
[[ unsigned long long->string ][ !!! *13* !!! ][ 110 ][ 23 ][ 17 ]]
|
||||
[[ bool->string ][ !!! *7* !!! ][ 105 ][ 24 ][ 12 ]]
|
||||
[[ float->string ][ 70 ][ 192 ][ 94 ][ !!! *49* !!! ]]
|
||||
[[ double->string ][ 106 ][ 217 ][ 122 ][ !!! *76* !!! ]]
|
||||
[[ long double->string ][ 120 ][ 219 ][ 123 ][ !!! *80* !!! ]]
|
||||
[[ char*->char ][ !!! *2* !!! ][ 90 ][ 9 ][ 8 ]]
|
||||
[[ char*->signed char ][ !!! *2* !!! ][ 87 ][ 10 ][ 7 ]]
|
||||
[[ char*->unsigned char ][ !!! *3* !!! ][ 90 ][ 10 ][ 13 ]]
|
||||
[[ char*->int ][ !!! *6* !!! ][ 107 ][ 21 ][ 15 ]]
|
||||
[[ char*->short ][ !!! *6* !!! ][ 110 ][ 19 ][ 14 ]]
|
||||
[[ char*->long int ][ !!! *6* !!! ][ 103 ][ 19 ][ 14 ]]
|
||||
[[ char*->long long ][ !!! *7* !!! ][ 104 ][ 20 ][ 15 ]]
|
||||
[[ char*->unsigned int ][ !!! *6* !!! ][ 101 ][ 20 ][ 15 ]]
|
||||
[[ char*->unsigned short ][ !!! *7* !!! ][ 100 ][ 20 ][ 14 ]]
|
||||
[[ char*->unsigned long int ][ !!! *6* !!! ][ 105 ][ 22 ][ 15 ]]
|
||||
[[ char*->unsigned long long ][ !!! *7* !!! ][ 106 ][ 21 ][ 14 ]]
|
||||
[[ char*->bool ][ !!! *2* !!! ][ 99 ][ 18 ][ 7 ]]
|
||||
[[ char*->float ][ !!! *22* !!! ][ 159 ][ 67 ][ 33 ]]
|
||||
[[ char*->double ][ !!! *20* !!! ][ 205 ][ 94 ][ 58 ]]
|
||||
[[ char*->long double ][ 140 ][ 214 ][ 95 ][ !!! *58* !!! ]]
|
||||
[[ unsigned char*->char ][ !!! *2* !!! ][ 92 ][ 9 ][ 7 ]]
|
||||
[[ unsigned char*->signed char ][ !!! *2* !!! ][ 89 ][ 10 ][ 7 ]]
|
||||
[[ unsigned char*->unsigned char ][ !!! *2* !!! ][ 89 ][ 10 ][ 14 ]]
|
||||
[[ unsigned char*->int ][ !!! *6* !!! ][ 104 ][ 20 ][ 14 ]]
|
||||
[[ unsigned char*->short ][ !!! *6* !!! ][ 106 ][ 21 ][ 14 ]]
|
||||
[[ unsigned char*->long int ][ !!! *6* !!! ][ 105 ][ 19 ][ 14 ]]
|
||||
[[ unsigned char*->long long ][ !!! *6* !!! ][ 106 ][ 20 ][ 15 ]]
|
||||
[[ unsigned char*->unsigned int ][ !!! *7* !!! ][ 105 ][ 19 ][ 14 ]]
|
||||
[[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 103 ][ 19 ][ 14 ]]
|
||||
[[ unsigned char*->unsigned long int ][ !!! *6* !!! ][ 106 ][ 19 ][ 14 ]]
|
||||
[[ unsigned char*->unsigned long long ][ !!! *6* !!! ][ 104 ][ 21 ][ 15 ]]
|
||||
[[ unsigned char*->bool ][ !!! *2* !!! ][ 102 ][ 18 ][ 7 ]]
|
||||
[[ unsigned char*->float ][ !!! *23* !!! ][ 160 ][ 66 ][ 32 ]]
|
||||
[[ unsigned char*->double ][ !!! *20* !!! ][ 201 ][ 95 ][ 58 ]]
|
||||
[[ unsigned char*->long double ][ 144 ][ 221 ][ 95 ][ !!! *60* !!! ]]
|
||||
[[ unsigned char*->string ][ !!! *12* !!! ][ 104 ][ 23 ][ --- ]]
|
||||
[[ signed char*->char ][ !!! *2* !!! ][ 90 ][ 9 ][ 7 ]]
|
||||
[[ signed char*->signed char ][ !!! *2* !!! ][ 89 ][ 9 ][ 7 ]]
|
||||
[[ signed char*->unsigned char ][ !!! *2* !!! ][ 89 ][ 10 ][ 13 ]]
|
||||
[[ signed char*->int ][ !!! *6* !!! ][ 106 ][ 19 ][ 15 ]]
|
||||
[[ signed char*->short ][ !!! *6* !!! ][ 107 ][ 20 ][ 15 ]]
|
||||
[[ signed char*->long int ][ !!! *6* !!! ][ 103 ][ 19 ][ 14 ]]
|
||||
[[ signed char*->long long ][ !!! *6* !!! ][ 103 ][ 19 ][ 14 ]]
|
||||
[[ signed char*->unsigned int ][ !!! *6* !!! ][ 101 ][ 19 ][ 15 ]]
|
||||
[[ signed char*->unsigned short ][ !!! *6* !!! ][ 101 ][ 19 ][ 16 ]]
|
||||
[[ signed char*->unsigned long int ][ !!! *6* !!! ][ 105 ][ 22 ][ 15 ]]
|
||||
[[ signed char*->unsigned long long ][ !!! *6* !!! ][ 104 ][ 21 ][ 15 ]]
|
||||
[[ signed char*->bool ][ !!! *2* !!! ][ 100 ][ 18 ][ 7 ]]
|
||||
[[ signed char*->float ][ !!! *23* !!! ][ 161 ][ 62 ][ 32 ]]
|
||||
[[ signed char*->double ][ !!! *20* !!! ][ 207 ][ 102 ][ 57 ]]
|
||||
[[ signed char*->long double ][ 144 ][ 216 ][ 96 ][ !!! *63* !!! ]]
|
||||
[[ signed char*->string ][ !!! *12* !!! ][ 104 ][ 23 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 110 ][ 22 ][ --- ]]
|
||||
[[ float->double ][ !!! *<1* !!! ][ 223 ][ 113 ][ --- ]]
|
||||
[[ double->double ][ !!! *<1* !!! ][ 227 ][ 111 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 231 ][ 122 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 229 ][ 121 ][ --- ]]
|
||||
[[ char->unsigned char ][ !!! *<1* !!! ][ 90 ][ 8 ][ --- ]]
|
||||
[[ char->signed char ][ !!! *<1* !!! ][ 88 ][ 8 ][ --- ]]
|
||||
[[ unsigned char->char ][ !!! *<1* !!! ][ 89 ][ 8 ][ --- ]]
|
||||
[[ signed char->char ][ !!! *<1* !!! ][ 91 ][ 9 ][ --- ]]
|
||||
]
|
||||
[endsect]
|
||||
[section gcc-4.4][table:id Performance Table (gcc-4.4)
|
||||
[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
|
||||
[[ string->char ][ !!! *<1* !!! ][ 90 ][ 7 ][ 7 ]]
|
||||
[[ string->signed char ][ !!! *<1* !!! ][ 88 ][ 7 ][ 8 ]]
|
||||
[[ string->unsigned char ][ !!! *<1* !!! ][ 88 ][ 8 ][ 14 ]]
|
||||
[[ string->int ][ !!! *3* !!! ][ 103 ][ 18 ][ 15 ]]
|
||||
[[ string->short ][ !!! *3* !!! ][ 105 ][ 20 ][ 15 ]]
|
||||
[[ string->long int ][ !!! *3* !!! ][ 101 ][ 18 ][ 16 ]]
|
||||
[[ string->long long ][ !!! *3* !!! ][ 101 ][ 18 ][ 15 ]]
|
||||
[[ string->unsigned int ][ !!! *3* !!! ][ 98 ][ 23 ][ 14 ]]
|
||||
[[ string->unsigned short ][ !!! *3* !!! ][ 100 ][ 17 ][ 14 ]]
|
||||
[[ string->unsigned long int ][ !!! *3* !!! ][ 100 ][ 21 ][ 15 ]]
|
||||
[[ string->unsigned long long ][ !!! *3* !!! ][ 99 ][ 19 ][ 15 ]]
|
||||
[[ string->bool ][ !!! *<1* !!! ][ 95 ][ 16 ][ 8 ]]
|
||||
[[ string->float ][ !!! *13* !!! ][ 160 ][ 61 ][ 33 ]]
|
||||
[[ string->double ][ !!! *14* !!! ][ 206 ][ 93 ][ 59 ]]
|
||||
[[ string->long double ][ 128 ][ 217 ][ 96 ][ !!! *61* !!! ]]
|
||||
[[ char->string ][ !!! *7* !!! ][ 100 ][ 17 ][ 12 ]]
|
||||
[[ unsigned char->string ][ !!! *7* !!! ][ 109 ][ 17 ][ 16 ]]
|
||||
[[ signed char->string ][ !!! *7* !!! ][ 99 ][ 17 ][ 12 ]]
|
||||
[[ int->string ][ !!! *13* !!! ][ 110 ][ 21 ][ 15 ]]
|
||||
[[ short->string ][ !!! *14* !!! ][ 110 ][ 22 ][ 17 ]]
|
||||
[[ long int->string ][ !!! *14* !!! ][ 109 ][ 21 ][ 16 ]]
|
||||
[[ long long->string ][ !!! *13* !!! ][ 114 ][ 20 ][ 17 ]]
|
||||
[[ unsigned int->string ][ !!! *13* !!! ][ 109 ][ 23 ][ 15 ]]
|
||||
[[ unsigned short->string ][ !!! *14* !!! ][ 109 ][ 23 ][ 17 ]]
|
||||
[[ unsigned long int->string ][ !!! *13* !!! ][ 112 ][ 23 ][ 16 ]]
|
||||
[[ unsigned long long->string ][ !!! *14* !!! ][ 109 ][ 21 ][ 17 ]]
|
||||
[[ bool->string ][ !!! *7* !!! ][ 108 ][ 23 ][ 11 ]]
|
||||
[[ float->string ][ 63 ][ 185 ][ 92 ][ !!! *50* !!! ]]
|
||||
[[ double->string ][ 106 ][ 216 ][ 116 ][ !!! *75* !!! ]]
|
||||
[[ long double->string ][ 118 ][ 219 ][ 119 ][ !!! *80* !!! ]]
|
||||
[[ char*->char ][ !!! *1* !!! ][ 93 ][ 9 ][ 9 ]]
|
||||
[[ char*->signed char ][ !!! *1* !!! ][ 92 ][ 9 ][ 9 ]]
|
||||
[[ char*->unsigned char ][ !!! *1* !!! ][ 92 ][ 9 ][ 14 ]]
|
||||
[[ char*->int ][ !!! *4* !!! ][ 107 ][ 19 ][ 15 ]]
|
||||
[[ char*->short ][ !!! *5* !!! ][ 109 ][ 19 ][ 15 ]]
|
||||
[[ char*->long int ][ !!! *4* !!! ][ 113 ][ 19 ][ 15 ]]
|
||||
[[ char*->long long ][ !!! *4* !!! ][ 108 ][ 20 ][ 15 ]]
|
||||
[[ char*->unsigned int ][ !!! *4* !!! ][ 106 ][ 19 ][ 15 ]]
|
||||
[[ char*->unsigned short ][ !!! *4* !!! ][ 106 ][ 18 ][ 15 ]]
|
||||
[[ char*->unsigned long int ][ !!! *4* !!! ][ 103 ][ 22 ][ 15 ]]
|
||||
[[ char*->unsigned long long ][ !!! *4* !!! ][ 105 ][ 20 ][ 15 ]]
|
||||
[[ char*->bool ][ !!! *1* !!! ][ 104 ][ 18 ][ 8 ]]
|
||||
[[ char*->float ][ !!! *15* !!! ][ 164 ][ 62 ][ 33 ]]
|
||||
[[ char*->double ][ !!! *16* !!! ][ 203 ][ 97 ][ 58 ]]
|
||||
[[ char*->long double ][ 132 ][ 223 ][ 98 ][ !!! *60* !!! ]]
|
||||
[[ unsigned char*->char ][ !!! *2* !!! ][ 90 ][ 9 ][ 8 ]]
|
||||
[[ unsigned char*->signed char ][ !!! *2* !!! ][ 92 ][ 10 ][ 8 ]]
|
||||
[[ unsigned char*->unsigned char ][ !!! *2* !!! ][ 91 ][ 9 ][ 14 ]]
|
||||
[[ unsigned char*->int ][ !!! *6* !!! ][ 106 ][ 20 ][ 15 ]]
|
||||
[[ unsigned char*->short ][ !!! *6* !!! ][ 106 ][ 21 ][ 15 ]]
|
||||
[[ unsigned char*->long int ][ !!! *6* !!! ][ 111 ][ 19 ][ 15 ]]
|
||||
[[ unsigned char*->long long ][ !!! *6* !!! ][ 107 ][ 20 ][ 15 ]]
|
||||
[[ unsigned char*->unsigned int ][ !!! *6* !!! ][ 105 ][ 19 ][ 15 ]]
|
||||
[[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 103 ][ 18 ][ 15 ]]
|
||||
[[ unsigned char*->unsigned long int ][ !!! *6* !!! ][ 106 ][ 22 ][ 14 ]]
|
||||
[[ unsigned char*->unsigned long long ][ !!! *6* !!! ][ 105 ][ 20 ][ 14 ]]
|
||||
[[ unsigned char*->bool ][ !!! *2* !!! ][ 106 ][ 18 ][ 8 ]]
|
||||
[[ unsigned char*->float ][ !!! *15* !!! ][ 167 ][ 68 ][ 33 ]]
|
||||
[[ unsigned char*->double ][ !!! *17* !!! ][ 203 ][ 99 ][ 58 ]]
|
||||
[[ unsigned char*->long double ][ 129 ][ 216 ][ 97 ][ !!! *61* !!! ]]
|
||||
[[ unsigned char*->string ][ !!! *13* !!! ][ 111 ][ 23 ][ --- ]]
|
||||
[[ signed char*->char ][ !!! *2* !!! ][ 92 ][ 9 ][ 8 ]]
|
||||
[[ signed char*->signed char ][ !!! *2* !!! ][ 91 ][ 9 ][ 8 ]]
|
||||
[[ signed char*->unsigned char ][ !!! *2* !!! ][ 91 ][ 9 ][ 14 ]]
|
||||
[[ signed char*->int ][ !!! *6* !!! ][ 107 ][ 19 ][ 15 ]]
|
||||
[[ signed char*->short ][ !!! *6* !!! ][ 109 ][ 24 ][ 14 ]]
|
||||
[[ signed char*->long int ][ !!! *6* !!! ][ 112 ][ 19 ][ 15 ]]
|
||||
[[ signed char*->long long ][ !!! *5* !!! ][ 107 ][ 20 ][ 15 ]]
|
||||
[[ signed char*->unsigned int ][ !!! *6* !!! ][ 108 ][ 20 ][ 15 ]]
|
||||
[[ signed char*->unsigned short ][ !!! *6* !!! ][ 104 ][ 18 ][ 15 ]]
|
||||
[[ signed char*->unsigned long int ][ !!! *6* !!! ][ 102 ][ 22 ][ 15 ]]
|
||||
[[ signed char*->unsigned long long ][ !!! *6* !!! ][ 104 ][ 20 ][ 15 ]]
|
||||
[[ signed char*->bool ][ !!! *2* !!! ][ 104 ][ 18 ][ 8 ]]
|
||||
[[ signed char*->float ][ !!! *16* !!! ][ 165 ][ 63 ][ 33 ]]
|
||||
[[ signed char*->double ][ !!! *16* !!! ][ 203 ][ 98 ][ 59 ]]
|
||||
[[ signed char*->long double ][ 129 ][ 215 ][ 98 ][ !!! *61* !!! ]]
|
||||
[[ signed char*->string ][ !!! *13* !!! ][ 109 ][ 21 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 109 ][ 21 ][ --- ]]
|
||||
[[ float->double ][ !!! *<1* !!! ][ 221 ][ 102 ][ --- ]]
|
||||
[[ double->double ][ !!! *<1* !!! ][ 223 ][ 103 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 231 ][ 115 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 231 ][ 115 ][ --- ]]
|
||||
[[ char->unsigned char ][ !!! *<1* !!! ][ 92 ][ 8 ][ --- ]]
|
||||
[[ char->signed char ][ !!! *<1* !!! ][ 88 ][ 8 ][ --- ]]
|
||||
[[ unsigned char->char ][ !!! *<1* !!! ][ 88 ][ 7 ][ --- ]]
|
||||
[[ signed char->char ][ !!! *<1* !!! ][ 89 ][ 8 ][ --- ]]
|
||||
]
|
||||
[endsect]
|
||||
[section gcc-4.5][table:id Performance Table (gcc-4.5)
|
||||
[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
|
||||
[[ string->char ][ !!! *<1* !!! ][ 91 ][ 8 ][ 7 ]]
|
||||
[[ string->signed char ][ !!! *<1* !!! ][ 91 ][ 8 ][ 7 ]]
|
||||
[[ string->unsigned char ][ !!! *<1* !!! ][ 90 ][ 8 ][ 13 ]]
|
||||
[[ string->int ][ !!! *3* !!! ][ 100 ][ 20 ][ 14 ]]
|
||||
[[ string->short ][ !!! *3* !!! ][ 106 ][ 20 ][ 14 ]]
|
||||
[[ string->long int ][ !!! *3* !!! ][ 100 ][ 18 ][ 14 ]]
|
||||
[[ string->long long ][ !!! *9* !!! ][ 100 ][ 18 ][ 15 ]]
|
||||
[[ string->unsigned int ][ !!! *3* !!! ][ 97 ][ 20 ][ 14 ]]
|
||||
[[ string->unsigned short ][ !!! *3* !!! ][ 102 ][ 17 ][ 14 ]]
|
||||
[[ string->unsigned long int ][ !!! *3* !!! ][ 97 ][ 21 ][ 14 ]]
|
||||
[[ string->unsigned long long ][ !!! *3* !!! ][ 97 ][ 19 ][ 14 ]]
|
||||
[[ string->bool ][ !!! *<1* !!! ][ 95 ][ 16 ][ 7 ]]
|
||||
[[ string->float ][ !!! *15* !!! ][ 157 ][ 63 ][ 32 ]]
|
||||
[[ string->double ][ !!! *17* !!! ][ 203 ][ 95 ][ 59 ]]
|
||||
[[ string->long double ][ 129 ][ 216 ][ 93 ][ !!! *58* !!! ]]
|
||||
[[ char->string ][ !!! *8* !!! ][ 100 ][ 17 ][ 10 ]]
|
||||
[[ unsigned char->string ][ !!! *8* !!! ][ 96 ][ 18 ][ 16 ]]
|
||||
[[ signed char->string ][ !!! *8* !!! ][ 96 ][ 18 ][ 10 ]]
|
||||
[[ int->string ][ !!! *14* !!! ][ 105 ][ 22 ][ 15 ]]
|
||||
[[ short->string ][ !!! *14* !!! ][ 107 ][ 23 ][ 17 ]]
|
||||
[[ long int->string ][ !!! *14* !!! ][ 109 ][ 22 ][ 17 ]]
|
||||
[[ long long->string ][ !!! *14* !!! ][ 105 ][ 22 ][ 18 ]]
|
||||
[[ unsigned int->string ][ !!! *14* !!! ][ 105 ][ 25 ][ 15 ]]
|
||||
[[ unsigned short->string ][ !!! *15* !!! ][ 105 ][ 23 ][ 17 ]]
|
||||
[[ unsigned long int->string ][ !!! *14* !!! ][ 109 ][ 24 ][ 17 ]]
|
||||
[[ unsigned long long->string ][ !!! *14* !!! ][ 102 ][ 23 ][ 17 ]]
|
||||
[[ bool->string ][ !!! *8* !!! ][ 104 ][ 23 ][ 12 ]]
|
||||
[[ float->string ][ 66 ][ 181 ][ 92 ][ !!! *49* !!! ]]
|
||||
[[ double->string ][ 107 ][ 215 ][ 120 ][ !!! *75* !!! ]]
|
||||
[[ long double->string ][ 117 ][ 221 ][ 125 ][ !!! *79* !!! ]]
|
||||
[[ char*->char ][ !!! *1* !!! ][ 89 ][ 9 ][ 7 ]]
|
||||
[[ char*->signed char ][ !!! *1* !!! ][ 90 ][ 9 ][ 7 ]]
|
||||
[[ char*->unsigned char ][ !!! *2* !!! ][ 90 ][ 9 ][ 13 ]]
|
||||
[[ char*->int ][ !!! *7* !!! ][ 103 ][ 20 ][ 15 ]]
|
||||
[[ char*->short ][ !!! *6* !!! ][ 102 ][ 29 ][ 14 ]]
|
||||
[[ char*->long int ][ !!! *7* !!! ][ 101 ][ 20 ][ 15 ]]
|
||||
[[ char*->long long ][ !!! *6* !!! ][ 102 ][ 20 ][ 14 ]]
|
||||
[[ char*->unsigned int ][ !!! *6* !!! ][ 99 ][ 19 ][ 14 ]]
|
||||
[[ char*->unsigned short ][ !!! *6* !!! ][ 101 ][ 18 ][ 14 ]]
|
||||
[[ char*->unsigned long int ][ !!! *6* !!! ][ 102 ][ 22 ][ 14 ]]
|
||||
[[ char*->unsigned long long ][ !!! *6* !!! ][ 101 ][ 21 ][ 14 ]]
|
||||
[[ char*->bool ][ !!! *3* !!! ][ 98 ][ 18 ][ 7 ]]
|
||||
[[ char*->float ][ !!! *18* !!! ][ 162 ][ 63 ][ 31 ]]
|
||||
[[ char*->double ][ !!! *17* !!! ][ 203 ][ 96 ][ 58 ]]
|
||||
[[ char*->long double ][ 135 ][ 214 ][ 98 ][ !!! *58* !!! ]]
|
||||
[[ unsigned char*->char ][ !!! *2* !!! ][ 87 ][ 9 ][ 7 ]]
|
||||
[[ unsigned char*->signed char ][ !!! *2* !!! ][ 87 ][ 9 ][ 7 ]]
|
||||
[[ unsigned char*->unsigned char ][ !!! *3* !!! ][ 87 ][ 9 ][ 13 ]]
|
||||
[[ unsigned char*->int ][ !!! *6* !!! ][ 105 ][ 20 ][ 14 ]]
|
||||
[[ unsigned char*->short ][ !!! *6* !!! ][ 102 ][ 21 ][ 14 ]]
|
||||
[[ unsigned char*->long int ][ !!! *6* !!! ][ 101 ][ 20 ][ 14 ]]
|
||||
[[ unsigned char*->long long ][ !!! *6* !!! ][ 102 ][ 20 ][ 14 ]]
|
||||
[[ unsigned char*->unsigned int ][ !!! *6* !!! ][ 99 ][ 19 ][ 14 ]]
|
||||
[[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 100 ][ 18 ][ 14 ]]
|
||||
[[ unsigned char*->unsigned long int ][ !!! *6* !!! ][ 101 ][ 24 ][ 14 ]]
|
||||
[[ unsigned char*->unsigned long long ][ !!! *6* !!! ][ 100 ][ 20 ][ 14 ]]
|
||||
[[ unsigned char*->bool ][ !!! *3* !!! ][ 99 ][ 18 ][ 8 ]]
|
||||
[[ unsigned char*->float ][ !!! *17* !!! ][ 164 ][ 64 ][ 32 ]]
|
||||
[[ unsigned char*->double ][ !!! *18* !!! ][ 201 ][ 94 ][ 58 ]]
|
||||
[[ unsigned char*->long double ][ 133 ][ 217 ][ 95 ][ !!! *60* !!! ]]
|
||||
[[ unsigned char*->string ][ !!! *14* !!! ][ 103 ][ 23 ][ --- ]]
|
||||
[[ signed char*->char ][ !!! *3* !!! ][ 88 ][ 10 ][ 8 ]]
|
||||
[[ signed char*->signed char ][ !!! *2* !!! ][ 87 ][ 10 ][ 7 ]]
|
||||
[[ signed char*->unsigned char ][ !!! *3* !!! ][ 87 ][ 9 ][ 13 ]]
|
||||
[[ signed char*->int ][ !!! *6* !!! ][ 104 ][ 20 ][ 14 ]]
|
||||
[[ signed char*->short ][ !!! *6* !!! ][ 105 ][ 21 ][ 14 ]]
|
||||
[[ signed char*->long int ][ !!! *6* !!! ][ 104 ][ 20 ][ 15 ]]
|
||||
[[ signed char*->long long ][ !!! *6* !!! ][ 106 ][ 20 ][ 14 ]]
|
||||
[[ signed char*->unsigned int ][ !!! *6* !!! ][ 99 ][ 20 ][ 14 ]]
|
||||
[[ signed char*->unsigned short ][ !!! *6* !!! ][ 100 ][ 18 ][ 14 ]]
|
||||
[[ signed char*->unsigned long int ][ !!! *6* !!! ][ 102 ][ 23 ][ 14 ]]
|
||||
[[ signed char*->unsigned long long ][ !!! *6* !!! ][ 103 ][ 20 ][ 14 ]]
|
||||
[[ signed char*->bool ][ !!! *3* !!! ][ 99 ][ 18 ][ 7 ]]
|
||||
[[ signed char*->float ][ !!! *18* !!! ][ 159 ][ 60 ][ 32 ]]
|
||||
[[ signed char*->double ][ !!! *18* !!! ][ 203 ][ 95 ][ 57 ]]
|
||||
[[ signed char*->long double ][ 129 ][ 213 ][ 97 ][ !!! *56* !!! ]]
|
||||
[[ signed char*->string ][ !!! *14* !!! ][ 105 ][ 22 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 109 ][ 22 ][ --- ]]
|
||||
[[ float->double ][ !!! *<1* !!! ][ 226 ][ 104 ][ --- ]]
|
||||
[[ double->double ][ !!! *<1* !!! ][ 229 ][ 103 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 225 ][ 115 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 227 ][ 115 ][ --- ]]
|
||||
[[ char->unsigned char ][ !!! *<1* !!! ][ 90 ][ 8 ][ --- ]]
|
||||
[[ char->signed char ][ !!! *<1* !!! ][ 84 ][ 8 ][ --- ]]
|
||||
[[ unsigned char->char ][ !!! *<1* !!! ][ 88 ][ 8 ][ --- ]]
|
||||
[[ signed char->char ][ !!! *<1* !!! ][ 89 ][ 8 ][ --- ]]
|
||||
]
|
||||
[endsect]
|
||||
[section gcc-4.6][table:id Performance Table (gcc-4.6)
|
||||
[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
|
||||
[[ string->char ][ !!! *<1* !!! ][ 94 ][ 8 ][ 7 ]]
|
||||
[[ string->signed char ][ !!! *<1* !!! ][ 96 ][ 9 ][ 7 ]]
|
||||
[[ string->unsigned char ][ !!! *<1* !!! ][ 96 ][ 8 ][ 13 ]]
|
||||
[[ string->int ][ !!! *3* !!! ][ 110 ][ 18 ][ 16 ]]
|
||||
[[ string->short ][ !!! *3* !!! ][ 111 ][ 18 ][ 16 ]]
|
||||
[[ string->long int ][ !!! *3* !!! ][ 109 ][ 18 ][ 15 ]]
|
||||
[[ string->long long ][ !!! *3* !!! ][ 111 ][ 18 ][ 15 ]]
|
||||
[[ string->unsigned int ][ !!! *3* !!! ][ 110 ][ 20 ][ 15 ]]
|
||||
[[ string->unsigned short ][ !!! *3* !!! ][ 111 ][ 18 ][ 15 ]]
|
||||
[[ string->unsigned long int ][ !!! *3* !!! ][ 109 ][ 18 ][ 15 ]]
|
||||
[[ string->unsigned long long ][ !!! *3* !!! ][ 114 ][ 19 ][ 15 ]]
|
||||
[[ string->bool ][ !!! *<1* !!! ][ 106 ][ 17 ][ 8 ]]
|
||||
[[ string->float ][ !!! *13* !!! ][ 175 ][ 70 ][ 33 ]]
|
||||
[[ string->double ][ !!! *14* !!! ][ 182 ][ 81 ][ 58 ]]
|
||||
[[ string->long double ][ 118 ][ 190 ][ 87 ][ !!! *58* !!! ]]
|
||||
[[ char->string ][ !!! *8* !!! ][ 118 ][ 21 ][ 12 ]]
|
||||
[[ unsigned char->string ][ !!! *8* !!! ][ 109 ][ 18 ][ 16 ]]
|
||||
[[ signed char->string ][ !!! *8* !!! ][ 108 ][ 18 ][ 12 ]]
|
||||
[[ int->string ][ 20 ][ 121 ][ 21 ][ !!! *16* !!! ]]
|
||||
[[ short->string ][ !!! *15* !!! ][ 120 ][ 22 ][ 17 ]]
|
||||
[[ long int->string ][ !!! *15* !!! ][ 120 ][ 22 ][ 16 ]]
|
||||
[[ long long->string ][ !!! *15* !!! ][ 120 ][ 22 ][ 17 ]]
|
||||
[[ unsigned int->string ][ !!! *15* !!! ][ 120 ][ 22 ][ 16 ]]
|
||||
[[ unsigned short->string ][ !!! *15* !!! ][ 120 ][ 22 ][ 18 ]]
|
||||
[[ unsigned long int->string ][ 16 ][ 118 ][ 22 ][ !!! *15* !!! ]]
|
||||
[[ unsigned long long->string ][ !!! *15* !!! ][ 117 ][ 21 ][ 17 ]]
|
||||
[[ bool->string ][ !!! *8* !!! ][ 117 ][ 23 ][ 10 ]]
|
||||
[[ float->string ][ 77 ][ 218 ][ 105 ][ !!! *50* !!! ]]
|
||||
[[ double->string ][ 108 ][ 247 ][ 129 ][ !!! *73* !!! ]]
|
||||
[[ long double->string ][ 120 ][ 250 ][ 131 ][ !!! *79* !!! ]]
|
||||
[[ char*->char ][ !!! *2* !!! ][ 99 ][ 9 ][ 7 ]]
|
||||
[[ char*->signed char ][ !!! *2* !!! ][ 98 ][ 9 ][ 8 ]]
|
||||
[[ char*->unsigned char ][ !!! *2* !!! ][ 98 ][ 9 ][ 13 ]]
|
||||
[[ char*->int ][ !!! *6* !!! ][ 115 ][ 22 ][ 15 ]]
|
||||
[[ char*->short ][ !!! *6* !!! ][ 114 ][ 22 ][ 15 ]]
|
||||
[[ char*->long int ][ !!! *6* !!! ][ 114 ][ 22 ][ 16 ]]
|
||||
[[ char*->long long ][ !!! *6* !!! ][ 119 ][ 22 ][ 15 ]]
|
||||
[[ char*->unsigned int ][ !!! *6* !!! ][ 114 ][ 20 ][ 15 ]]
|
||||
[[ char*->unsigned short ][ !!! *6* !!! ][ 116 ][ 20 ][ 15 ]]
|
||||
[[ char*->unsigned long int ][ !!! *6* !!! ][ 117 ][ 22 ][ 15 ]]
|
||||
[[ char*->unsigned long long ][ !!! *6* !!! ][ 118 ][ 22 ][ 15 ]]
|
||||
[[ char*->bool ][ !!! *3* !!! ][ 113 ][ 18 ][ 8 ]]
|
||||
[[ char*->float ][ !!! *15* !!! ][ 180 ][ 78 ][ 32 ]]
|
||||
[[ char*->double ][ !!! *16* !!! ][ 185 ][ 89 ][ 58 ]]
|
||||
[[ char*->long double ][ 119 ][ 193 ][ 91 ][ !!! *60* !!! ]]
|
||||
[[ unsigned char*->char ][ !!! *2* !!! ][ 99 ][ 9 ][ 8 ]]
|
||||
[[ unsigned char*->signed char ][ !!! *2* !!! ][ 99 ][ 10 ][ 8 ]]
|
||||
[[ unsigned char*->unsigned char ][ !!! *2* !!! ][ 100 ][ 9 ][ 15 ]]
|
||||
[[ unsigned char*->int ][ !!! *6* !!! ][ 118 ][ 22 ][ 15 ]]
|
||||
[[ unsigned char*->short ][ !!! *6* !!! ][ 117 ][ 26 ][ 15 ]]
|
||||
[[ unsigned char*->long int ][ !!! *6* !!! ][ 119 ][ 21 ][ 15 ]]
|
||||
[[ unsigned char*->long long ][ !!! *6* !!! ][ 118 ][ 21 ][ 14 ]]
|
||||
[[ unsigned char*->unsigned int ][ !!! *6* !!! ][ 115 ][ 22 ][ 14 ]]
|
||||
[[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 117 ][ 20 ][ 15 ]]
|
||||
[[ unsigned char*->unsigned long int ][ !!! *6* !!! ][ 115 ][ 21 ][ 15 ]]
|
||||
[[ unsigned char*->unsigned long long ][ !!! *6* !!! ][ 117 ][ 22 ][ 15 ]]
|
||||
[[ unsigned char*->bool ][ !!! *3* !!! ][ 112 ][ 18 ][ 8 ]]
|
||||
[[ unsigned char*->float ][ !!! *15* !!! ][ 181 ][ 78 ][ 33 ]]
|
||||
[[ unsigned char*->double ][ !!! *16* !!! ][ 185 ][ 92 ][ 59 ]]
|
||||
[[ unsigned char*->long double ][ 120 ][ 190 ][ 89 ][ !!! *58* !!! ]]
|
||||
[[ unsigned char*->string ][ !!! *14* !!! ][ 121 ][ 22 ][ --- ]]
|
||||
[[ signed char*->char ][ !!! *2* !!! ][ 99 ][ 9 ][ 9 ]]
|
||||
[[ signed char*->signed char ][ !!! *2* !!! ][ 98 ][ 9 ][ 8 ]]
|
||||
[[ signed char*->unsigned char ][ !!! *2* !!! ][ 98 ][ 9 ][ 14 ]]
|
||||
[[ signed char*->int ][ !!! *6* !!! ][ 119 ][ 22 ][ 16 ]]
|
||||
[[ signed char*->short ][ !!! *6* !!! ][ 115 ][ 22 ][ 15 ]]
|
||||
[[ signed char*->long int ][ !!! *6* !!! ][ 119 ][ 22 ][ 15 ]]
|
||||
[[ signed char*->long long ][ !!! *6* !!! ][ 117 ][ 22 ][ 15 ]]
|
||||
[[ signed char*->unsigned int ][ !!! *6* !!! ][ 117 ][ 23 ][ 15 ]]
|
||||
[[ signed char*->unsigned short ][ !!! *6* !!! ][ 117 ][ 21 ][ 14 ]]
|
||||
[[ signed char*->unsigned long int ][ !!! *7* !!! ][ 119 ][ 24 ][ 15 ]]
|
||||
[[ signed char*->unsigned long long ][ !!! *6* !!! ][ 116 ][ 22 ][ 15 ]]
|
||||
[[ signed char*->bool ][ !!! *3* !!! ][ 111 ][ 18 ][ 8 ]]
|
||||
[[ signed char*->float ][ !!! *16* !!! ][ 180 ][ 78 ][ 33 ]]
|
||||
[[ signed char*->double ][ !!! *16* !!! ][ 185 ][ 89 ][ 59 ]]
|
||||
[[ signed char*->long double ][ 120 ][ 191 ][ 91 ][ !!! *59* !!! ]]
|
||||
[[ signed char*->string ][ !!! *14* !!! ][ 122 ][ 23 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 120 ][ 22 ][ --- ]]
|
||||
[[ float->double ][ !!! *<1* !!! ][ 242 ][ 115 ][ --- ]]
|
||||
[[ double->double ][ !!! *<1* !!! ][ 243 ][ 115 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 265 ][ 141 ][ --- ]]
|
||||
[[ int->int ][ !!! *<1* !!! ][ 266 ][ 140 ][ --- ]]
|
||||
[[ char->unsigned char ][ !!! *<1* !!! ][ 95 ][ 8 ][ --- ]]
|
||||
[[ char->signed char ][ !!! *<1* !!! ][ 95 ][ 8 ][ --- ]]
|
||||
[[ unsigned char->char ][ !!! *<1* !!! ][ 94 ][ 8 ][ --- ]]
|
||||
[[ signed char->char ][ !!! *<1* !!! ][ 94 ][ 8 ][ --- ]]
|
||||
]
|
||||
[endsect]
|
||||
|
||||
[/ END of section, generated by performance measuring program ]
|
||||
[endsect]
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
// boost polymorphic_cast.hpp header file ----------------------------------------------//
|
||||
// boost cast.hpp header file ----------------------------------------------//
|
||||
|
||||
// (C) Copyright Kevlin Henney and Dave Abrahams 1999.
|
||||
// Distributed under the Boost
|
||||
@@ -8,9 +8,7 @@
|
||||
// See http://www.boost.org/libs/conversion for Documentation.
|
||||
|
||||
// Revision History
|
||||
// 09 Jun 14 "cast.hpp" was renamed to "polymorphic_cast.hpp" and
|
||||
// inclusion of numeric_cast was removed (Antony Polukhin)
|
||||
// 23 Jun 05 numeric_cast removed and redirected to the new verion (Fernando Cacciola)
|
||||
// 23 JUn 05 numeric_cast removed and redirected to the new verion (Fernando Cacciola)
|
||||
// 02 Apr 01 Removed BOOST_NO_LIMITS workarounds and included
|
||||
// <boost/limits.hpp> instead (the workaround did not
|
||||
// actually compile when BOOST_NO_LIMITS was defined in
|
||||
@@ -42,12 +40,26 @@
|
||||
// place in nested namespace.
|
||||
// 3 Aug 99 Initial version
|
||||
|
||||
#ifndef BOOST_POLYMORPHIC_CAST_HPP
|
||||
#define BOOST_POLYMORPHIC_CAST_HPP
|
||||
#ifndef BOOST_CAST_HPP
|
||||
#define BOOST_CAST_HPP
|
||||
|
||||
# include <boost/config.hpp>
|
||||
# include <boost/assert.hpp>
|
||||
# include <typeinfo>
|
||||
# include <boost/type.hpp>
|
||||
# include <boost/limits.hpp>
|
||||
# include <boost/detail/select_type.hpp>
|
||||
|
||||
// It has been demonstrated numerous times that MSVC 6.0 fails silently at link
|
||||
// time if you use a template function which has template parameters that don't
|
||||
// appear in the function's argument list.
|
||||
//
|
||||
// TODO: Add this to config.hpp?
|
||||
# if defined(BOOST_MSVC) && BOOST_MSVC < 1300
|
||||
# define BOOST_EXPLICIT_DEFAULT_TARGET , ::boost::type<Target>* = 0
|
||||
# else
|
||||
# define BOOST_EXPLICIT_DEFAULT_TARGET
|
||||
# endif
|
||||
|
||||
namespace boost
|
||||
{
|
||||
@@ -61,7 +73,7 @@ namespace boost
|
||||
// section 15.8 exercise 1, page 425.
|
||||
|
||||
template <class Target, class Source>
|
||||
inline Target polymorphic_cast(Source* x)
|
||||
inline Target polymorphic_cast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET)
|
||||
{
|
||||
Target tmp = dynamic_cast<Target>(x);
|
||||
if ( tmp == 0 ) throw std::bad_cast();
|
||||
@@ -80,12 +92,16 @@ namespace boost
|
||||
// Contributed by Dave Abrahams
|
||||
|
||||
template <class Target, class Source>
|
||||
inline Target polymorphic_downcast(Source* x)
|
||||
inline Target polymorphic_downcast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET)
|
||||
{
|
||||
BOOST_ASSERT( dynamic_cast<Target>(x) == x ); // detect logic error
|
||||
return static_cast<Target>(x);
|
||||
}
|
||||
|
||||
# undef BOOST_EXPLICIT_DEFAULT_TARGET
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_POLYMORPHIC_CAST_HPP
|
||||
# include <boost/numeric/conversion/cast.hpp>
|
||||
|
||||
#endif // BOOST_CAST_HPP
|
||||
@@ -0,0 +1,184 @@
|
||||
// Copyright Alexander Nasonov & Paul A. Bristow 2006.
|
||||
|
||||
// Use, modification and distribution are subject to the
|
||||
// Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
|
||||
#define BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
|
||||
|
||||
#include <climits>
|
||||
#include <ios>
|
||||
#include <limits>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/integer_traits.hpp>
|
||||
|
||||
#ifndef BOOST_NO_IS_ABSTRACT
|
||||
// Fix for SF:1358600 - lexical_cast & pure virtual functions & VC 8 STL
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/type_traits/is_abstract.hpp>
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || \
|
||||
(defined(BOOST_MSVC) && (BOOST_MSVC<1310))
|
||||
|
||||
#define BOOST_LCAST_NO_COMPILE_TIME_PRECISION
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
|
||||
#include <boost/assert.hpp>
|
||||
#else
|
||||
#include <boost/static_assert.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost { namespace detail {
|
||||
|
||||
class lcast_abstract_stub {};
|
||||
|
||||
#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
|
||||
// Calculate an argument to pass to std::ios_base::precision from
|
||||
// lexical_cast. See alternative implementation for broken standard
|
||||
// libraries in lcast_get_precision below. Keep them in sync, please.
|
||||
template<class T>
|
||||
struct lcast_precision
|
||||
{
|
||||
#ifdef BOOST_NO_IS_ABSTRACT
|
||||
typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
|
||||
#else
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
|
||||
boost::is_abstract<T>
|
||||
, std::numeric_limits<lcast_abstract_stub>
|
||||
, std::numeric_limits<T>
|
||||
>::type limits;
|
||||
#endif
|
||||
|
||||
BOOST_STATIC_CONSTANT(bool, use_default_precision =
|
||||
!limits::is_specialized || limits::is_exact
|
||||
);
|
||||
|
||||
BOOST_STATIC_CONSTANT(bool, is_specialized_bin =
|
||||
!use_default_precision &&
|
||||
limits::radix == 2 && limits::digits > 0
|
||||
);
|
||||
|
||||
BOOST_STATIC_CONSTANT(bool, is_specialized_dec =
|
||||
!use_default_precision &&
|
||||
limits::radix == 10 && limits::digits10 > 0
|
||||
);
|
||||
|
||||
BOOST_STATIC_CONSTANT(std::streamsize, streamsize_max =
|
||||
boost::integer_traits<std::streamsize>::const_max
|
||||
);
|
||||
|
||||
BOOST_STATIC_CONSTANT(unsigned int, precision_dec = limits::digits10 + 1U);
|
||||
|
||||
BOOST_STATIC_ASSERT(!is_specialized_dec ||
|
||||
precision_dec <= streamsize_max + 0UL
|
||||
);
|
||||
|
||||
BOOST_STATIC_CONSTANT(unsigned long, precision_bin =
|
||||
2UL + limits::digits * 30103UL / 100000UL
|
||||
);
|
||||
|
||||
BOOST_STATIC_ASSERT(!is_specialized_bin ||
|
||||
(limits::digits + 0UL < ULONG_MAX / 30103UL &&
|
||||
precision_bin > limits::digits10 + 0UL &&
|
||||
precision_bin <= streamsize_max + 0UL)
|
||||
);
|
||||
|
||||
BOOST_STATIC_CONSTANT(std::streamsize, value =
|
||||
is_specialized_bin ? precision_bin
|
||||
: is_specialized_dec ? precision_dec : 6
|
||||
);
|
||||
};
|
||||
#endif
|
||||
|
||||
template<class T>
|
||||
inline std::streamsize lcast_get_precision(T* = 0)
|
||||
{
|
||||
#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
|
||||
return lcast_precision<T>::value;
|
||||
#else // Follow lcast_precision algorithm at run-time:
|
||||
|
||||
#ifdef BOOST_NO_IS_ABSTRACT
|
||||
typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
|
||||
#else
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
|
||||
boost::is_abstract<T>
|
||||
, std::numeric_limits<lcast_abstract_stub>
|
||||
, std::numeric_limits<T>
|
||||
>::type limits;
|
||||
#endif
|
||||
|
||||
bool const use_default_precision =
|
||||
!limits::is_specialized || limits::is_exact;
|
||||
|
||||
if(!use_default_precision)
|
||||
{ // Includes all built-in floating-point types, float, double ...
|
||||
// and UDT types for which digits (significand bits) is defined (not zero)
|
||||
|
||||
bool const is_specialized_bin =
|
||||
limits::radix == 2 && limits::digits > 0;
|
||||
bool const is_specialized_dec =
|
||||
limits::radix == 10 && limits::digits10 > 0;
|
||||
std::streamsize const streamsize_max =
|
||||
(boost::integer_traits<std::streamsize>::max)();
|
||||
|
||||
if(is_specialized_bin)
|
||||
{ // Floating-point types with
|
||||
// limits::digits defined by the specialization.
|
||||
|
||||
unsigned long const digits = limits::digits;
|
||||
unsigned long const precision = 2UL + digits * 30103UL / 100000UL;
|
||||
// unsigned long is selected because it is at least 32-bits
|
||||
// and thus ULONG_MAX / 30103UL is big enough for all types.
|
||||
BOOST_ASSERT(
|
||||
digits < ULONG_MAX / 30103UL &&
|
||||
precision > limits::digits10 + 0UL &&
|
||||
precision <= streamsize_max + 0UL
|
||||
);
|
||||
return precision;
|
||||
}
|
||||
else if(is_specialized_dec)
|
||||
{ // Decimal Floating-point type, most likely a User Defined Type
|
||||
// rather than a real floating-point hardware type.
|
||||
unsigned int const precision = limits::digits10 + 1U;
|
||||
BOOST_ASSERT(precision <= streamsize_max + 0UL);
|
||||
return precision;
|
||||
}
|
||||
}
|
||||
|
||||
// Integral type (for which precision has no effect)
|
||||
// or type T for which limits is NOT specialized,
|
||||
// so assume stream precision remains the default 6 decimal digits.
|
||||
// Warning: if your User-defined Floating-point type T is NOT specialized,
|
||||
// then you may lose accuracy by only using 6 decimal digits.
|
||||
// To avoid this, you need to specialize T with either
|
||||
// radix == 2 and digits == the number of significand bits,
|
||||
// OR
|
||||
// radix = 10 and digits10 == the number of decimal digits.
|
||||
|
||||
return 6;
|
||||
#endif
|
||||
}
|
||||
|
||||
template<class T>
|
||||
inline void lcast_set_precision(std::ios_base& stream, T*)
|
||||
{
|
||||
stream.precision(lcast_get_precision<T>());
|
||||
}
|
||||
|
||||
template<class Source, class Target>
|
||||
inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
|
||||
{
|
||||
std::streamsize const s = lcast_get_precision(static_cast<Source*>(0));
|
||||
std::streamsize const t = lcast_get_precision(static_cast<Target*>(0));
|
||||
stream.precision(s > t ? s : t);
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
#endif // BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
|
||||
|
||||
@@ -5,24 +5,17 @@
|
||||
#ifndef IMPLICIT_CAST_DWA200356_HPP
|
||||
# define IMPLICIT_CAST_DWA200356_HPP
|
||||
|
||||
# include <boost/mpl/identity.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class T> struct icast_identity
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// implementation originally suggested by C. Green in
|
||||
// http://lists.boost.org/MailArchives/boost/msg00886.php
|
||||
|
||||
// The use of identity creates a non-deduced form, so that the
|
||||
// explicit template argument must be supplied
|
||||
template <typename T>
|
||||
inline T implicit_cast (typename boost::detail::icast_identity<T>::type x) {
|
||||
inline T implicit_cast (typename mpl::identity<T>::type x) {
|
||||
return x;
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
+2
-13
@@ -6,13 +6,6 @@
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
|
||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||
<title>Boost Conversion Library</title>
|
||||
<style>
|
||||
.copyright
|
||||
{
|
||||
color: #666666;
|
||||
font-size: small;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
@@ -39,11 +32,7 @@ supplied by several headers:</p>
|
||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED"
|
||||
S-Format="%d %B, %Y" startspan -->June 23, 2005<!--webbot bot="Timestamp" endspan i-checksum="30348" -->
|
||||
</p>
|
||||
<p class="copyright">
|
||||
Copyright 2001 Beman Dawes.
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)
|
||||
</p>
|
||||
|
||||
</body>
|
||||
|
||||
</html>
|
||||
</html>
|
||||
@@ -0,0 +1,16 @@
|
||||
|
||||
<!--
|
||||
Copyright 2005-2007 Daniel James.
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=../../doc/html/boost_lexical_cast.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="../../doc/html/boost_lexical_cast.html">../../doc/html/boost_lexical_cast.html</a>
|
||||
</body>
|
||||
</html>
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,15 +0,0 @@
|
||||
{
|
||||
"key": "conversion",
|
||||
"name": "Conversion",
|
||||
"authors": [
|
||||
"Dave Abrahams",
|
||||
"Kevlin Henney"
|
||||
],
|
||||
"description": "Polymorphic casts.",
|
||||
"category": [
|
||||
"Miscellaneous"
|
||||
],
|
||||
"maintainers": [
|
||||
"Antony Polukhin <antoshkka -at- gmail.com>"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
// boost utility cast test program -----------------------------------------//
|
||||
|
||||
// (C) Copyright Beman Dawes, Dave Abrahams 1999. Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
|
||||
// Revision History
|
||||
// 28 Set 04 factored out numeric_cast<> test (Fernando Cacciola)
|
||||
// 20 Jan 01 removed use of <limits> for portability to raw GCC (David Abrahams)
|
||||
// 28 Jun 00 implicit_cast removed (Beman Dawes)
|
||||
// 30 Aug 99 value_cast replaced by numeric_cast
|
||||
// 3 Aug 99 Initial Version
|
||||
|
||||
#include <iostream>
|
||||
#include <climits>
|
||||
#include <cfloat> // for DBL_MAX (Peter Schmid)
|
||||
#include <boost/cast.hpp>
|
||||
|
||||
#include "boost/test/minimal.hpp"
|
||||
|
||||
# if SCHAR_MAX == LONG_MAX
|
||||
# error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
|
||||
# endif
|
||||
|
||||
using namespace boost;
|
||||
using std::cout;
|
||||
|
||||
|
||||
int test_main( int argc, char * argv[] )
|
||||
{
|
||||
|
||||
# ifdef NDEBUG
|
||||
cout << "NDEBUG is defined\n";
|
||||
# else
|
||||
cout << "NDEBUG is not defined\n";
|
||||
# endif
|
||||
|
||||
cout << "\nBeginning tests...\n";
|
||||
|
||||
// test implicit_cast and numeric_cast -------------------------------------//
|
||||
|
||||
// tests which should succeed
|
||||
long small_value = 1;
|
||||
long small_negative_value = -1;
|
||||
long large_value = LONG_MAX;
|
||||
long large_negative_value = LONG_MIN;
|
||||
signed char c = 0;
|
||||
|
||||
c = large_value; // see if compiler generates warning
|
||||
|
||||
c = numeric_cast<signed char>( small_value );
|
||||
BOOST_CHECK( c == 1 );
|
||||
c = 0;
|
||||
c = numeric_cast<signed char>( small_value );
|
||||
BOOST_CHECK( c == 1 );
|
||||
c = 0;
|
||||
c = numeric_cast<signed char>( small_negative_value );
|
||||
BOOST_CHECK( c == -1 );
|
||||
|
||||
// These tests courtesy of Joe R NWP Swatosh<joe.r.swatosh@usace.army.mil>
|
||||
BOOST_CHECK( 0.0f == numeric_cast<float>( 0.0 ) );
|
||||
BOOST_CHECK( 0.0 == numeric_cast<double>( 0.0 ) );
|
||||
|
||||
// tests which should result in errors being detected
|
||||
|
||||
bool caught_exception = false;
|
||||
try { c = numeric_cast<signed char>( large_value ); }
|
||||
catch (bad_numeric_cast)
|
||||
{ cout<<"caught bad_numeric_cast #1\n"; caught_exception = true; }
|
||||
BOOST_CHECK ( caught_exception );
|
||||
|
||||
caught_exception = false;
|
||||
try { c = numeric_cast<signed char>( large_negative_value ); }
|
||||
catch (bad_numeric_cast)
|
||||
{ cout<<"caught bad_numeric_cast #2\n"; caught_exception = true; }
|
||||
BOOST_CHECK ( caught_exception );
|
||||
|
||||
unsigned long ul;
|
||||
caught_exception = false;
|
||||
try { ul = numeric_cast<unsigned long>( large_negative_value ); }
|
||||
catch (bad_numeric_cast)
|
||||
{ cout<<"caught bad_numeric_cast #3\n"; caught_exception = true; }
|
||||
BOOST_CHECK ( caught_exception );
|
||||
|
||||
caught_exception = false;
|
||||
try { ul = numeric_cast<unsigned long>( small_negative_value ); }
|
||||
catch (bad_numeric_cast)
|
||||
{ cout<<"caught bad_numeric_cast #4\n"; caught_exception = true; }
|
||||
BOOST_CHECK ( caught_exception );
|
||||
|
||||
caught_exception = false;
|
||||
try { numeric_cast<int>( DBL_MAX ); }
|
||||
catch (bad_numeric_cast)
|
||||
{ cout<<"caught bad_numeric_cast #5\n"; caught_exception = true; }
|
||||
BOOST_CHECK ( caught_exception );
|
||||
|
||||
return 0 ;
|
||||
}
|
||||
@@ -0,0 +1,308 @@
|
||||
// what: simple unit test framework
|
||||
// who: developed by Kevlin Henney
|
||||
// when: November 2000
|
||||
// where: tested with BCC 5.5, MSVC 6.0, and g++ 2.91
|
||||
//
|
||||
// ChangeLog:
|
||||
// 20 Jan 2001 - Fixed a warning for MSVC (Dave Abrahams)
|
||||
|
||||
#ifndef TEST_INCLUDED
|
||||
#define TEST_INCLUDED
|
||||
|
||||
#include <exception>
|
||||
#include <iostream>
|
||||
#include <strstream> // for out-of-the-box g++
|
||||
#include <string>
|
||||
|
||||
namespace test // test tuple comprises name and nullary function (object)
|
||||
{
|
||||
template<typename string_type, typename function_type>
|
||||
struct test
|
||||
{
|
||||
string_type name;
|
||||
function_type action;
|
||||
|
||||
static test make(string_type name, function_type action)
|
||||
{
|
||||
test result; // MSVC aggreggate initializer bugs
|
||||
result.name = name;
|
||||
result.action = action;
|
||||
return result;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
namespace test // failure exception used to indicate checked test failures
|
||||
{
|
||||
class failure : public std::exception
|
||||
{
|
||||
public: // struction (default cases are OK)
|
||||
|
||||
failure(const std::string & why)
|
||||
: reason(why)
|
||||
{
|
||||
}
|
||||
|
||||
// std::~string has no exception-specification (could throw anything),
|
||||
// but we need to be compatible with std::~exception's empty one
|
||||
// see std::15.4p13 and std::15.4p3
|
||||
~failure() throw()
|
||||
{
|
||||
}
|
||||
|
||||
public: // usage
|
||||
|
||||
virtual const char * what() const throw()
|
||||
{
|
||||
return reason.c_str();
|
||||
}
|
||||
|
||||
private: // representation
|
||||
|
||||
std::string reason;
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
namespace test // not_implemented exception used to mark unimplemented tests
|
||||
{
|
||||
class not_implemented : public std::exception
|
||||
{
|
||||
public: // usage (default ctor and dtor are OK)
|
||||
|
||||
virtual const char * what() const throw()
|
||||
{
|
||||
return "not implemented";
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
namespace test // test utilities
|
||||
{
|
||||
inline void check(bool condition, const std::string & description)
|
||||
{
|
||||
if(!condition)
|
||||
{
|
||||
throw failure(description);
|
||||
}
|
||||
}
|
||||
|
||||
inline void check_true(bool value, const std::string & description)
|
||||
{
|
||||
check(value, "expected true: " + description);
|
||||
}
|
||||
|
||||
inline void check_false(bool value, const std::string & description)
|
||||
{
|
||||
check(!value, "expected false: " + description);
|
||||
}
|
||||
|
||||
template<typename lhs_type, typename rhs_type>
|
||||
void check_equal(
|
||||
const lhs_type & lhs, const rhs_type & rhs,
|
||||
const std::string & description)
|
||||
{
|
||||
check(lhs == rhs, "expected equal values: " + description);
|
||||
}
|
||||
|
||||
template<typename lhs_type, typename rhs_type>
|
||||
void check_unequal(
|
||||
const lhs_type & lhs, const rhs_type & rhs,
|
||||
const std::string & description)
|
||||
{
|
||||
check(lhs != rhs, "expected unequal values: " + description);
|
||||
}
|
||||
|
||||
inline void check_null(const void* ptr, const std::string & description)
|
||||
{
|
||||
check(!ptr, "expected null pointer: " + description);
|
||||
}
|
||||
|
||||
inline void check_non_null(const void* ptr, const std::string & description)
|
||||
{
|
||||
check(ptr != 0, "expected non-null pointer: " + description);
|
||||
}
|
||||
}
|
||||
|
||||
#define TEST_CHECK_THROW(expression, exception, description) \
|
||||
try \
|
||||
{ \
|
||||
expression; \
|
||||
throw ::test::failure(description); \
|
||||
} \
|
||||
catch(exception &) \
|
||||
{ \
|
||||
}
|
||||
|
||||
namespace test // memory tracking (enabled if test new and delete linked in)
|
||||
{
|
||||
class allocations
|
||||
{
|
||||
public: // singleton access
|
||||
|
||||
static allocations & instance()
|
||||
{
|
||||
static allocations singleton;
|
||||
return singleton;
|
||||
}
|
||||
|
||||
public: // logging
|
||||
|
||||
void clear()
|
||||
{
|
||||
alloc_count = dealloc_count = 0;
|
||||
}
|
||||
|
||||
void allocation()
|
||||
{
|
||||
++alloc_count;
|
||||
}
|
||||
|
||||
void deallocation()
|
||||
{
|
||||
++dealloc_count;
|
||||
}
|
||||
|
||||
public: // reporting
|
||||
|
||||
unsigned long allocated() const
|
||||
{
|
||||
return alloc_count;
|
||||
}
|
||||
|
||||
unsigned long deallocated() const
|
||||
{
|
||||
return dealloc_count;
|
||||
}
|
||||
|
||||
bool balanced() const
|
||||
{
|
||||
return alloc_count == dealloc_count;
|
||||
}
|
||||
|
||||
private: // structors (default dtor is fine)
|
||||
|
||||
allocations()
|
||||
: alloc_count(0), dealloc_count(0)
|
||||
{
|
||||
}
|
||||
|
||||
private: // prevention
|
||||
|
||||
allocations(const allocations &);
|
||||
allocations & operator=(const allocations &);
|
||||
|
||||
private: // state
|
||||
|
||||
unsigned long alloc_count, dealloc_count;
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
namespace test // tester is the driver class for a sequence of tests
|
||||
{
|
||||
template<typename test_iterator>
|
||||
class tester
|
||||
{
|
||||
public: // structors (default destructor is OK)
|
||||
|
||||
tester(test_iterator first_test, test_iterator after_last_test)
|
||||
: begin(first_test), end(after_last_test)
|
||||
{
|
||||
}
|
||||
|
||||
public: // usage
|
||||
|
||||
bool operator()(); // returns true if all tests passed
|
||||
|
||||
private: // representation
|
||||
|
||||
test_iterator begin, end;
|
||||
|
||||
private: // prevention
|
||||
|
||||
tester(const tester &);
|
||||
tester &operator=(const tester &);
|
||||
|
||||
};
|
||||
|
||||
template<typename test_iterator>
|
||||
bool tester<test_iterator>::operator()()
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
unsigned long passed = 0, failed = 0, unimplemented = 0;
|
||||
|
||||
for(test_iterator current = begin; current != end; ++current)
|
||||
{
|
||||
cerr << "[" << current->name << "] " << flush;
|
||||
string result = "passed"; // optimistic
|
||||
|
||||
try
|
||||
{
|
||||
allocations::instance().clear();
|
||||
current->action();
|
||||
|
||||
if(!allocations::instance().balanced())
|
||||
{
|
||||
unsigned long allocated = allocations::instance().allocated();
|
||||
unsigned long deallocated = allocations::instance().deallocated();
|
||||
ostrstream report;
|
||||
report << "new/delete ("
|
||||
<< allocated << " allocated, "
|
||||
<< deallocated << " deallocated)"
|
||||
<< ends;
|
||||
const char * text = report.str();
|
||||
report.freeze(false);
|
||||
throw failure(text);
|
||||
}
|
||||
|
||||
++passed;
|
||||
}
|
||||
catch(const failure & caught)
|
||||
{
|
||||
(result = "failed: ") += caught.what();
|
||||
++failed;
|
||||
}
|
||||
catch(const not_implemented &)
|
||||
{
|
||||
result = "not implemented";
|
||||
++unimplemented;
|
||||
}
|
||||
catch(const exception & caught)
|
||||
{
|
||||
(result = "exception: ") += caught.what();
|
||||
++failed;
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
result = "failed with unknown exception";
|
||||
++failed;
|
||||
}
|
||||
|
||||
cerr << result << endl;
|
||||
}
|
||||
|
||||
cerr << passed + failed << " tests: "
|
||||
<< passed << " passed, "
|
||||
<< failed << " failed";
|
||||
|
||||
if(unimplemented)
|
||||
{
|
||||
cerr << " (" << unimplemented << " not implemented)";
|
||||
}
|
||||
|
||||
cerr << endl;
|
||||
|
||||
return failed == 0;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
// Copyright Kevlin Henney, 2000. All rights reserved.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
+26
-21
@@ -1,29 +1,34 @@
|
||||
# Signals library
|
||||
|
||||
# Copyright (C) 2001-2003 Douglas Gregor
|
||||
# Copyright (C) 2011-2014 Antony Polukhin
|
||||
#
|
||||
# Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
#
|
||||
|
||||
# Permission to copy, use, sell and distribute this software is granted
|
||||
# provided this copyright notice appears in all copies. Permission to modify
|
||||
# the code and to distribute modified code is granted provided this copyright
|
||||
# notice appears in all copies, and a notice that the code was modified is
|
||||
# included with the copyright notice. This software is provided "as is"
|
||||
# without express or implied warranty, and with no claim as to its suitability
|
||||
# for any purpose.
|
||||
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
# bring in rules for testing
|
||||
import testing ;
|
||||
import feature ;
|
||||
|
||||
project
|
||||
: requirements
|
||||
<toolset>gcc-4.7:<cxxflags>-ftrapv
|
||||
<toolset>gcc-4.6:<cxxflags>-ftrapv
|
||||
<toolset>clang:<cxxflags>-ftrapv
|
||||
# default to all warnings on:
|
||||
<warnings>all
|
||||
# set warnings as errors for those compilers we know we get warning free:
|
||||
<toolset>gcc:<cxxflags>-Wextra
|
||||
<toolset>gcc:<cxxflags>-Wno-uninitialized
|
||||
;
|
||||
|
||||
test-suite conversion
|
||||
: [ run implicit_cast.cpp ]
|
||||
[ compile-fail implicit_cast_fail.cpp ]
|
||||
[ run cast_test.cpp ]
|
||||
[ run polymorphic_cast_test.cpp ]
|
||||
[ compile-fail implicit_cast_fail2.cpp ]
|
||||
[ run ../cast_test.cpp ]
|
||||
[ run ../numeric_cast_test.cpp ]
|
||||
[ run ../lexical_cast_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
|
||||
[ run lexical_cast_loopback_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
|
||||
[ run lexical_cast_abstract_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
|
||||
[ run lexical_cast_noncopyable_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
|
||||
[ run lexical_cast_vc8_bug_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
|
||||
[ run lexical_cast_wchars_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
|
||||
[ run lexical_cast_float_types_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
|
||||
[ run lexical_cast_inf_nan_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
|
||||
[ run lexical_cast_empty_input_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
|
||||
;
|
||||
|
||||
|
||||
|
||||
@@ -28,11 +28,5 @@ int main()
|
||||
|
||||
type<foo> f = check_return(boost::implicit_cast<foo>("hello"));
|
||||
type<long> z = check_return(boost::implicit_cast<long>(foo("hello")));
|
||||
|
||||
// warning supression:
|
||||
(void)x;
|
||||
(void)f;
|
||||
(void)z;
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@@ -4,6 +4,10 @@
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/implicit_cast.hpp>
|
||||
#include <boost/type.hpp>
|
||||
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
using boost::implicit_cast;
|
||||
|
||||
@@ -12,9 +16,7 @@ struct foo
|
||||
explicit foo(char const*) {}
|
||||
};
|
||||
|
||||
int main()
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
foo x = implicit_cast<foo>("foobar");
|
||||
(void)x; // warning suppression.
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,19 +0,0 @@
|
||||
//
|
||||
// Test that implicit_cast requires a template argument
|
||||
//
|
||||
// Copyright 2014 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
//
|
||||
// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
|
||||
//
|
||||
|
||||
#include <boost/implicit_cast.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int x = boost::implicit_cast( 1 );
|
||||
(void)x;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Sergey Shandar 2005, Alexander Nasonov, 2007.
|
||||
//
|
||||
// Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
//
|
||||
// Test abstract class. Bug 1358600:
|
||||
// http://sf.net/tracker/?func=detail&aid=1358600&group_id=7586&atid=107586
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(__INTEL_COMPILER)
|
||||
#pragma warning(disable: 193 383 488 981 1418 1419)
|
||||
#elif defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
|
||||
#endif
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace boost;
|
||||
|
||||
void test_abstract();
|
||||
|
||||
unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
{
|
||||
unit_test_framework::test_suite *suite =
|
||||
BOOST_TEST_SUITE("lexical_cast unit test");
|
||||
suite->add(BOOST_TEST_CASE(&test_abstract));
|
||||
|
||||
return suite;
|
||||
}
|
||||
|
||||
class A
|
||||
{
|
||||
public:
|
||||
virtual void out(std::ostream &) const = 0;
|
||||
};
|
||||
|
||||
class B: public A
|
||||
{
|
||||
public:
|
||||
virtual void out(std::ostream &O) const { O << "B"; }
|
||||
};
|
||||
|
||||
std::ostream &operator<<(std::ostream &O, const A &a)
|
||||
{
|
||||
a.out(O);
|
||||
return O;
|
||||
}
|
||||
|
||||
void test_abstract()
|
||||
{
|
||||
const A &a = B();
|
||||
BOOST_CHECK(boost::lexical_cast<std::string>(a) == "B");
|
||||
}
|
||||
|
||||
Executable
+58
@@ -0,0 +1,58 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2011.
|
||||
//
|
||||
// Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(__INTEL_COMPILER)
|
||||
#pragma warning(disable: 193 383 488 981 1418 1419)
|
||||
#elif defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
|
||||
#endif
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/range/iterator_range.hpp>
|
||||
|
||||
using namespace boost;
|
||||
|
||||
void test_empty_iterator_range()
|
||||
{
|
||||
boost::iterator_range<const char*> v;
|
||||
BOOST_CHECK_THROW(lexical_cast<int>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<float>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<double>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<long double>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned int>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<std::string>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned short>(v), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
|
||||
}
|
||||
|
||||
void test_empty_string()
|
||||
{
|
||||
BOOST_CHECK_THROW(lexical_cast<int>(std::string()), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<float>(std::string()), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<double>(std::string()), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<long double>(std::string()), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned int>(std::string()), bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(lexical_cast<std::string>(std::string()), std::string());
|
||||
BOOST_CHECK_THROW(lexical_cast<unsigned short>(std::string()), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<char>(std::string()), bad_lexical_cast);
|
||||
}
|
||||
|
||||
unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
{
|
||||
unit_test_framework::test_suite *suite =
|
||||
BOOST_TEST_SUITE("lexical_cast. Empty input unit test");
|
||||
suite->add(BOOST_TEST_CASE(&test_empty_iterator_range));
|
||||
suite->add(BOOST_TEST_CASE(&test_empty_string));
|
||||
|
||||
return suite;
|
||||
}
|
||||
Executable
+513
@@ -0,0 +1,513 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2011.
|
||||
//
|
||||
// Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(__INTEL_COMPILER)
|
||||
#pragma warning(disable: 193 383 488 981 1418 1419)
|
||||
#elif defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
|
||||
#endif
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/test/floating_point_comparison.hpp>
|
||||
|
||||
void test_conversion_from_to_float();
|
||||
void test_conversion_from_to_double();
|
||||
void test_conversion_from_to_long_double();
|
||||
|
||||
using namespace boost;
|
||||
|
||||
|
||||
unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
{
|
||||
unit_test_framework::test_suite *suite =
|
||||
BOOST_TEST_SUITE("lexical_cast float types unit test");
|
||||
suite->add(BOOST_TEST_CASE(&test_conversion_from_to_float));
|
||||
suite->add(BOOST_TEST_CASE(&test_conversion_from_to_double));
|
||||
suite->add(BOOST_TEST_CASE(&test_conversion_from_to_long_double));
|
||||
|
||||
return suite;
|
||||
}
|
||||
|
||||
|
||||
// Replace "-,999" with "-999".
|
||||
template<class CharT>
|
||||
std::basic_string<CharT> to_str_gcc_workaround(std::basic_string<CharT> str)
|
||||
{
|
||||
std::locale loc;
|
||||
std::numpunct<CharT> const& np = BOOST_USE_FACET(std::numpunct<CharT>, loc);
|
||||
std::ctype<CharT> const& ct = BOOST_USE_FACET(std::ctype<CharT>, loc);
|
||||
|
||||
if(np.grouping().empty())
|
||||
return str;
|
||||
|
||||
CharT prefix[3] = { ct.widen('-'), np.thousands_sep(), CharT() };
|
||||
|
||||
if(str.find(prefix) != 0)
|
||||
return str;
|
||||
|
||||
prefix[1] = CharT();
|
||||
str.replace(0, 2, prefix);
|
||||
return str;
|
||||
}
|
||||
|
||||
template<class CharT, class T>
|
||||
std::basic_string<CharT> to_str(T t)
|
||||
{
|
||||
std::basic_ostringstream<CharT> o;
|
||||
o << t;
|
||||
return to_str_gcc_workaround(o.str());
|
||||
}
|
||||
|
||||
|
||||
template<class T>
|
||||
void test_conversion_from_to_float_for_locale()
|
||||
{
|
||||
std::locale current_locale;
|
||||
typedef std::numpunct<char> numpunct;
|
||||
numpunct const& np = BOOST_USE_FACET(numpunct, current_locale);
|
||||
if ( !np.grouping().empty() )
|
||||
{
|
||||
BOOST_CHECK_THROW(
|
||||
lexical_cast<T>( std::string("100") + np.thousands_sep() + np.thousands_sep() + "0" )
|
||||
, bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<T>( std::string("100") + np.thousands_sep() ), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<T>( np.thousands_sep() + std::string("100") ), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<T>( std::string("1") + np.thousands_sep() + np.decimal_point() + "e10" ), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<T>( std::string("1e10") + np.thousands_sep() ), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<T>( std::string("1") + np.thousands_sep() + "e10" ), bad_lexical_cast);
|
||||
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
|
||||
#endif
|
||||
// Exception must not be thrown, when we are using no separators at all
|
||||
BOOST_CHECK_CLOSE_FRACTION( lexical_cast<T>("30000"), static_cast<T>(30000), (std::numeric_limits<T>::epsilon()) );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Converts char* [and wchar_t] to float number type and checks, that generated
|
||||
* number is in interval [base_value-epsilon, base_value+epsilon].
|
||||
*/
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
#define CHECK_CLOSE_ABS_DIFF(VAL,PREFIX) \
|
||||
converted_val = lexical_cast<test_t>(#VAL); \
|
||||
BOOST_CHECK_CLOSE_FRACTION( (VAL ## L? VAL ## L : std::numeric_limits<test_t>::epsilon()), \
|
||||
(converted_val ? converted_val : std::numeric_limits<test_t>::epsilon()), \
|
||||
std::numeric_limits<test_t>::epsilon() \
|
||||
); \
|
||||
BOOST_CHECK_EQUAL(converted_val, lexical_cast<test_t>(L## #VAL) );
|
||||
|
||||
#else
|
||||
#define CHECK_CLOSE_ABS_DIFF(VAL,TYPE) \
|
||||
converted_val = lexical_cast<test_t>(#VAL); \
|
||||
BOOST_CHECK_CLOSE_FRACTION( (VAL ## L? VAL ## L : std::numeric_limits<test_t>::epsilon()), \
|
||||
(converted_val ? converted_val : std::numeric_limits<test_t>::epsilon()), \
|
||||
std::numeric_limits<test_t>::epsilon() \
|
||||
);
|
||||
#endif
|
||||
|
||||
template <class TestType>
|
||||
void test_converion_to_float_types()
|
||||
{
|
||||
typedef TestType test_t;
|
||||
test_t converted_val;
|
||||
|
||||
BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>('1'), (std::numeric_limits<test_t>::epsilon()));
|
||||
BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>('0'));
|
||||
|
||||
unsigned char const uc_one = '1';
|
||||
unsigned char const uc_zero ='0';
|
||||
BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>(uc_one), (std::numeric_limits<test_t>::epsilon()));
|
||||
BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>(uc_zero));
|
||||
|
||||
signed char const sc_one = '1';
|
||||
signed char const sc_zero ='0';
|
||||
BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>(sc_one), (std::numeric_limits<test_t>::epsilon()));
|
||||
BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>(sc_zero));
|
||||
|
||||
BOOST_CHECK_CLOSE_FRACTION(1e34L, lexical_cast<test_t>( "10000000000000000000000000000000000"), (std::numeric_limits<test_t>::epsilon()) );
|
||||
|
||||
// VC failes the next test
|
||||
// BOOST_CHECK_CLOSE_FRACTION(1e-35L, lexical_cast<test_t>("0.00000000000000000000000000000000001"), (std::numeric_limits<test_t>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(
|
||||
0.1111111111111111111111111111111111111111111111111111111111111111111111111L
|
||||
, lexical_cast<test_t>("0.1111111111111111111111111111111111111111111111111111111111111111111111111")
|
||||
, (std::numeric_limits<test_t>::epsilon()) );
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1,test_t);
|
||||
BOOST_CHECK_EQUAL(0,lexical_cast<test_t>("0"));
|
||||
CHECK_CLOSE_ABS_DIFF(-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1.0, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0.0, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1.0,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1e1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1.0e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0.0e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1.0e1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1e-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1.0e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0.0e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1.0e-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1E1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1.0E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0.0E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1.0E1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1E-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(1.0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(0.0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-1.0E-1, test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(.0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(.0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-.0E-1, test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10.0, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00.0, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10.0,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10e1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10.0e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00.0e1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10.0e1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10e-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10.0e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00.0e-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10.0e-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10E1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10.0E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00.0E1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10.0E1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10E-1,test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(10.0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(00.0E-1, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10.0E-1, test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(-10101.0E-011, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(-10101093, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(10101093, test_t);
|
||||
|
||||
CHECK_CLOSE_ABS_DIFF(-.34, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(.34, test_t);
|
||||
CHECK_CLOSE_ABS_DIFF(.34e10, test_t);
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("-1.e"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("-1.E"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("1.e"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("1.E"), bad_lexical_cast);
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("1.0E"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("10E"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("10e"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e-"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("1.0E-"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("10E-"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("10e-"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("e1"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("e-1"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("e-"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>(".e"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111ee"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111e-"), bad_lexical_cast);
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("-B"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("0xB"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("0x0"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("--1.0"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e--1"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("1.0.0"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("1e1e1"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e-1e-1"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>(" 1.0"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("1.0 "), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>(""), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("-"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>('\0'), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>('-'), bad_lexical_cast);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_float_typess_for_overflows()
|
||||
{
|
||||
typedef T test_t;
|
||||
test_t minvalue = (std::numeric_limits<test_t>::min)();
|
||||
std::string s_min_value = lexical_cast<std::string>(minvalue);
|
||||
BOOST_CHECK_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(minvalue), (std::numeric_limits<test_t>::epsilon()));
|
||||
BOOST_CHECK_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(s_min_value), (std::numeric_limits<test_t>::epsilon()));
|
||||
|
||||
test_t maxvalue = (std::numeric_limits<test_t>::max)();
|
||||
std::string s_max_value = lexical_cast<std::string>(maxvalue);
|
||||
BOOST_CHECK_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(maxvalue), (std::numeric_limits<test_t>::epsilon()));
|
||||
BOOST_CHECK_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(s_max_value), (std::numeric_limits<test_t>::epsilon()));
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>(s_max_value+"1"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>(s_max_value+"9"), bad_lexical_cast);
|
||||
|
||||
// VC9 can fail the fllowing tests on floats and doubles when using stingstream...
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("1"+s_max_value), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>("9"+s_max_value), bad_lexical_cast);
|
||||
|
||||
if ( is_same<test_t,float>::value )
|
||||
{
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>( (std::numeric_limits<double>::max)() ), bad_lexical_cast);
|
||||
BOOST_CHECK(
|
||||
(std::numeric_limits<double>::min)() - std::numeric_limits<test_t>::epsilon()
|
||||
<= lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
|
||||
&& lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
|
||||
<= (std::numeric_limits<double>::min)() + std::numeric_limits<test_t>::epsilon()
|
||||
);
|
||||
}
|
||||
|
||||
if ( sizeof(test_t) < sizeof(long double) )
|
||||
{
|
||||
BOOST_CHECK_THROW(lexical_cast<test_t>( (std::numeric_limits<long double>::max)() ), bad_lexical_cast);
|
||||
BOOST_CHECK(
|
||||
(std::numeric_limits<long double>::min)() - std::numeric_limits<test_t>::epsilon()
|
||||
<= lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
|
||||
&& lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
|
||||
<= (std::numeric_limits<long double>::min)() + std::numeric_limits<test_t>::epsilon()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#undef CHECK_CLOSE_ABS_DIFF
|
||||
|
||||
#define TEST_TO_FROM_CAST_AROUND_TYPED(VAL,STRING_TYPE) \
|
||||
test_value = VAL + std::numeric_limits<test_t>::epsilon() * i ; \
|
||||
converted_val = lexical_cast<test_t>( lexical_cast<STRING_TYPE>(test_value) ); \
|
||||
BOOST_CHECK_CLOSE_FRACTION( \
|
||||
test_value, \
|
||||
converted_val, \
|
||||
std::numeric_limits<test_t>::epsilon() \
|
||||
);
|
||||
|
||||
/*
|
||||
* For interval [ from_mult*epsilon+VAL, to_mult*epsilon+VAL ], converts float type
|
||||
* numbers to string[wstring] and then back to float type, then compares initial
|
||||
* values and generated.
|
||||
* Step is epsilon
|
||||
*/
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
# define TEST_TO_FROM_CAST_AROUND(VAL) \
|
||||
for(i=from_mult; i<=to_mult; ++i) { \
|
||||
TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::string) \
|
||||
TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::wstring) \
|
||||
}
|
||||
#else
|
||||
# define TEST_TO_FROM_CAST_AROUND(VAL) \
|
||||
for(i=from_mult; i<=to_mult; ++i) { \
|
||||
TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::string) \
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class TestType>
|
||||
void test_converion_from_to_float_types()
|
||||
{
|
||||
typedef TestType test_t;
|
||||
test_t test_value;
|
||||
test_t converted_val;
|
||||
|
||||
int i;
|
||||
int from_mult = -50;
|
||||
int to_mult = 50;
|
||||
|
||||
TEST_TO_FROM_CAST_AROUND( 0.0 );
|
||||
|
||||
long double val1;
|
||||
for(val1 = 1.0e-10L; val1 < 1e11; val1*=10 )
|
||||
TEST_TO_FROM_CAST_AROUND( val1 );
|
||||
|
||||
long double val2;
|
||||
for(val2 = -1.0e-10L; val2 > -1e11; val2*=10 )
|
||||
TEST_TO_FROM_CAST_AROUND( val2 );
|
||||
|
||||
from_mult = -100;
|
||||
to_mult = 0;
|
||||
TEST_TO_FROM_CAST_AROUND( (std::numeric_limits<test_t>::max)() );
|
||||
|
||||
from_mult = 0;
|
||||
to_mult = 100;
|
||||
TEST_TO_FROM_CAST_AROUND( (std::numeric_limits<test_t>::min)() );
|
||||
}
|
||||
|
||||
#undef TEST_TO_FROM_CAST_AROUND
|
||||
#undef TEST_TO_FROM_CAST_AROUND_TYPED
|
||||
|
||||
|
||||
template<class T, class CharT>
|
||||
void test_conversion_from_float_to_char(CharT zero)
|
||||
{
|
||||
BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(0)) == zero + 0);
|
||||
BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(1)) == zero + 1);
|
||||
BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(2)) == zero + 2);
|
||||
BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(3)) == zero + 3);
|
||||
BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(4)) == zero + 4);
|
||||
BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(5)) == zero + 5);
|
||||
BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(6)) == zero + 6);
|
||||
BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(7)) == zero + 7);
|
||||
BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(8)) == zero + 8);
|
||||
BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(9)) == zero + 9);
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
|
||||
|
||||
T t = (std::numeric_limits<T>::max)();
|
||||
BOOST_CHECK_THROW(lexical_cast<CharT>(t), bad_lexical_cast);
|
||||
}
|
||||
|
||||
template<class T, class CharT>
|
||||
void test_conversion_from_char_to_float(CharT zero)
|
||||
{
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 0)), static_cast<T>(0), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 1)), static_cast<T>(1), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 2)), static_cast<T>(2), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 3)), static_cast<T>(3), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 4)), static_cast<T>(4), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 5)), static_cast<T>(5), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 6)), static_cast<T>(6), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 7)), static_cast<T>(7), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 8)), static_cast<T>(8), (std::numeric_limits<T>::epsilon()) );
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 9)), static_cast<T>(9), (std::numeric_limits<T>::epsilon()) );
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero + 10)), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero - 1)), bad_lexical_cast);
|
||||
}
|
||||
|
||||
struct restore_oldloc
|
||||
{
|
||||
std::locale oldloc;
|
||||
~restore_oldloc() { std::locale::global(oldloc); }
|
||||
};
|
||||
|
||||
template<class T>
|
||||
void test_conversion_from_to_float()
|
||||
{ char const zero = '0';
|
||||
signed char const szero = '0';
|
||||
unsigned char const uzero = '0';
|
||||
test_conversion_from_float_to_char<T>(zero);
|
||||
test_conversion_from_char_to_float<T>(zero);
|
||||
test_conversion_from_float_to_char<T>(szero);
|
||||
test_conversion_from_char_to_float<T>(szero);
|
||||
test_conversion_from_float_to_char<T>(uzero);
|
||||
test_conversion_from_char_to_float<T>(uzero);
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
wchar_t const wzero = L'0';
|
||||
test_conversion_from_float_to_char<T>(wzero);
|
||||
test_conversion_from_char_to_float<T>(wzero);
|
||||
#endif
|
||||
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>("+1"), 1, std::numeric_limits<T>::epsilon());
|
||||
BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>("+9"), 9, std::numeric_limits<T>::epsilon());
|
||||
|
||||
BOOST_CHECK_THROW(lexical_cast<T>("++1"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<T>("-+9"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<T>("--1"), bad_lexical_cast);
|
||||
BOOST_CHECK_THROW(lexical_cast<T>("+-9"), bad_lexical_cast);
|
||||
|
||||
test_converion_to_float_types<T>();
|
||||
test_float_typess_for_overflows<T>();
|
||||
test_converion_from_to_float_types<T>();
|
||||
|
||||
|
||||
typedef std::numpunct<char> numpunct;
|
||||
|
||||
restore_oldloc guard;
|
||||
std::locale const& oldloc = guard.oldloc;
|
||||
|
||||
std::string grouping1 = BOOST_USE_FACET(numpunct, oldloc).grouping();
|
||||
std::string grouping2(grouping1);
|
||||
|
||||
test_conversion_from_to_float_for_locale<T>();
|
||||
|
||||
try
|
||||
{
|
||||
std::locale newloc("");
|
||||
std::locale::global(newloc);
|
||||
|
||||
grouping2 = BOOST_USE_FACET(numpunct, newloc).grouping();
|
||||
}
|
||||
catch(std::exception const& ex)
|
||||
{
|
||||
std::string msg("Failed to set system locale: ");
|
||||
msg += ex.what();
|
||||
BOOST_TEST_MESSAGE(msg);
|
||||
}
|
||||
|
||||
if(grouping1 != grouping2)
|
||||
test_conversion_from_to_float_for_locale<T>();
|
||||
|
||||
if(grouping1.empty() && grouping2.empty())
|
||||
BOOST_TEST_MESSAGE("Formatting with thousands_sep has not been tested");
|
||||
}
|
||||
|
||||
|
||||
void test_conversion_from_to_float()
|
||||
{
|
||||
test_conversion_from_to_float<float>();
|
||||
}
|
||||
void test_conversion_from_to_double()
|
||||
{
|
||||
test_conversion_from_to_float<double>();
|
||||
}
|
||||
void test_conversion_from_to_long_double()
|
||||
{
|
||||
test_conversion_from_to_float<long double>();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Executable
+180
@@ -0,0 +1,180 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2011.
|
||||
//
|
||||
// Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(__INTEL_COMPILER)
|
||||
#pragma warning(disable: 193 383 488 981 1418 1419)
|
||||
#elif defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
|
||||
#endif
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
|
||||
#include <boost/math/special_functions/sign.hpp>
|
||||
#include <boost/math/special_functions/fpclassify.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/test/floating_point_comparison.hpp>
|
||||
|
||||
#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
|
||||
#define BOOST_LCAST_NO_WCHAR_T
|
||||
#endif
|
||||
|
||||
using namespace boost;
|
||||
|
||||
template <class T>
|
||||
bool is_pos_inf(T value)
|
||||
{
|
||||
return (boost::math::isinf)(value) && !(boost::math::signbit)(value);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
bool is_neg_inf(T value)
|
||||
{
|
||||
return (boost::math::isinf)(value) && (boost::math::signbit)(value);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
bool is_pos_nan(T value)
|
||||
{
|
||||
return (boost::math::isnan)(value) && !(boost::math::signbit)(value);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
bool is_neg_nan(T value)
|
||||
{
|
||||
/* There is some strange behaviour on Itanium platform with -nan nuber for long double.
|
||||
* It is a IA64 feature, or it is a boost::math feature, not a lexical_cast bug */
|
||||
#if defined(__ia64__) || defined(_M_IA64)
|
||||
return (boost::math::isnan)(value)
|
||||
&& ( boost::is_same<T, long double >::value || (boost::math::signbit)(value) );
|
||||
#else
|
||||
return (boost::math::isnan)(value) && (boost::math::signbit)(value);
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void test_inf_nan_templated()
|
||||
{
|
||||
typedef T test_t;
|
||||
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("inf") ) );
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INF") ) );
|
||||
|
||||
BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-inf") ) );
|
||||
BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INF") ) );
|
||||
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+inf") ) );
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+INF") ) );
|
||||
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("infinity") ) );
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INFINITY") ) );
|
||||
|
||||
BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-infinity") ) );
|
||||
BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INFINITY") ) );
|
||||
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+infinity") ) );
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+INFINITY") ) );
|
||||
|
||||
BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nan") ) );
|
||||
BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NAN") ) );
|
||||
|
||||
BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-nan") ) );
|
||||
BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-NAN") ) );
|
||||
|
||||
BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+nan") ) );
|
||||
BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+NAN") ) );
|
||||
|
||||
BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nan()") ) );
|
||||
BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NAN(some string)") ) );
|
||||
BOOST_CHECK_THROW( lexical_cast<test_t>("NAN(some string"), bad_lexical_cast );
|
||||
|
||||
BOOST_CHECK(lexical_cast<std::string>( (boost::math::changesign)(std::numeric_limits<test_t >::infinity()))
|
||||
== "-inf" );
|
||||
BOOST_CHECK(lexical_cast<std::string>( std::numeric_limits<test_t >::infinity()) == "inf" );
|
||||
BOOST_CHECK(lexical_cast<std::string>( std::numeric_limits<test_t >::quiet_NaN()) == "nan" );
|
||||
#if !defined(__ia64__) && !defined(_M_IA64)
|
||||
BOOST_CHECK(lexical_cast<std::string>(
|
||||
(boost::math::changesign)(std::numeric_limits<test_t >::quiet_NaN()))
|
||||
== "-nan" );
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"inf") ) );
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"INF") ) );
|
||||
|
||||
BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-inf") ) );
|
||||
BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INF") ) );
|
||||
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+inf") ) );
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INF") ) );
|
||||
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"infinity") ) );
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"INFINITY") ) );
|
||||
|
||||
BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-infinity") ) );
|
||||
BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INFINITY") ) );
|
||||
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+infinity") ) );
|
||||
BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INFINITY") ) );
|
||||
|
||||
BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"nan") ) );
|
||||
BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"NAN") ) );
|
||||
|
||||
BOOST_CHECK( is_neg_nan( lexical_cast<test_t>(L"-nan") ) );
|
||||
BOOST_CHECK( is_neg_nan( lexical_cast<test_t>(L"-NAN") ) );
|
||||
|
||||
BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"+nan") ) );
|
||||
BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"+NAN") ) );
|
||||
|
||||
BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"nan()") ) );
|
||||
BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"NAN(some string)") ) );
|
||||
BOOST_CHECK_THROW( lexical_cast<test_t>(L"NAN(some string"), bad_lexical_cast );
|
||||
|
||||
BOOST_CHECK(lexical_cast<std::wstring>( (boost::math::changesign)(std::numeric_limits<test_t >::infinity()))
|
||||
== L"-inf" );
|
||||
BOOST_CHECK(lexical_cast<std::wstring>( std::numeric_limits<test_t >::infinity()) == L"inf" );
|
||||
BOOST_CHECK(lexical_cast<std::wstring>( std::numeric_limits<test_t >::quiet_NaN()) == L"nan" );
|
||||
#if !defined(__ia64__) && !defined(_M_IA64)
|
||||
BOOST_CHECK(lexical_cast<std::wstring>(
|
||||
(boost::math::changesign)(std::numeric_limits<test_t >::quiet_NaN()))
|
||||
== L"-nan" );
|
||||
#endif
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
void test_inf_nan_float()
|
||||
{
|
||||
test_inf_nan_templated<float >();
|
||||
}
|
||||
|
||||
void test_inf_nan_double()
|
||||
{
|
||||
test_inf_nan_templated<double >();
|
||||
}
|
||||
|
||||
void test_inf_nan_long_double()
|
||||
{
|
||||
test_inf_nan_templated<long double >();
|
||||
}
|
||||
|
||||
unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
{
|
||||
unit_test_framework::test_suite *suite =
|
||||
BOOST_TEST_SUITE("lexical_cast inf anf nan parsing unit test");
|
||||
suite->add(BOOST_TEST_CASE(&test_inf_nan_float));
|
||||
suite->add(BOOST_TEST_CASE(&test_inf_nan_double));
|
||||
suite->add(BOOST_TEST_CASE(&test_inf_nan_long_double));
|
||||
|
||||
return suite;
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Alexander Nasonov, 2006.
|
||||
//
|
||||
// Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
//
|
||||
// Test round-tripping conversion FPT -> string -> FPT,
|
||||
// where FPT is Floating Point Type.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(__INTEL_COMPILER)
|
||||
#pragma warning(disable: 193 383 488 981 1418 1419)
|
||||
#elif defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
|
||||
#endif
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace boost;
|
||||
|
||||
void test_round_conversion_float();
|
||||
void test_round_conversion_double();
|
||||
void test_round_conversion_long_double();
|
||||
|
||||
unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
{
|
||||
unit_test_framework::test_suite *suite =
|
||||
BOOST_TEST_SUITE("lexical_cast unit test");
|
||||
suite->add(BOOST_TEST_CASE(&test_round_conversion_float));
|
||||
suite->add(BOOST_TEST_CASE(&test_round_conversion_double));
|
||||
suite->add(BOOST_TEST_CASE(&test_round_conversion_long_double));
|
||||
|
||||
return suite;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
void test_round_conversion()
|
||||
{
|
||||
T epsilon = std::numeric_limits<T>::epsilon();
|
||||
std::string const epsilon_s = boost::lexical_cast<std::string>(epsilon);
|
||||
BOOST_CHECK(epsilon == lexical_cast<T>(epsilon_s));
|
||||
|
||||
T max_ = (std::numeric_limits<T>::max)();
|
||||
std::string const max_s = boost::lexical_cast<std::string>(max_);
|
||||
BOOST_CHECK(max_ == lexical_cast<T>(max_s));
|
||||
|
||||
T min_ = (std::numeric_limits<T>::min)();
|
||||
std::string const min_s = boost::lexical_cast<std::string>(min_);
|
||||
BOOST_CHECK(min_ == lexical_cast<T>(min_s));
|
||||
|
||||
T max_div137 = max_ / 137;
|
||||
std::string max_div137_s = boost::lexical_cast<std::string>(max_div137);
|
||||
BOOST_CHECK(max_div137 == lexical_cast<T>(max_div137_s));
|
||||
|
||||
T epsilon_mult137 = epsilon * 137;
|
||||
std::string epsilon_mult137_s(lexical_cast<std::string>(epsilon_mult137));
|
||||
BOOST_CHECK(epsilon_mult137 == lexical_cast<T>(epsilon_mult137_s));
|
||||
|
||||
}
|
||||
|
||||
// See bug http://tinyurl.com/vhpvo
|
||||
template<class T>
|
||||
void test_msvc_magic_values()
|
||||
{
|
||||
T magic_msvc = 0.00010000433948393407;
|
||||
std::string magic_msvc_s = boost::lexical_cast<std::string>(magic_msvc);
|
||||
BOOST_CHECK(magic_msvc == lexical_cast<T>(magic_msvc_s));
|
||||
}
|
||||
|
||||
void test_round_conversion_float()
|
||||
{
|
||||
test_round_conversion<float>();
|
||||
}
|
||||
|
||||
void test_round_conversion_double()
|
||||
{
|
||||
test_round_conversion<double>();
|
||||
test_msvc_magic_values<double>();
|
||||
}
|
||||
|
||||
void test_round_conversion_long_double()
|
||||
{
|
||||
test_round_conversion<long double>();
|
||||
test_msvc_magic_values<long double>();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Alexander Nasonov, 2007.
|
||||
//
|
||||
// Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
//
|
||||
// Test that Source can be non-copyable.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(__INTEL_COMPILER)
|
||||
#pragma warning(disable: 193 383 488 981 1418 1419)
|
||||
#elif defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
|
||||
#endif
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace boost;
|
||||
|
||||
void test_noncopyable();
|
||||
|
||||
unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
{
|
||||
unit_test_framework::test_suite *suite =
|
||||
BOOST_TEST_SUITE("lexical_cast unit test");
|
||||
suite->add(BOOST_TEST_CASE(&test_noncopyable));
|
||||
|
||||
return suite;
|
||||
}
|
||||
|
||||
class Noncopyable : private boost::noncopyable
|
||||
{
|
||||
public:
|
||||
Noncopyable() {}
|
||||
};
|
||||
|
||||
inline std::ostream &operator<<(std::ostream &out, const Noncopyable&)
|
||||
{
|
||||
return out << "Noncopyable";
|
||||
}
|
||||
|
||||
void test_noncopyable()
|
||||
{
|
||||
Noncopyable x;
|
||||
BOOST_CHECK(boost::lexical_cast<std::string>(x) == "Noncopyable");
|
||||
}
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Alexander Nasonov, 2007.
|
||||
//
|
||||
// Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
//
|
||||
// This tests now must pass on vc8, because lexical_cast
|
||||
// implementation has changed and it does not use stringstream for casts
|
||||
// to integral types
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
#include <string>
|
||||
|
||||
using namespace boost;
|
||||
|
||||
// See also test_conversion_from_string_to_integral(CharT)
|
||||
// in libs/conversion/lexical_cast_test.cpp
|
||||
template<class T, class CharT>
|
||||
void test_too_long_number(CharT zero)
|
||||
{
|
||||
typedef std::numeric_limits<T> limits;
|
||||
|
||||
std::basic_string<CharT> s;
|
||||
|
||||
std::basic_ostringstream<CharT> o;
|
||||
o << (limits::max)() << zero;
|
||||
s = o.str();
|
||||
BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
|
||||
s[s.size()-1] += 9; // '0' -> '9'
|
||||
BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
|
||||
|
||||
if(limits::is_signed)
|
||||
{
|
||||
std::basic_ostringstream<CharT> o;
|
||||
o << (limits::min)() << zero;
|
||||
s = o.str();
|
||||
BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
|
||||
s[s.size()-1] += 9; // '0' -> '9'
|
||||
BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
|
||||
}
|
||||
}
|
||||
|
||||
void test_vc8_bug()
|
||||
{
|
||||
test_too_long_number<boost::intmax_t>('0');
|
||||
test_too_long_number<boost::uintmax_t>('0');
|
||||
#if !defined(BOOST_LCAST_NO_WCHAR_T)
|
||||
test_too_long_number<boost::intmax_t>(L'0');
|
||||
test_too_long_number<boost::uintmax_t>(L'0');
|
||||
#endif
|
||||
}
|
||||
|
||||
unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
{
|
||||
unit_test_framework::test_suite *suite =
|
||||
BOOST_TEST_SUITE("lexical_cast vc8 bug unit test");
|
||||
suite->add(BOOST_TEST_CASE(test_vc8_bug));
|
||||
return suite;
|
||||
}
|
||||
Executable
+56
@@ -0,0 +1,56 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2011.
|
||||
//
|
||||
// Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(__INTEL_COMPILER)
|
||||
#pragma warning(disable: 193 383 488 981 1418 1419)
|
||||
#elif defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
|
||||
#endif
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/test/floating_point_comparison.hpp>
|
||||
|
||||
using namespace boost;
|
||||
|
||||
void test_char_types_conversions()
|
||||
{
|
||||
#ifndef BOOST_LCAST_NO_WCHAR_T
|
||||
const char c_arr[] = "Test array of chars";
|
||||
const unsigned char uc_arr[] = "Test array of chars";
|
||||
const signed char sc_arr[] = "Test array of chars";
|
||||
const wchar_t wc_arr[] =L"Test array of chars";
|
||||
|
||||
// Following tests depend on realization of std::locale
|
||||
// and pass for popular compilers and STL realizations
|
||||
BOOST_CHECK(boost::lexical_cast<wchar_t>(c_arr[0]) == wc_arr[0]);
|
||||
BOOST_CHECK(boost::lexical_cast<std::wstring>(c_arr) == std::wstring(wc_arr));
|
||||
|
||||
BOOST_CHECK(boost::lexical_cast<std::wstring>(sc_arr) == std::wstring(wc_arr) );
|
||||
BOOST_CHECK(boost::lexical_cast<std::wstring>(uc_arr) == std::wstring(wc_arr) );
|
||||
|
||||
BOOST_CHECK_EQUAL(boost::lexical_cast<wchar_t>(uc_arr[0]), wc_arr[0]);
|
||||
BOOST_CHECK_EQUAL(boost::lexical_cast<wchar_t>(sc_arr[0]), wc_arr[0]);
|
||||
#endif
|
||||
BOOST_CHECK(1);
|
||||
}
|
||||
|
||||
unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
{
|
||||
unit_test_framework::test_suite *suite =
|
||||
BOOST_TEST_SUITE("lexical_cast char<->wchar_t unit test");
|
||||
suite->add(BOOST_TEST_CASE(&test_char_types_conversions));
|
||||
|
||||
return suite;
|
||||
}
|
||||
@@ -1,150 +0,0 @@
|
||||
//
|
||||
// Test boost::polymorphic_cast, boost::polymorphic_downcast
|
||||
//
|
||||
// Copyright 1999 Beman Dawes
|
||||
// Copyright 1999 Dave Abrahams
|
||||
// Copyright 2014 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
//
|
||||
// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
|
||||
//
|
||||
|
||||
#define BOOST_ENABLE_ASSERT_HANDLER
|
||||
#include <boost/polymorphic_cast.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <string>
|
||||
|
||||
static bool expect_assertion = false;
|
||||
static int assertion_failed_count = 0;
|
||||
|
||||
// BOOST_ASSERT custom handler
|
||||
void boost::assertion_failed( char const * expr, char const * function, char const * file, long line )
|
||||
{
|
||||
if( expect_assertion )
|
||||
{
|
||||
++assertion_failed_count;
|
||||
}
|
||||
else
|
||||
{
|
||||
BOOST_ERROR( "unexpected assertion" );
|
||||
|
||||
BOOST_LIGHTWEIGHT_TEST_OSTREAM
|
||||
<< file << "(" << line << "): assertion '" << expr << "' failed in function '"
|
||||
<< function << "'" << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
struct Base
|
||||
{
|
||||
virtual ~Base() {}
|
||||
virtual std::string kind() { return "Base"; }
|
||||
};
|
||||
|
||||
struct Base2
|
||||
{
|
||||
virtual ~Base2() {}
|
||||
virtual std::string kind2() { return "Base2"; }
|
||||
};
|
||||
|
||||
struct Derived : public Base, Base2
|
||||
{
|
||||
virtual std::string kind() { return "Derived"; }
|
||||
};
|
||||
|
||||
static void test_polymorphic_cast()
|
||||
{
|
||||
Base * base = new Derived;
|
||||
|
||||
Derived * derived;
|
||||
|
||||
try
|
||||
{
|
||||
derived = boost::polymorphic_cast<Derived*>( base );
|
||||
|
||||
BOOST_TEST( derived != 0 );
|
||||
|
||||
if( derived != 0 )
|
||||
{
|
||||
BOOST_TEST_EQ( derived->kind(), "Derived" );
|
||||
}
|
||||
}
|
||||
catch( std::bad_cast const& )
|
||||
{
|
||||
BOOST_ERROR( "boost::polymorphic_cast<Derived*>( base ) threw std::bad_cast" );
|
||||
}
|
||||
|
||||
Base2 * base2;
|
||||
|
||||
try
|
||||
{
|
||||
base2 = boost::polymorphic_cast<Base2*>( base ); // crosscast
|
||||
|
||||
BOOST_TEST( base2 != 0 );
|
||||
|
||||
if( base2 != 0 )
|
||||
{
|
||||
BOOST_TEST_EQ( base2->kind2(), "Base2" );
|
||||
}
|
||||
}
|
||||
catch( std::bad_cast const& )
|
||||
{
|
||||
BOOST_ERROR( "boost::polymorphic_cast<Base2*>( base ) threw std::bad_cast" );
|
||||
}
|
||||
|
||||
delete base;
|
||||
}
|
||||
|
||||
static void test_polymorphic_downcast()
|
||||
{
|
||||
Base * base = new Derived;
|
||||
|
||||
Derived * derived = boost::polymorphic_downcast<Derived*>( base );
|
||||
|
||||
BOOST_TEST( derived != 0 );
|
||||
|
||||
if( derived != 0 )
|
||||
{
|
||||
BOOST_TEST_EQ( derived->kind(), "Derived" );
|
||||
}
|
||||
|
||||
// polymorphic_downcast can't do crosscasts
|
||||
|
||||
delete base;
|
||||
}
|
||||
|
||||
static void test_polymorphic_cast_fail()
|
||||
{
|
||||
Base * base = new Base;
|
||||
|
||||
BOOST_TEST_THROWS( boost::polymorphic_cast<Derived*>( base ), std::bad_cast );
|
||||
|
||||
delete base;
|
||||
}
|
||||
|
||||
static void test_polymorphic_downcast_fail()
|
||||
{
|
||||
Base * base = new Base;
|
||||
|
||||
int old_count = assertion_failed_count;
|
||||
expect_assertion = true;
|
||||
|
||||
boost::polymorphic_downcast<Derived*>( base ); // should assert
|
||||
|
||||
BOOST_TEST_EQ( assertion_failed_count, old_count + 1 );
|
||||
expect_assertion = false;
|
||||
|
||||
delete base;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_polymorphic_cast();
|
||||
test_polymorphic_downcast();
|
||||
test_polymorphic_cast_fail();
|
||||
test_polymorphic_downcast_fail();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
Reference in New Issue
Block a user