C++标准模板（STL）- 类型支持 (数值极限，epsilon，round_error，infinity)

最新推荐文章于 2024-04-29 11:56:38 发布
最新推荐文章于 2024-04-29 11:56:38 发布
阅读量504 收藏
点赞数 1
分类专栏： # 数值极限 文章标签： c++ 数值极限 标准库模板 epsilon round_error infinity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40788199/article/details/133830691
版权

数值极限

提供查询所有基础数值类型的性质的接口

定义于头文件 <limits>

template< class T > class numeric_limits;

numeric_limits 类模板提供查询各种算术类型属性的标准化方式（例如 int 类型的最大可能值是 std::numeric_limits<int>::max() ）。
 

返回 1.0 与给定类型的下个可表示值的差

std::numeric_limits<T>::epsilon

static T epsilon() throw();

(C++11 前)

static constexpr T epsilon() noexcept;

(C++11 起)

 返回机器 epsilon ，即 1.0 与浮点类型 T 的下个可表示值的差。它仅若 std::numeric_limits<T>::is_integer == false 才有意义。

返回值

Tstd::numeric_limits<T>::epsilon()
/* non-specialized */T()
boolfalse
char​0​
signed char​0​
unsigned char​0​
wchar_t​0​
char8_t​0​
char16_t​0​
char32_t​0​
short​0​
unsigned short​0​
int​0​
unsigned int​0​
long​0​
unsigned long​0​
long long​0​
unsigned long long​0​
floatFLT_EPSILON
doubleDBL_EPSILON
long doubleLDBL_EPSILON

 调用示例

#include <iostream>
#include <string>
#include <limits>
#include <cstdint>
#include <cfloat>

struct SName
{
};

//偏特化
struct SPartSpec
{
};

namespace std
{
template<>
struct numeric_limits<SPartSpec>
{
    static _GLIBCXX_USE_CONSTEXPR bool is_specialized   = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_signed        = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_integer       = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_exact         = true;
    static _GLIBCXX_USE_CONSTEXPR bool has_infinity     = true;
    static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN    = true;
    static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = true;
    static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm     = denorm_present;
    static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss  = true;
    static _GLIBCXX_USE_CONSTEXPR float_round_style round_style     = round_toward_neg_infinity;
    static _GLIBCXX_USE_CONSTEXPR bool is_iec559        = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_bounded       = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_modulo        = true;
    static _GLIBCXX_USE_CONSTEXPR int  digits           = CHAR_BIT;
    static _GLIBCXX_USE_CONSTEXPR int  digits10         = CHAR_BIT;
    static _GLIBCXX_USE_CONSTEXPR int  max_digits10     = DECIMAL_DIG;
    static _GLIBCXX_USE_CONSTEXPR int  radix            = FLT_RADIX;
    static _GLIBCXX_USE_CONSTEXPR int  min_exponent     = FLT_MIN_EXP;
    static _GLIBCXX_USE_CONSTEXPR int  min_exponent10   = FLT_MIN_10_EXP;
    static _GLIBCXX_USE_CONSTEXPR int  max_exponent     = FLT_MAX_EXP;
    static _GLIBCXX_USE_CONSTEXPR int  max_exponent10   = FLT_MAX_EXP;
    static _GLIBCXX_USE_CONSTEXPR bool traps            = true;
    static _GLIBCXX_USE_CONSTEXPR bool tinyness_before  = true;

    static _GLIBCXX_CONSTEXPR int
    min() _GLIBCXX_USE_NOEXCEPT { return  CHAR_MIN ; }
    static _GLIBCXX_CONSTEXPR int
    lowest() _GLIBCXX_USE_NOEXCEPT { return  CHAR_MIN ; }
    static _GLIBCXX_CONSTEXPR int
    max() _GLIBCXX_USE_NOEXCEPT { return  CHAR_MAX ; }
    static _GLIBCXX_CONSTEXPR int
    epsilon() _GLIBCXX_USE_NOEXCEPT { return  LDBL_EPSILON ; }
};
}

