integer-promotion

common_type<long, unsigned long>::type is unsigned long because concerning the operands after integral promotion the standard says... [...] if the operand that has unsigned integer type has rank greater than or equal to the rank of the type of the other operand, the operand with signed integer type shall be converted to the type of the operand with unsigned integer type Not to call the integral promotion system buggy, but it seems like if there is a bigger signed integer type which can can represent the range of both signed and unsigned operands it should be used. I know some platforms might

What is the type of the result of a multiplication of two chars in C/C++? unsigned char a = 70; unsigned char b = 58; cout << a*b << endl; // prints 4060, means no overflow cout << (unsigned int)(unsigned char)(a*b) << endl; // prints 220, means overflow I expect the result of multiplying two number of type T (e.g., char, short, int) becomes T. It seems it is int for char because sizeof(a*b) is 4. I wrote a simple function to check the size of the result of the multiplication: template<class T> void print_sizeof_mult(){ T a; T b; cout << sizeof(a*b) << endl; } print_sizeof_mult<char>() , print

I need to eliminate gcc -Wconversion warnings. For example typedef unsigned short uint16_t; uint16_t a = 1; uint16_t b = 2; b += a; gives warning: conversion to 'uint16_t {aka short unsigned int}' from 'int' may alter its value [-Wconversion] b += a; ~~^~~~ I can eliminate this by uint16_t a = 1; uint16_t b = 2; b = static_cast<uint16_t>(b + a); Is there any way to keep the operator+= and eliminate the warning? Thank you. EDIT I use gcc test.cpp -Wconversion my gcc version is gcc.exe (Rev3, Built by MSYS2 project) 7.2.0 I need to eliminate gcc -Wconversion warnings. You don't say why but this

Let say I have a 32-bit machine. I know during integer promotion the expressions are converted to:\ int if all values of the original type can be represented in int unsigned otherwise Could you please explain what will happen for the following expression? and In general, how ranking works here? First snippet: si16 x, pt; si32 speed; u16 length; x = (speed*pt)/length; Second one: x = pt + length; EDIT: si16 means signed short (size 16 bit), si32 bit means signed int (size 32 bit) and u16 means unsigned short (size 16) I found the following link that has described the issue very clearly:

I'm using IAR Workbench compiler with MISRA C:2004 checking on. The fragment is: #define UNS_32 unsigned int UNS_32 arg = 3U; UNS_32 converted_arg = (UNS_32) arg; /* Error line --> */ UNS_32 irq_source = (UNS_32)(1U << converted_arg); The MISRA error is: Error[Pm136]: illegal explicit conversion from underlying MISRA type "unsigned char" to "unsigned int" (MISRA C 2004 rule 10.3) I don't see any unsigned char in any of the code above. The discussion at Why did Misra throw an error here? discusses multiplication which may have different promoting rules than left shifting. My understanding is

I am quite confused by the following code: #include <stdio.h> #include <stdint.h> int main(int argc, char ** argv) { uint16_t a = 413; uint16_t b = 64948; fprintf(stdout, "%u\n", (a - b)); fprintf(stdout, "%u\n", ((uint16_t) (a - b))); return 0; } That returns: $ gcc -Wall test.c -o test $ ./test 4294902761 1001 $ It seems that expression (a - b) has type uint32_t. I don't uderstand why since both operators are uint16_t. Can anyone explain this to me? The C standard explains this quite clearly (§6.5.6 Additive Operators): If both operands have arithmetic type, the usual arithmetic conversions