boost::algorithm::clamp() in C++ library

Boost.Lexical_Cast in C++

Last Updated : 18 Apr, 2022

Boost.LexicalCast which is defined in the Library "boost/lexical_cast.hpp" provides a cast operator, boost::lexical_cast, that can convert numbers from strings to numeric types like int or double and vice versa. boost::lexical_cast is an alternative to functions like std::stoi(), std::stod(), and std::to_string(), which were added to the standard library in C++11. Now let see the Implementation of this function in a program. Examples:

Conversion
integer -> string
string- > integer
integer -> char
float- > string

Associated exceptions : If a conversion fails, an exception of type bad_lexical_cast, which is derived from bad_cast, is thrown. It throws an exception because the float 52.50 and the string "GeeksforGeeks" cannot be converted to a number of type int.

CPP

// CPP program to illustrate
// Boost.Lexical_Cast in C++
#include "boost/lexical_cast.hpp"
#include <bits/stdc++.h>
using namespace std;
using boost::lexical_cast;
using boost::bad_lexical_cast;
int main() {

  // integer to string conversion
  int s = 23;
  string s1 = lexical_cast<string>(s);
  cout << s1 << endl;

  // integer to char conversion
  array<char, 64> msg = lexical_cast<array<char, 64>>(45);
  cout << msg[0] << msg[1] << endl;

  // string to integer conversion in integer value
  int num = lexical_cast<int>("1234");
  cout << num << endl;

  // bad conversion float to int
  // using try and catch we display the error
  try {
    int num2 = lexical_cast<int>("52.20");
  }

  // To catch exception
  catch (bad_lexical_cast &e) {
    cout << "Exception caught : " << e.what() << endl;
  }

  // bad conversion string to integer character
  // using try and catch we display the error
  try {
    int i = lexical_cast<int>("GeeksforGeeks");
  }

  // catching Exception
  catch (bad_lexical_cast &e) {
    cout << "Exception caught :" << e.what() << endl;
  }

  return 0;
}

Output:-

23
45
1234
Exception caught : bad lexical cast: source type value could not be interpreted as target
Exception caught :bad lexical cast: source type value could not be interpreted as target

Reference :- http://www.boost.org/

boost::algorithm::clamp() in C++ library

ajay0007

Improve

Article Tags :

Practice Tags :

CPP

Similar Reads

Any datatype in C++ boost library

Any datatype is used to store any type of value in a variable. Scripting languages like JavaScript, TypeScript provides any datatype functionality. C++ also provides this functionality but only with the help of boost library. Any type of value can be assigned to a variable by just making its datatyp

static_cast in C++

A Cast operator is a unary operator which forces one data type to be converted into another data type.C++ supports 4 types of casting:Static CastDynamic CastConst CastReinterpret CastThis article focuses on discussing the static_cast in detail.Static CastThis is the simplest type of cast that can be

boost::algorithm::clamp() in C++ library

The clamp() function in C++ boost library is found under the header 'boost/algorithm/clamp.hpp' contains two functions for "clamping" a value between a pair of boundary values. Syntax: const T& clamp ( const T& val, const T& lo, const T& hi ) or const T& clamp ( const T& valu

logical_and in C++

logical_and in C++ is a binary function object class which returns the result of the logical "and" operation between its two arguments (as returned by operator &&). Syntax: template struct logical_and : binary_function { T operator() (const T& a, const T& b) const {return a&b&} }; Pa

C++ boost::dynamic_bitset Class with Examples

The boost has more than 150 libraries in it, where a couple of most frequently used libraries were already included in C++ standard library. The dynamic_bitset is a powerful library used for bit manipulation. The dynamic_bitset class is used to represent a set of bits in either 0(reset) or 1(set) fo

Casting Operators in C++

The casting operators is the modern C++ solution for converting one type of data safely to another type. This process is called typecasting where the type of the data is changed to another type either implicitly (by the compiler) or explicitly (by the programmer).Let's take a look at an example:C++#

logical_or in C++

logical_or in C++ is a binary function object class which returns the result of the logical "or" operation between its two arguments (as returned by operator ||). Syntax: template struct logical_or : binary_function { T operator() (const T& a, const T& b) const {return a||b;} }; Parameters:

Dynamic _Cast in C++

In C++, dynamic_cast is a cast operator that converts data from one type to another type at runtime. It is mainly used in inherited class hierarchies for safely casting the base class pointer or reference to derived class (called downcasting). To work with dynamic_cast, there must be one virtual fun

is_abstract template in C++

The std::is_abstract template of C++ STL is used to check whether the type is a abstract class type or not. It returns a boolean value showing the same. Syntax: template < class T > struct is_abstract; Parameter: This template contains single parameter T (Trait class) to check whether T is a a

std::any Class in C++

any is one of the newest features of C++17 that provides a type-safe container to store single value of any type. In layman's terms, it is a container which allows one to store any value in it without worrying about the type safety. It acts as an extension to C++ by mimicking behaviour similar to an