int main()
{
    std::cout << std::boolalpha;
    std::cout << "std::numeric_limits<bool>::epsilon():                 "
              << std::numeric_limits<bool>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<char>::epsilon():                 "
              << std::numeric_limits<char>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<signed char>::epsilon():          "
              << std::numeric_limits<signed char>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<unsigned char>::epsilon():        "
              << std::numeric_limits<unsigned char>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<wchar_t>::epsilon():              "
              << std::numeric_limits<wchar_t>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<char16_t>::epsilon():             "
              << std::numeric_limits<char16_t>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<char32_t>::epsilon():             "
              << std::numeric_limits<char32_t>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<short>::epsilon():                "
              << std::numeric_limits<short>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<unsigned short>::epsilon():       "
              << std::numeric_limits<unsigned short>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<int>::epsilon():                  "
              << std::numeric_limits<int>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<unsigned int>::epsilon():         "
              << std::numeric_limits<unsigned int>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<long>::epsilon():                 "
              << std::numeric_limits<long>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<unsigned long>::epsilon():        "
              << std::numeric_limits<unsigned long>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<long long>::epsilon():            "
              << std::numeric_limits<long long>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<unsigned long long>::epsilon():   "
              << std::numeric_limits<unsigned long long>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<float>::epsilon():                "
              << std::numeric_limits<float>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<double>::epsilon():               "
              << std::numeric_limits<double>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<long double>::epsilon():          "
              << std::numeric_limits<long double>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<std::string>::epsilon():          "
              << std::numeric_limits<std::string>::epsilon() << std::endl;
    //必须偏特化
//    std::cout << "std::numeric_limits<SName>::epsilon():                "
//              << std::numeric_limits<SName>::epsilon() << std::endl;
    std::cout << "std::numeric_limits<SPartSpec>::epsilon():            "
              << std::numeric_limits<SPartSpec>::epsilon() << std::endl;
    return 0;
}

输出

返回给定浮点类型的最大舍入误差

std::numeric_limits<T>::round_error

static T round_error() throw();

(C++11 前)

static constexpr T round_error() noexcept;

(C++11 起)

 返回以 ULP （最后位置单位）表示的最大可能舍入错误，其为 ISO 10967 定义，可以从 0.5 （舍入到最近位）变化到 1.0 （舍入到零或无穷大）。它仅若 std::numeric_limits<T>::is_integer == false 才有意义。

返回值

Tstd::numeric_limits<T>::round_error()
/* non-specialized */T()
boolfalse
char​0​
signed char​0​
unsigned char​0​
wchar_t​0​
char8_t​0​
char16_t​0​
char32_t​0​
short​0​
unsigned short​0​
int​0​
unsigned int​0​
long​0​
unsigned long​0​
long long​0​
unsigned long long​0​
float0.5F
double0.5
long double0.5L

调用示例

#include <iostream>
#include <string>
#include <limits>
#include <cstdint>
#include <cfloat>

struct SName
{
};

//偏特化
struct SPartSpec
{
};

namespace std
{
template<>
struct numeric_limits<SPartSpec>
{
    static _GLIBCXX_USE_CONSTEXPR bool is_specialized   = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_signed        = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_integer       = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_exact         = true;
    static _GLIBCXX_USE_CONSTEXPR bool has_infinity     = true;
    static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN    = true;
    static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = true;
    static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm     = denorm_present;
    static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss  = true;
    static _GLIBCXX_USE_CONSTEXPR float_round_style round_style     = round_toward_neg_infinity;
    static _GLIBCXX_USE_CONSTEXPR bool is_iec559        = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_bounded       = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_modulo        = true;
    static _GLIBCXX_USE_CONSTEXPR int  digits           = CHAR_BIT;
    static _GLIBCXX_USE_CONSTEXPR int  digits10         = CHAR_BIT;
    static _GLIBCXX_USE_CONSTEXPR int  max_digits10     = DECIMAL_DIG;
    static _GLIBCXX_USE_CONSTEXPR int  radix            = FLT_RADIX;
    static _GLIBCXX_USE_CONSTEXPR int  min_exponent     = FLT_MIN_EXP;
    static _GLIBCXX_USE_CONSTEXPR int  min_exponent10   = FLT_MIN_10_EXP;
    static _GLIBCXX_USE_CONSTEXPR int  max_exponent     = FLT_MAX_EXP;
    static _GLIBCXX_USE_CONSTEXPR int  max_exponent10   = FLT_MAX_EXP;
    static _GLIBCXX_USE_CONSTEXPR bool traps            = true;
    static _GLIBCXX_USE_CONSTEXPR bool tinyness_before  = true;

