operations with different int types

Question

I have a program which uses multiple different int types.

Most often used are uint64_t and the standard int. However I wonder if I can safely do operations mixed between them.

For instance I have an uint64_t and I want to add an int to it and store that value as another uint64_t.

Is doing such a thing safe? Do I have to cast the int to uint64_t before I can use operations on it?

I can`t really find stuff about it online. It might just be allowed and no one questions it or my Google queries are wrong.

Anyway so basically my question is can I mix and do operations with different types of ints?

Answer 1

Yes you can.

Your compiler will take care of the conversions. The only thing to worry about is overflow - if you store the result in a container that is smaller than the inputs.

The Google search term you need is "implicit type conversions" - see for example http://pic.dhe.ibm.com/infocenter/ratdevz/v8r5/index.jsp?topic=%2Fcom.ibm.tpf.toolkit.compilers.doc%2Fref%2Flangref_os390%2Fcbclr21011.htm

That link includes the following table:

Arithmetic conversion proceeds in the following order:

Operand Type                                  Conversion
---------------------------------------------+--------------------------------------------
One operand has long double type             | The other operand is converted to long double type.
---------------------------------------------+--------------------------------------------
One operand has double type                  | The other operand is converted to double.
---------------------------------------------+--------------------------------------------
One operand has float type                   | The other operand is converted to float.
---------------------------------------------+--------------------------------------------
One operand has unsigned long long int type  | The other operand is converted to unsigned long long int.
---------------------------------------------+--------------------------------------------
One operand has long long int type           | The other operand is converted to long long int.
---------------------------------------------+--------------------------------------------
One operand has unsigned long int type       | The other operand is converted to unsigned long int.
---------------------------------------------+--------------------------------------------
One operand has unsigned int type            |
and the other operand has long int type      |
and the value of the unsigned int can be     |
 represented in a long int                   | The operand with unsigned int type is converted to long int.
---------------------------------------------+--------------------------------------------
One operand has unsigned int type            |
and the other operand has long int type      |
and the value of the unsigned int cannot be  |
represented in a long int                    | Both operands are converted to unsigned long int
---------------------------------------------+--------------------------------------------
One operand has long int type                | The other operand is converted to long int.
---------------------------------------------+--------------------------------------------
One operand has unsigned int type            | The other operand is converted to unsigned int.
---------------------------------------------+--------------------------------------------
Both operands have int type                  | The result is type int.
---------------------------------------------+--------------------------------------------

Answer 2

C standard says,

If the operand that has unsigned integer type has rank greater or equal to the rank of the type of the other operand, then the operand with signed integer type is converted to the type of the operand with unsigned integer type.

Therefore as int & unsigned int are of same rank you can add them, and when you add them int is converted to unsigned int leaving the result again in to unsigned int.