forked from OSchip/llvm-project
65 lines
2.6 KiB
ReStructuredText
65 lines
2.6 KiB
ReStructuredText
.. title:: clang-tidy - cppcoreguidelines-narrowing-conversions
|
||
|
||
cppcoreguidelines-narrowing-conversions
|
||
=======================================
|
||
|
||
Checks for silent narrowing conversions, e.g: ``int i = 0; i += 0.1;``. While
|
||
the issue is obvious in this former example, it might not be so in the
|
||
following: ``void MyClass::f(double d) { int_member_ += d; }``.
|
||
|
||
This rule is part of the "Expressions and statements" profile of the C++ Core
|
||
Guidelines, corresponding to rule ES.46. See
|
||
|
||
https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#es46-avoid-lossy-narrowing-truncating-arithmetic-conversions.
|
||
|
||
We enforce only part of the guideline, more specifically, we flag narrowing conversions from:
|
||
- an integer to a narrower integer (e.g. ``char`` to ``unsigned char``),
|
||
- an integer to a narrower floating-point (e.g. ``uint64_t`` to ``float``),
|
||
- a floating-point to an integer (e.g. ``double`` to ``int``),
|
||
- a floating-point to a narrower floating-point (e.g. ``double`` to ``float``)
|
||
if WarnOnFloatingPointNarrowingConversion Option is set.
|
||
|
||
This check will flag:
|
||
- All narrowing conversions that are not marked by an explicit cast (c-style or
|
||
``static_cast``). For example: ``int i = 0; i += 0.1;``,
|
||
``void f(int); f(0.1);``,
|
||
- All applications of binary operators with a narrowing conversions.
|
||
For example: ``int i; i+= 0.1;``.
|
||
|
||
|
||
Options
|
||
-------
|
||
|
||
.. option:: WarnOnFloatingPointNarrowingConversion
|
||
|
||
When non-zero, the check will warn on narrowing floating point conversion
|
||
(e.g. ``double`` to ``float``). `1` by default.
|
||
|
||
.. option:: PedanticMode
|
||
|
||
When non-zero, the check will warn on assigning a floating point constant
|
||
to an integer value even if the floating point value is exactly
|
||
representable in the destination type (e.g. ``int i = 1.0;``).
|
||
`0` by default.
|
||
|
||
FAQ
|
||
---
|
||
|
||
- What does "narrowing conversion from 'int' to 'float'" mean?
|
||
|
||
An IEEE754 Floating Point number can represent all integer values in the range
|
||
[-2^PrecisionBits, 2^PrecisionBits] where PrecisionBits is the number of bits in
|
||
the mantissa.
|
||
|
||
For ``float`` this would be [-2^23, 2^23], where ``int`` can represent values in
|
||
the range [-2^31, 2^31-1].
|
||
|
||
- What does "implementation-defined" mean?
|
||
|
||
You may have encountered messages like "narrowing conversion from 'unsigned int'
|
||
to signed type 'int' is implementation-defined".
|
||
The C/C++ standard does not mandate two’s complement for signed integers, and so
|
||
the compiler is free to define what the semantics are for converting an unsigned
|
||
integer to signed integer. Clang's implementation uses the two’s complement
|
||
format.
|