    static _GLIBCXX_CONSTEXPR int
    min() _GLIBCXX_USE_NOEXCEPT { return  CHAR_MIN ; }
    static _GLIBCXX_CONSTEXPR int
    lowest() _GLIBCXX_USE_NOEXCEPT { return  CHAR_MIN ; }
    static _GLIBCXX_CONSTEXPR int
    max() _GLIBCXX_USE_NOEXCEPT { return  CHAR_MAX ; }
    static _GLIBCXX_CONSTEXPR int
    epsilon() _GLIBCXX_USE_NOEXCEPT { return  LDBL_EPSILON ; }
    static _GLIBCXX_CONSTEXPR double
    round_error() _GLIBCXX_USE_NOEXCEPT { return  0.5F ; }
};
}

int main()
{
    std::cout << std::boolalpha;
    std::cout << "std::numeric_limits<bool>::round_error():                 "
              << std::numeric_limits<bool>::round_error() << std::endl;
    std::cout << "std::numeric_limits<char>::round_error():                 "
              << std::numeric_limits<char>::round_error() << std::endl;
    std::cout << "std::numeric_limits<signed char>::round_error():          "
              << std::numeric_limits<signed char>::round_error() << std::endl;
    std::cout << "std::numeric_limits<unsigned char>::round_error():        "
              << std::numeric_limits<unsigned char>::round_error() << std::endl;
    std::cout << "std::numeric_limits<wchar_t>::round_error():              "
              << std::numeric_limits<wchar_t>::round_error() << std::endl;
    std::cout << "std::numeric_limits<char16_t>::round_error():             "
              << std::numeric_limits<char16_t>::round_error() << std::endl;
    std::cout << "std::numeric_limits<char32_t>::round_error():             "
              << std::numeric_limits<char32_t>::round_error() << std::endl;
    std::cout << "std::numeric_limits<short>::round_error():                "
              << std::numeric_limits<short>::round_error() << std::endl;
    std::cout << "std::numeric_limits<unsigned short>::round_error():       "
              << std::numeric_limits<unsigned short>::round_error() << std::endl;
    std::cout << "std::numeric_limits<int>::round_error():                  "
              << std::numeric_limits<int>::round_error() << std::endl;
    std::cout << "std::numeric_limits<unsigned int>::round_error():         "
              << std::numeric_limits<unsigned int>::round_error() << std::endl;
    std::cout << "std::numeric_limits<long>::round_error():                 "
              << std::numeric_limits<long>::round_error() << std::endl;
    std::cout << "std::numeric_limits<unsigned long>::round_error():        "
              << std::numeric_limits<unsigned long>::round_error() << std::endl;
    std::cout << "std::numeric_limits<long long>::round_error():            "
              << std::numeric_limits<long long>::round_error() << std::endl;
    std::cout << "std::numeric_limits<unsigned long long>::round_error():   "
              << std::numeric_limits<unsigned long long>::round_error() << std::endl;
    std::cout << "std::numeric_limits<float>::round_error():                "
              << std::numeric_limits<float>::round_error() << std::endl;
    std::cout << "std::numeric_limits<double>::round_error():               "
              << std::numeric_limits<double>::round_error() << std::endl;
    std::cout << "std::numeric_limits<long double>::round_error():          "
              << std::numeric_limits<long double>::round_error() << std::endl;
    std::cout << "std::numeric_limits<std::string>::round_error():          "
              << std::numeric_limits<std::string>::round_error() << std::endl;
    //必须偏特化
//    std::cout << "std::numeric_limits<SName>::round_error():                "
//              << std::numeric_limits<SName>::round_error() << std::endl;
    std::cout << "std::numeric_limits<SPartSpec>::round_error():            "
              << std::numeric_limits<SPartSpec>::round_error() << std::endl;
    return 0;
}

输出

返回给定类型的正无穷大值

std::numeric_limits<T>::infinity

static T infinity() throw();

(C++11 前)

static constexpr T infinity() noexcept;

