C++标准模板（STL）- 类型支持 (数值极限，quiet_NaN，signaling_NaN，denorm_min)

news2025/1/12 20:39:43

数值极限

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


定义于头文件 <limits>

template< class T > class numeric_limits;

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

返回给定浮点类型的安静 NaN 值

std::numeric_limits<T>::quiet_NaN

static T quiet_NaN() throw();

(C++11 前)

static constexpr T quiet_NaN() noexcept;

(C++11 起)

返回特殊值“安静的非数”，以浮点类型 T 表示。仅若 std::numeric_limits<T>::has_quiet_NaN == true 才有意义。在最常见的浮点数二进制表示 IEEE 754 中，任何所有指数位均为 1 且至少有一位尾数位为 1 的值表示 NaN 。何种尾数值表示安静或发信的 NaN ，及符号位是否有意义，是实现定义的。 

返回值

Tstd::numeric_limits<T>::quiet_NaN()
/* 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​
floatNAN 或另一实现定义的 NaN
double实现定义
long double实现定义

注意

NaN 与自身决不比较相等。复制 NaN 可能不保留其位表示。

调用示例

#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 ; }
    static _GLIBCXX_CONSTEXPR double
    quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return  NAN ; }
};
}

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

输出

返回给定浮点类型的发信的 NaN

std::numeric_limits<T>::signaling_NaN

static T signaling_NaN() throw();

(C++11 前)

static constexpr T signaling_NaN() noexcept;

(C++11 起)

 返回特殊值“发信的非数”，以浮点类型 T 表示。仅若 std::numeric_limits<T>::has_signaling_NaN == true 才有意义。在最常见的浮点数二进制表示 IEEE 754 中，任何所有指数位均为 1 且至少有一位尾数位为 1 的值表示 NaN 。何种尾数位的值表示安静或发信的 NaN ，及符号位是否有意义，是实现定义的。

返回值

Tstd::numeric_limits<T>::signaling_NaN()
/* 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​
float实现定义
double实现定义
long double实现定义

调用示例

#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 ; }
    static _GLIBCXX_CONSTEXPR double
    quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return  NAN ; }
    static _GLIBCXX_CONSTEXPR double
    signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return  NAN ; }
};
}

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

输出

返回给定浮点类型的最小正非正规值

std::numeric_limits<T>::denorm_min

static T denorm_min() throw();

(C++11 前)

static constexpr T denorm_min() noexcept;

(C++11 起)

 若 std::numeric_limits<T>::has_denorm != std::denorm_absent 则返回 T 类型的最小正非正规值，否则返回 std::numeric_limits<T>::min() 。仅对浮点类型有意义。

返回值

Tstd::numeric_limits<T>::denorm_min()
/* 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​
float若 std::numeric_limits<float>::is_iec559 == true 则为 2-149
double若 std::numeric_limits<float>::is_iec559 == true 则为 2-1074
long double/* 实现定义 */

调用示例

#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 ; }
    static _GLIBCXX_CONSTEXPR double
    quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return  NAN ; }
    static _GLIBCXX_CONSTEXPR double
    signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return  NAN ; }
    static _GLIBCXX_CONSTEXPR double
    denorm_min() _GLIBCXX_USE_NOEXCEPT { return  NAN ; }
};
}

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

输出

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1108767.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

AST实战|比较大的混淆文件(超过10M)怎么还原

AST实战|比较大的混淆文件(超过10M)怎么还原

关注它&#xff0c;不迷路。 本文章中所有内容仅供学习交流&#xff0c;不可用于任何商业用途和非法用途&#xff0c;否则后果自负&#xff0c;如有侵权&#xff0c;请联系作者立即删除&#xff01; 1. 需求 目前&#xff0c;我接触到的混淆js文件大小刷新了新记录&…
阅读更多...
在 Visual Studio Code (VS Code) 中设置

在 Visual Studio Code (VS Code) 中设置

在 Visual Studio Code (VS Code) 中设置代理服务器的详细教程如下&#xff1a; 打开 Visual Studio Code。 在顶部菜单栏中&#xff0c;点击 "File"&#xff08;文件&#xff09; > "Preferences"&#xff08;首选项&#xff09; > "Settings…
阅读更多...
成为吃鸡战场绝对王者，掌握顶级作战干货！

成为吃鸡战场绝对王者，掌握顶级作战干货！

