Operaciones con diferentes tipos de int.

Tengo un progtwig que utiliza varios tipos int diferentes.

Los más utilizados son uint64_t y el estándar int . Sin embargo, me pregunto si puedo hacer con seguridad operaciones mezcladas entre ellos.

Por ejemplo, tengo un uint64_t y quiero agregarle un int y almacenar ese valor como otro uint64_t .

¿Es seguro hacer algo así? ¿Tengo que lanzar el int a uint64_t antes de poder usar las operaciones en él?

Realmente no puedo encontrar cosas al respecto en línea. Puede que solo esté permitido y nadie lo cuestione, o mis consultas de Google están equivocadas.

De todos modos, básicamente mi pregunta es: ¿puedo mezclar y realizar operaciones con diferentes tipos de entradas?

Sí tu puedes.

Tu comstackdor se encargará de las conversiones. Lo único de lo que debe preocuparse es el desbordamiento: si almacena el resultado en un contenedor que es más pequeño que las entradas.

El término de búsqueda de Google que necesita es “conversiones de tipo implícitas”; consulte, por ejemplo, http://pic.dhe.ibm.com/infocenter/ratdevz/v8r5/index.jsp?topic=%2Fcom.ibm.tpf.toolkit.compilers .doc% 2Fref% 2Flangref_os390% 2Fcbclr21011.htm

Ese enlace incluye la siguiente tabla:

La conversión aritmética procede en el siguiente orden:

 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. ---------------------------------------------+-------------------------------------------- 

C norma C dice:

Si el operando que tiene un tipo entero sin signo tiene un rango mayor o igual al rango del tipo del otro operando, entonces el operando con tipo entero con signo se convierte al tipo del operando con tipo entero sin signo.

Por lo tanto, como int y unsigned int son del mismo rango, puede agregarlos, y cuando los agrega int se convierte en unsigned int dejando el resultado nuevamente en unsigned int .