(C++11 起)

 返回浮点类型 T 所表示的特殊值“正无穷大”。仅若 std::numeric_limits<T>::has_infinity == true 才有意义。在最常见的浮点数二进制表示 IEEE 754 中，正无穷大是所有指数位为 1 而所有尾数位为 0 的值。

返回值

Tstd::numeric_limits<T>::infinity()
/* non-specialized */T()
boolfalse
char​0​
signed char​0​
unsigned char​0​
wchar_t​0​
char8_t​0​
char16_t​0​
char32_t​0​
short​0​
unsigned short​0​
int​0​
unsigned int​0​
long​0​
unsigned long​0​
long long​0​
unsigned long long​0​
floatHUGE_VALF
doubleHUGE_VAL
long doubleHUGE_VALL

调用示例

#include <iostream>
#include <string>
#include <limits>
#include <cstdint>
#include <cfloat>
#include <cmath>

struct SName
{
};

//偏特化
struct SPartSpec
{
};

namespace std
{
template<>
struct numeric_limits<SPartSpec>
{
    static _GLIBCXX_USE_CONSTEXPR bool is_specialized   = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_signed        = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_integer       = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_exact         = true;
    static _GLIBCXX_USE_CONSTEXPR bool has_infinity     = true;
    static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN    = true;
    static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = true;
    static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm     = denorm_present;
    static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss  = true;
    static _GLIBCXX_USE_CONSTEXPR float_round_style round_style     = round_toward_neg_infinity;
    static _GLIBCXX_USE_CONSTEXPR bool is_iec559        = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_bounded       = true;
    static _GLIBCXX_USE_CONSTEXPR bool is_modulo        = true;
    static _GLIBCXX_USE_CONSTEXPR int  digits           = CHAR_BIT;
    static _GLIBCXX_USE_CONSTEXPR int  digits10         = CHAR_BIT;
    static _GLIBCXX_USE_CONSTEXPR int  max_digits10     = DECIMAL_DIG;
    static _GLIBCXX_USE_CONSTEXPR int  radix            = FLT_RADIX;
    static _GLIBCXX_USE_CONSTEXPR int  min_exponent     = FLT_MIN_EXP;
    static _GLIBCXX_USE_CONSTEXPR int  min_exponent10   = FLT_MIN_10_EXP;
    static _GLIBCXX_USE_CONSTEXPR int  max_exponent     = FLT_MAX_EXP;
    static _GLIBCXX_USE_CONSTEXPR int  max_exponent10   = FLT_MAX_EXP;
    static _GLIBCXX_USE_CONSTEXPR bool traps            = true;
    static _GLIBCXX_USE_CONSTEXPR bool tinyness_before  = true;

    static _GLIBCXX_CONSTEXPR int
    min() _GLIBCXX_USE_NOEXCEPT { return  CHAR_MIN ; }
    static _GLIBCXX_CONSTEXPR int
    lowest() _GLIBCXX_USE_NOEXCEPT { return  CHAR_MIN ; }
    static _GLIBCXX_CONSTEXPR int
    max() _GLIBCXX_USE_NOEXCEPT { return  CHAR_MAX ; }
    static _GLIBCXX_CONSTEXPR int
    epsilon() _GLIBCXX_USE_NOEXCEPT { return  LDBL_EPSILON ; }
    static _GLIBCXX_CONSTEXPR double
    round_error() _GLIBCXX_USE_NOEXCEPT { return  0.5F ; }
    static _GLIBCXX_CONSTEXPR double
    infinity() _GLIBCXX_USE_NOEXCEPT { return  HUGE_VAL ; }
};
}

