Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::numeric_limits<T>::is_modulo

      From cppreference.com
      <cpp‎ |types‎ |numeric limits
       
       
      Utilities library
       
       
      std::numeric_limits
      Static constants
      numeric_limits::is_modulo
      Static member functions
      Helper types
       
      staticconstbool is_modulo;
      (until C++11)
      staticconstexprbool is_modulo;
      (since C++11)

      The value ofstd::numeric_limits<T>::is_modulo istrue for all arithmetic typesT that handle overflows with modulo arithmetic, that is, if the result of addition, subtraction, multiplication, or division of this type would fall outside the range[min()max()], the value returned by such operation differs from the expected value by a multiple ofmax()- min()+1.

      is_modulo isfalse for signed integer types, unless the implementation defines signed integer overflow to wrap.

      Contents

      [edit]Standard specializations

      T value ofstd::numeric_limits<T>::is_modulo
      /* non-specialized */false
      boolfalse
      char implementation-defined
      signedchar implementation-defined
      unsignedchartrue
      wchar_t implementation-defined
      char8_t(since C++20)true
      char16_t(since C++11)true
      char32_t(since C++11)true
      short implementation-defined
      unsignedshorttrue
      int implementation-defined
      unsignedinttrue
      long implementation-defined
      unsignedlongtrue
      longlong(C++11) implementation-defined
      unsignedlonglong(C++11)true
      floatfalse
      doublefalse
      longdoublefalse

      [edit]Notes

      The standard said "On most machines, this istrue for signed integers." before the resolution ofLWG issue 2422. SeeGCC PR 22200 for a related discussion.

      [edit]Example

      Demonstrates the behavior of modulo types:

      Run this code
      #include <iostream>#include <type_traits>#include <limits> template<class T>typenamestd::enable_if<std::numeric_limits<T>::is_modulo>::type    check_overflow(){std::cout<<"max value is "<<std::numeric_limits<T>::max()<<'\n'<<"min value is "<<std::numeric_limits<T>::min()<<'\n'<<"max value + 1 is "<<std::numeric_limits<T>::max()+1<<'\n';} int main(){    check_overflow<int>();std::cout<<'\n';    check_overflow<unsignedlong>();//  check_overflow<float>(); // compile-time error, not a modulo type}

      Possible output:

      max value is 2147483647min value is -2147483648max value + 1 is -2147483648 max value is 18446744073709551615min value is 0max value + 1 is 0

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      LWG 612C++98the definition of "handle overflows
      with modulo arithmetic" was poor[1]
      provided a
      better definition
      LWG 2422C++98is_modulo was required to betrue for
      signed integer types on most machines
      required to befalse for signed integer types
      unless signed integer overflow is defined to wrap
      1. The definition is "adding two positive numbers can have a result that wraps around to a third number that is less". It has the following problems:
        • It does not define the wrapped value.
        • It does not state whether result is repeatable.
        • It does not require that doing addition, subtraction and other operations on all values have defined behavior.

      [edit]See also

      [static]
      identifies integer types
      (public static member constant)[edit]
      [static]
      identifies the IEC 559/IEEE 754 floating-point types
      (public static member constant)[edit]
      [static]
      identifies exact types
      (public static member constant)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/types/numeric_limits/is_modulo&oldid=148715"

      [8]ページ先頭

      ©2009-2025 Movatter.jp