在绝地求生的战场上&#xff0c;只有强者才能生存&#xff01;作为吃鸡行家&#xff0c;吃鸡将在这里为您带来与众不同的游戏技巧和干货&#xff0c;助您成为绝对的战场王者&#xff01; 首先&#xff0c;让我们来介绍几个实用的吃鸡作图工具。我们推荐了几款实用的绘图软件和工…
阅读更多...
springboot项目东方通TongWeb改造以及部署

springboot项目东方通TongWeb改造以及部署

SpringBoot东方通TongWeb改造以及部署 文章目录 SpringBoot东方通TongWeb改造以及部署1、替换springboot中的tomcat为 (东方通)tongweb&#xff0c;打包1.1 排除springboot中内置的tomcat依赖&#xff0c;设置打包方式为war包1.2 修改配置文件的配置1.2.1查看端口是否被占用1.2…
阅读更多...
轮转数组[中等]

轮转数组[中等]

优质博文&#xff1a;IT-BLOG-CN 一、题目 给定一个整数数组nums&#xff0c;将数组中的元素向右轮转k个位置&#xff0c;其中k是非负数。 示例 1: 输入: nums [1,2,3,4,5,6,7], k 3 输出: [5,6,7,1,2,3,4] 解释: 向右轮转 1 步: [7,1,2,3,4,5,6] 向右轮转 2 步: [6,7,1,2,…
阅读更多...
VMware安装银河麒麟高级服务器操作系统V10

VMware安装银河麒麟高级服务器操作系统V10

目标 VMware安装银河麒麟高级服务器操作系统V10背景介绍环境准备安装步骤配置VM虚拟机系统安装 VMware安装银河麒麟高级服务器操作系统V10 背景介绍 近期&#xff0c;随着国产信创的持续发热和大众关注度的上升&#xff0c;我们公司决定与时俱进&#xff0c;针对国产技术趋势…
阅读更多...
【使用OpenCV进行目标分割与计数的代码实例详解】

【使用OpenCV进行目标分割与计数的代码实例详解】

文章目录 概要实例一&#xff1a;硬币分割计数实例二&#xff1a;玉米粒分割计数 概要 在当今数字图像处理领域&#xff0c;图像分割技术是一项至关重要的任务。图像分割旨在将图像中的不同目标或区域准确地分开&#xff0c;为计算机视觉、图像识别和机器学习等领域提供了坚实…
阅读更多...
javascript/python 笔记： folium feature group自动切换

javascript/python 笔记： folium feature group自动切换

1 python部分 python部分只能是静态的结果 1.1 导入库 import folium import math 1.2 数据 cell_lst表示基站位置&#xff0c;location_lst表示 用户实际位置&#xff08;均为伪数据&#xff09; cell_lst[[1.341505, 103.682498],[1.342751, 103.679604],[1.341505, 10…
阅读更多...
【微信小程序】自定义组件布局会议OA其他页面（附源码）

【微信小程序】自定义组件布局会议OA其他页面（附源码）

&#x1f389;&#x1f389;欢迎来到我的CSDN主页&#xff01;&#x1f389;&#x1f389; &#x1f3c5;我是Java方文山&#xff0c;一个在CSDN分享笔记的博主。&#x1f4da;&#x1f4da; &#x1f31f;推荐给大家我的专栏《微信小程序开发实战》。&#x1f3af;&#x1f3a…
阅读更多...
如何为 Elasticsearch 创建自定义连接器

如何为 Elasticsearch 创建自定义连接器

了解如何为 Elasticsearch 创建自定义连接器以简化数据摄取过程。 作者&#xff1a;JEDR BLASZYK Elasticsearch 拥有一个摄取工具库&#xff0c;可以从多个来源获取数据。 但是&#xff0c;有时你的数据源可能与 Elastic 现有的提取工具不兼容。 在这种情况下&#xff0c;你可…
阅读更多...
推荐 3 个国外的自由职业者/兼职网站，大家有空可以去淘淘金

推荐 3 个国外的自由职业者/兼职网站，大家有空可以去淘淘金

推荐 3 个国外的自由职业者/兼职网站&#xff0c;大家有空可以去淘淘金 1. Upwork 这个是全球最大的外包网站之一,很多知名公司都会在这里找外包员工 upwork.com 2. fiverr.com 这个平台也是侧重于技能变现&#xff0c;除了专业的职业技能&#xff0c;还有很多稀奇古怪的…
阅读更多...
SpringCloud之Ribbon负载均衡解读

