FBB::LDC - Converts (large) digital values to characters
#include <bobcat/LDC>
Linking option: -lbobcat
Objects of the class LDC (Large Digital Converter) convert
(large) digital values (like values handled by the class BigInt (cf.
bigint(3bobcat))) to character representations using radices from 2
through 36. For radices larger than 10 letters are used, using a
through z to represent the (decimal) values 10 through 36. When
specifying radices outside of this range an exception is thrown.
Alternatively, the digits of the converted number can be provided
in a std::string argument, where the string’s first character
(at index 0) is used for value 0, the next character for value 1, etc.,
until the string’s last character. In that case the string’s
length defines the number system that is used for converting the (large)
digital value. Usually the first 10 characters will be
"0123456789", but LDC doesn’t enforce that. Instead,
any series of characters can be specified, in which case the character at
index idx is used to represent value idx in the converted
value string. E.g., when specifying "abcdefghij" the
hexadecimal value "deadbeef" is converted to
"dhdfjciffj" instead of "3735928559",
which is the normally used decimal digit representation. Digit strings must
at least contain two characters or an exception is thrown.
FBB
All constructors, members, operators and manipulators, mentioned in this
man-page, are defined in the namespace FBB.
- o
- LDC():
The default constructor initializes its value to 0;
- o
- LDC(std::string const &hexNr, size_t radix = 10):
The bytes of the string hexNr contains the character representation
of a hexadecimal value, which is converted to its equivalent
representation using the radix number system. The string
hexNr should not begin with 0x, but its first character
should be the value’s most significant digit. E.g., LDC ldc{
"12345" } is converted to decimal 74565 (in this example
"12345" is first converted to a std::string, which
is then passed on to ldc’s constructor). hexNr may
not be empty or an exception is thrown;
- o
- LDC(std::string const &hexNr, std::string const &digits):
Same as the previous constructor, but the number system is inferred from
digits’s length, using its first character to represent
value 0, and its last character to represent the final digit of the
inferred number system;
- o
- LDC(size_t nBytes, char const *bytes, size_t radix = 10):
The bytes of the string bytes contains the character representation
of a hexadecimal value, which is converted to its equivalent
representation using radix. The string bytes should not
begin with 0x, but its first character should be the value’s
most significant digit. E.g., LDC{ 5, "12345" } is
converted to decimal 74565. nBytes must be at least 1 or an
exception is thrown;
- o
- LDC(size_t nBytes, char const *bytes, std::string const
&digits):
Same as the previous constructor, but the number system and the digit
characters are inferred from digits;
- o
- LDC(BigInt const &bigInt, size_t radix = 10):
BigInt’s value is converted to its equivalent representation
using radix;
- o
- LDC(BigInt const &bigInt, std::string const &digits):
Same as the previous constructor, but the number system and the digit
characters are inferred from digits.
Copy and move constructors (and assignment operators) are
available.
In addition to the standard copy- and move-assignment operators
the following operators are available:
- o
- LDC &operator=(std::string const &hexNr):
The operator’s rhs is the character representation of a hexadecimal
number, which is assigned to the LDC object. The object converts
hexNr to its decimal representation (see also the members
set, below).
Example:
LDC ldc; // initialized with some value
ldc = "12345"; // assign a new value
cout << ldc << ’\n’ // displays 74655
The rhs value may not be empty or an exception is thrown;
- o
- std::string operator()(size_t power, char sep =
’\’’) const:
The converted value is returned using separator sep before each
multiple of power digits. E.g., when ldc contains the
converted value 3735928559 then ldc(3) returns the string
3.735.928.559.
- o
- std::ostream &operator<<(std::ostream &out, LDC const
&ldc):
The insertion operator inserts the converted value into out,
returning out.
- o
- void set(std::string const &hexNr, size_t radix = 10):
The LDC object’s converted value is set to the hexadecimal
value hexNr, converted to number system radix. hexNr
may not be empty or an exception is thrown ;
- o
- void set(std::string const &hexNr, std::string const
&digits):
Same as the previous member, but converting hexNr to the number
system and number characters defined by digits;
- o
- void set(size_t nBytes, char const *bytes, size_t radix = 10):
The LDC object’s converted value is set to the hexadecimal
value stored in the nBytes bytes of bytes, converted to
number system radix. nBytes must be at least 1 or an
exception is thrown;
- o
- void set(size_t nBytes, char const *bytes, std::string const
&digits):
Same as the previous member, but converting bytes to the number
system and number characters defined by digits;
- o
- std::string const &str() const:
The LDC object’s converted value is returned;
- o
- void swap(LDC &other):
The other LDC object and the current LDC object are swapped.
#include <iostream>
#include <bobcat/ldc>
using namespace std;
using namespace FBB;
int main(int argc, char **argv)
{
string value = "1122334455667788aabbcc";
size_t radix = 10;
LDC digits{ value, "0123456789ABCDEF" };
LDC ldc{ value, radix };
cout << "radix = " << radix << "\n"
"value = " << value << "\n"
"digits: " << digits << "\n"
" LDC: " << ldc << "\n"
" " << ldc(3, ’.’) << ’\n’;
}
// shows:
// radix = 10
// value = 1122334455667788aabbcc
// digits: 1122334455667788AABBCC
// LDC: 20713245101768454273940428
// 20.713.245.101.768.454.273.940.428
bobcat/ldc - defines the class interface
- o
- https://fbb-git.gitlab.io/bobcat/: gitlab project page;
- o
- bobcat_6.02.02-x.dsc: detached signature;
- o
- bobcat_6.02.02-x.tar.gz: source archive;
- o
- bobcat_6.02.02-x_i386.changes: change log;
- o
- libbobcat1_6.02.02-x_*.deb: debian package containing the
libraries;
- o
- libbobcat1-dev_6.02.02-x_*.deb: debian package containing the
libraries, headers and manual pages;
Bobcat is an acronym of `Brokken’s Own Base Classes And
Templates’.
This is free software, distributed under the terms of the GNU
General Public License (GPL).
Frank B. Brokken (f.b.brokken@rug.nl).