int main()
{
    std::cout << std::boolalpha;
    std::cout << "std::numeric_limits<bool>::infinity():                 "
              << std::numeric_limits<bool>::infinity() << std::endl;
    std::cout << "std::numeric_limits<char>::infinity():                 "
              << std::numeric_limits<char>::infinity() << std::endl;
    std::cout << "std::numeric_limits<signed char>::infinity():          "
              << std::numeric_limits<signed char>::infinity() << std::endl;
    std::cout << "std::numeric_limits<unsigned char>::infinity():        "
              << std::numeric_limits<unsigned char>::infinity() << std::endl;
    std::cout << "std::numeric_limits<wchar_t>::infinity():              "
              << std::numeric_limits<wchar_t>::infinity() << std::endl;
    std::cout << "std::numeric_limits<char16_t>::infinity():             "
              << std::numeric_limits<char16_t>::infinity() << std::endl;
    std::cout << "std::numeric_limits<char32_t>::infinity():             "
              << std::numeric_limits<char32_t>::infinity() << std::endl;
    std::cout << "std::numeric_limits<short>::infinity():                "
              << std::numeric_limits<short>::infinity() << std::endl;
    std::cout << "std::numeric_limits<unsigned short>::infinity():       "
              << std::numeric_limits<unsigned short>::infinity() << std::endl;
    std::cout << "std::numeric_limits<int>::infinity():                  "
              << std::numeric_limits<int>::infinity() << std::endl;
    std::cout << "std::numeric_limits<unsigned int>::infinity():         "
              << std::numeric_limits<unsigned int>::infinity() << std::endl;
    std::cout << "std::numeric_limits<long>::infinity():                 "
              << std::numeric_limits<long>::infinity() << std::endl;
    std::cout << "std::numeric_limits<unsigned long>::infinity():        "
              << std::numeric_limits<unsigned long>::infinity() << std::endl;
    std::cout << "std::numeric_limits<long long>::infinity():            "
              << std::numeric_limits<long long>::infinity() << std::endl;
    std::cout << "std::numeric_limits<unsigned long long>::infinity():   "
              << std::numeric_limits<unsigned long long>::infinity() << std::endl;
    std::cout << "std::numeric_limits<float>::infinity():                "
              << std::numeric_limits<float>::infinity() << std::endl;
    std::cout << "std::numeric_limits<double>::infinity():               "
              << std::numeric_limits<double>::infinity() << std::endl;
    std::cout << "std::numeric_limits<long double>::infinity():          "
              << std::numeric_limits<long double>::infinity() << std::endl;
    std::cout << "std::numeric_limits<std::string>::infinity():          "
              << std::numeric_limits<std::string>::infinity() << std::endl;
    //必须偏特化
//    std::cout << "std::numeric_limits<SName>::infinity():                "
//              << std::numeric_limits<SName>::infinity() << std::endl;
    std::cout << "std::numeric_limits<SPartSpec>::infinity():            "
              << std::numeric_limits<SPartSpec>::infinity() << std::endl;
    return 0;
}

输出