SpringCloud之Ribbon负载均衡解读

目录 基本介绍 概述 LoadBalanced理解 简单源码解读 1&#xff09;LoadBalancerIntercepor 2&#xff09;LoadBalancerClient 3&#xff09;负载均衡策略IRule 4&#xff09;总结 负载均衡策略 负载均衡策略 自定义负载均衡策略 基本介绍 概述 Ribbon是Netflix发布…
阅读更多...
Nginx集群负载均衡配置完整流程

Nginx集群负载均衡配置完整流程

今天&#xff0c;良哥带你来做一个nginx集群的负载均衡配置的完整流程。 一、准备工作 本次搭建的操作系统环境是win11&#xff0c;linux可配置类同。 1&#xff09;首先&#xff0c;下载nginx。 下载地址为&#xff1a;http://nginx.org/en/download.html 良哥下载的是&am…
阅读更多...
浅谈余压监控系统在住宅小区的应用方案

浅谈余压监控系统在住宅小区的应用方案

【摘要】&#xff1a; 本文分析了火灾发生时人员伤亡的主要原因——烟雾&#xff0c;并针对该原因提供切实可靠的系统应用解决方案&#xff0c;并通过具体案例&#xff0c;从设计依据、产品选型、系统组网、现场安装等方式介绍余压监控系统&#xff0c;希望可以在火灾发生时较大…
阅读更多...
如何使用前端绘图库（D3.js、Chart.js等）？

如何使用前端绘图库（D3.js、Chart.js等）？

聚沙成塔每天进步一点点 ⭐ 专栏简介 前端入门之旅&#xff1a;探索Web开发的奇妙世界 欢迎来到前端入门之旅&#xff01;感兴趣的可以订阅本专栏哦&#xff01;这个专栏是为那些对Web开发感兴趣、刚刚踏入前端领域的朋友们量身打造的。无论你是完全的新手还是有一些基础的开发…
阅读更多...
紫光同创FPGA实现PCIE测速试验，提供PDS工程和Linux QT上位机源码和技术支持

紫光同创FPGA实现PCIE测速试验，提供PDS工程和Linux QT上位机源码和技术支持

目录 1、前言免责声明 2、我这里已有的 GT 高速接口解决方案3、设计思路框架PCIE硬件设计PCIE IP核添加和配置驱动文件和驱动安装QT上位机和源码 4、PDS工程详解5、上板调试验证并演示6、福利&#xff1a;工程代码的获取 紫光同创FPGA实现PCIE测速试验&#xff0c;提供PDS工程和…
阅读更多...
spring 提前编译：AOT

spring 提前编译：AOT

文章目录 AOT概述GraalvmNative Image演示Native Image构建过程GraalVM安装&#xff08;1&#xff09;下载GraalVM 安装C的编译环境 Native Image构建 AOT概述 JIT与AOT的区别 JIT和AOT 这个名词是指两种不同的编译方式&#xff0c;这两种编译方式的主要区别在于是否在“运行时…
阅读更多...
vue源码笔记之——响应系统

vue源码笔记之——响应系统

vue是一种声明式范式编程&#xff0c;使用vue者只需要告诉其想要什么结果&#xff0c;无需关心具体实现&#xff08;vue内部做了&#xff0c;底层是利用命令式范式&#xff09; 1. reactive为什么只能操作对象&#xff0c;对于基本数据类型&#xff0c;需要用ref&#xff1f; …
阅读更多...
Nginx 代理

Nginx 代理

目录 正向代理 反向代理 负载均衡 负载均衡的工作原理 优势和好处 算法和策略 应用领域 Nginx 的反向代理 应用场景 在网络通信中&#xff0c;代理服务器扮演着重要的角色&#xff0c;其中正向代理和反向代理是两种常见的代理服务器模式。它们在网络安全、性能优化和…
阅读更多...
vue3后台管理系统之pinia及持久化集成使用

vue3后台管理系统之pinia及持久化集成使用

安装依赖 pnpm i pinia 在src目录下创建store 创建大仓库 //仓库大仓库 import { createPinia } from pinia //创建大仓库 const pinia createPinia() //对外暴露&#xff1a;入口文件需要安装仓库 export default pinia 全局注册pinia 配置用户仓库pinia管理数据 // 创建用…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023