繁星璀璨G
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
STL.rar_C++ STL_STL_c++ 模板_离线stl库
09-19
c++的标准模板STL操作，对初学者很有用，帮助更快入们
C++/C++11中std::numeric_limits的使用
热门推荐
网络资源是无限的
09-10 7万+
C++/C++11中std::numeric_limits的使用
STL.rar_C++ STL_FSET-885_STL_stl源码_visual c
09-24
STL源码，所有STL源码程序都在眼下，希望你能学会
STL-map.rar_C++ map_C++map_map stl_stl map
09-22
STL中map用法详解 非常详细，有说明和可以编译的例子
C++ STL标准模板库-优秀的C++标准库
06-10
STL是Standard Template Library的简称，中文名标准模板库，是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室开发的 ，是一个具有工业强度的，高效的C++库，STL早已是ANSI/ISO C++标准中的一部分。STL库由于其对跨平台，对标准C++的支持，开源，高效等优点，如今已经被广泛运用于企业级开发。
c++之关于"epsilon"
weixin_30595035的博客
11-10 2779
关于"epsilon" DBL_EPSILON和 FLT_EPSILON主要用于单精度和双精度的比较 #include <cfloat> double a = 0.5; if (a == 0.5) // true { // do something } double b = sin(M_PI / 6); if (b == 0.5) //false { // do some...
std::numeric_limits＜T＞::epsilon
Jasmine-Lily的博客
04-03 373
std::numeric_limits::epsilon
C++数值极限numeric_limits
人无远虑，必有近忧
07-19 1538
一般来说，数值类型的极值是一个与平台相关的特性。C++标准程序库通过template numeric_limits提供这些极值，取代传统C语言所采用的预处理常数。你仍然可以使用后者，其中整数常数定义于和，浮点常数定义于和，新的极值概念有两个优点，一是提供了更好的类型安全性，二是程序员可借此写出一些template以核定这些极值。 3. 示例 输出 参考文献 http://www.cplusplus.com/refere
浮点数计算务必考虑浮点表示误差并使用epsilon
weixin_42325834的博客
06-04 1995
对于浮点数的计算非常容易产生懒惰的想法而试图忽视掉浮点表示的缺陷。最简单的例子是浮点表示某些数值会有误差，这个时候必须考虑使用epsilon。比如我要比较abs(a/b - c/d)的最小值，如果数值一样就取字典最小序。如下版本是有问题的：double ans = abs(elements[v[0]] * 1.0 / elements[v[1]] - elements[v[2]] * 1.0 / ...
《C++语言 - 标准模板库STL》_标准模板库_C++_C++STL_
09-29
c++入门资料
numeric_limits<double>::max ()
zhangfenger的博客
12-27 5021
std::numeric_limits&lt;double&gt;::max () 返回编译器允许的 double 型数 最大值。 std::numeric_limits&lt;int&gt;::max () 返回 编译器允许的 int 型数 最大值。 使用时需包含头文件 #include &lt;limits&gt;...
关于浮点数的EPSILON
norman_irsa的博客
06-09 2万+
如何获取EPSILON的值 在C语言中，float和double的EPSILON值在float.h头文件中以宏的方式给出，分别是 FLT_EPSILON DBL_EPSILON 在C++中，则可以numeric_limits模板类的epsilon方法获取到，分别是 std::numeric_limits<float>::epsilon() std::numeric_lim...
C++一些小知识点
qq_34122731的博客
01-24 324
1.cout.precision(n);保留n为有效位数，并且有自动舍弃多余的0的功能， 在 iostream中 2.cout.setf(ios::fixed); 十进制显示，而不用科学计数法，不过会把没用的0全 显示出来，很多余的一个功能 3. cout &amp;lt;&amp;lt;setprecision(3) &amp;lt;&amp;lt;x &amp;lt;&amp;lt;endl；显示3位小数 ...
c++ double float 相等性判断
Sweet_Oranges的专栏
09-16 2433
起因 在c++开发中，double或者float类型判断相等性不能简单的用等于符号进行，一般会采用如下方式进行判断 static inline bool DoubleEqual(double a, double b) { return fabs(a - b) < std::numeric_limits<double>::epsilon(); } 为了验证这个说法，我在机器上写了如下一段代码， 结果竟然没有一次输出，貌似可以直接比较 double a = 0, b =
【C++第三阶段】list容器&排序
最新发布
还有很多需要学习，现在还很菜
04-29 603
以下内容仅为当前认识，可能有不足之处，欢迎讨论！
C 练习实例36 - 求100之内的素数
2401_82561004的博客
04-27 982
质数（prime number）又称素数，有无限个。一个大于1的自然数，除了1和它本身外，不能被其他自然数整除。// Copyright © 2013年 编程字典. All rights reserved.求100之内的素数。
C++ Primer (第五版）第八章习题部分答案
weixin_48467622的博客
04-27 1016
C++ Primer (第五版）第八章习题部分答案
手搓顺序表（C语言）
m0_62646213的博客
04-23 731
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
C++ STL标准模板库
09-17
C++ STL（Standard Template Library），中文名为标准模板库，是一个具有工业强度的，高效的C++库。STL提供了丰富的数据结构和算法，包括容器（Containers）、迭代器（Iterators）、算法（Algorithms）和函数对象（Functors）。通过使用STL，开发人员可以更加方便地进行数据处理、操作和算法实现。 STL的组件包括： 1. 容器（Containers）：提供了各种常用数据结构，如向量（vector）、链表（list）、集合（set）、映射（map）等，可以方便地存储和操作数据。 2. 迭代器（Iterators）：用于遍历容器的元素，提供了统一的接口，使得算法可以独立于容器进行操作。 3. 算法（Algorithms）：包括了各种常用的算法，如排序、查找、复制、删除等，可以对容器中的元素进行各种操作。 4. 函数对象（Functors）：可以像函数一样调用的对象，用于在算法中实现自定义的操作。 STL的设计目标是提供一组通用的工具，以便开发人员可以更加高效地进行C++程序设计。通过使用STL，开发人员可以节省大量的时间和精力，并提高程序的可重用性和可维护性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值