Els enters

Aquesta lliçó explica els valors que poden prendre les variables de tipus enter (int), com es representen, i quines són les operacions que se’ls pot aplicar.

El tipus `int`

El tipus int representa els nombres enters en C++. Idealment, es correspon al conjunt dels enters ($\mathbb{Z}$), tot i que, a la pràctica, els nombres que es poden utilitzar estan limitats en un cert intèrval. Els valors enters es poden operar amb les operacions habituals (suma, resta, producte i divisió entera) i comparar entre ells.

Representació

En general, en C++ els enters s’escriuen i s’usen de la forma habitual: 2, 10, 42, 0, -415, etc.

Per raons històriques i pràctiques, els enters també es poden escriure en C++ utilitzant altres sistemes de representació numèrica $\small[\mathbb{W}]$:

Binari (base dos): Els nombres prefixats per 0b es representen en binari. Així, 0b10 representa el valor 2 i 0b1010 representa 10.
Octal (base vuit): Els nombres prefixats per 0 es representen en octal. Així, 02 representa el valor 2, però 012 representa 10 ($8+2$). Per això, compte!, no poseu mai zeros a l’esquerra dels enters per error.
Hexadecimal (base setze): Els nombres prefixats per 0x es representen en hexadecimal. Així, 0x2 representa el valor 2 i 0xA representa el valor 10.

A l’hora de llegir enters (amb cin), i a l’hora d’escriure’ls (amb cout), l’ordinador usa la base 10. Per exemple, si tenim un programa que calcula la suma de dos nombres, i volem sumar 23 i 42, nosaltres escriurem al teclat 23 i 42 (així, en base 10, com estem acostumats), l’ordinador llegirà els dos nombres i els desarà en complement a dos, en farà la suma, i després tindrà la gentilesa d’usar base 10 per escriure el resultat a la pantalla (65), de manera que nosaltres, humans, ho entenguem fàcilment.

Amb independència de com es representin els nombres enters al codi o a l’entrada/sortida, l’ordinador desa internament els nombres enters utilitzant un determinat nombre de bits anomenat complement a dos $\small[\mathbb{W}]$.

Per exemple, a l’ordinador de l’autor d’aquesta lliçó, els valors de tipus int es representen amb 32 bits, de forma que els enters que es poden usar són els compresos entre $-2^{31}$ i $2^{31}-1$ (-2147483648 i 2147483647). Aquests valors són prou grans com per no haver-se’n de preocupar habitualment (però sí en algunes aplicacions com les que calculen el deute dels estats).

Operacions

Les operacions que es poden aplicar entre dos enters són la suma (amb l’operador +), la resta (amb l’operador -), el producte (amb l’operador *) i la divisió entera (amb l’operador /), i el residu de la divisió entera (amb l’operador %), A més, hi ha disposible l’operació de canvi de signe (amb l’operador unari -). També existeixen operacions addicionals (^, << i >>) que no utilitzarem.

La taula següent mostra les operacions bàsiques entre enters:

Operador	Operació
`-`	canvi de signe
`+`	suma
`-`	resta
`*`	multiplicació
`/`	quocient de la divisió entera
`%`	residu de la divisió entera

L’operació de canvi de signe és unària, és a dir, té un sol operand. Les altres operacions són binàries.

Les operacions de suma, resta i producte són les operacions aritmètiques habituals. Per exemple, 3+9 val 12, 3-18 val -15 i 10*11 val 110. La divisió entre dos enters és la divisió entera, descartant la part decimal. Així, per exemple, 42/7 val 6, i 42/10 val 4 i no pas 4.2 (que no és un enter). El residu (%) és allò que sobra en fer la divisió entera. Així, 42%7 val 0 i 42%10 val 2.

Cal anar en compte en fer divisions i residus amb nombres negatius, ja que no dónen el resultats matemàtics esperats. Per exemple, si dividim -42 entre 10, el resultat correcte seria -5 i en sobren 8. Però -42/10 dóna -4 i no -5, i -42%10 dóna -2 i no 8. Per corregir aquestes situacions, cal restar 1 al quocient, i sumar el divisor (10, a l’exemple) al residu.

La prioritat d’aquests operadors aritmètics és l’habitual en matemàtiques: El producte, la divisió i el residu tenen prioritat sobre la suma i la resta. Sempre es poden utilitzar parèntesis per forçar que certes operacions s’apliquin abans que d’altres. Per exemple, 3 + 2 * 5 val 13 però (3 + 2) * 5 val 25.

Una regla bàsica en C++ (i en molts llenguatges de programació) diu que mai es pot dividir per zero: Altrament, dóna lloc a un error d’execució. Calcular el residu de dividir per zero també dóna error d’execució. Vigileu que els vostres programes mai divideixen per zero!

A més, els enters també es poden comparar entre ells: Donats dos enters, es pot mirar si són iguals (amb l’operador ==), si són diferents (amb l’operador !=), si el primer és estrictament inferior al segon (amb l’operador <), si el primer és estrictament superior al segon (amb l’operador >), si el primer és inferior o igual al segon (amb l’operador <=), i si el primer és superior o igual al segon (amb l’operador >=).

La taula següent mostra les operacions de comparacions entre enters:

Operador	Operació
`==`	igualtat
`!=`	diferència
`<`	més petit
`>`	més gran
`<=`	menor o igual
`>=`	major o igual

Fixeu-vos que l’operador per comprovar si dos enters són iguals és == (amb dos iguals). En C++, = (amb un sol igual) serveix per desar valors. Fixeu-vos també que <= i >= s’han d’escriure com s’indica, i no pas ni =< ni =>.

Sobreeiximents

Com que dins de l’ordinador els valors enters es desen amb un cert nombre predeterminats de bits, és possible que el resultat d’una operació no es pugui desar completament. Quan això passa, es diu que hi ha un sobreeiximent (overflow) i el resultat és incorrecte.

Per exemple, amb enters de 32 bits, el resultat de 2147483647 + 1 dóna -2147483648 que és, evidentment, incorrecte.

C++ ofereix poc (o gens) suport per detectar els sobreeiximent. Afortunadament, en molts casos no cal preocupar-se’n.

Altres tipus enters

En C++ hi ha altres tipus per guardar enters, com ara unsigned int, short int, o long int. Les variacions principals és si admeten o no negatius i quants bits ocupen. El seu ús no és gaire necessari en aquest curs.

La llibreria `<limits>`

La llibreria estàndard <limits> ofereix algunes funcions que poden ser útils a l’hora de treballar amb nombres enters:

numeric_limits<int>::max() retorna el valor més gran pels ints.
numeric_limits<int>::min() retorna el valor més petit pels ints.

També es poden utilitzar per altres tipus, com short int o long int.

El programa següent escriu la talla (en bytes), el valor mínim i el valor màxim de diferents tipus:

#include <iostream>
#include <limits>
using namespace std;

int main() {
    cout << "int" << " " << sizeof(int) << " " << numeric_limits<int>::min() << " " << numeric_limits<int>::max() << endl;
    cout << "short" << " " << sizeof(short) << " " << numeric_limits<short>::min() << " " << numeric_limits<short>::max() << endl;
    cout << "long" << " " << sizeof(long) << " " << numeric_limits<long>::min() << " " << numeric_limits<long>::max() << endl;
    cout << "unsigned int" << " " << sizeof(unsigned int) << " " << numeric_limits<unsigned int>::min() << " " << numeric_limits<unsigned int>::max() << endl;
    cout << "unsigned short" << " " << sizeof(unsigned short) << " " << numeric_limits<unsigned short>::min() << " " << numeric_limits<unsigned short>::max() << endl;
    cout << "unsigned long" << " " << sizeof(unsigned long) << " " << numeric_limits<unsigned long>::min() << " " << numeric_limits<unsigned long>::max() << endl;
}

Aquesta és la sortida al sistema de l’autor:

int             4    -2147483648           2147483647
short           2    -32768                32767
long            8    -9223372036854775808  9223372036854775807
unsigned int    4    0                     4294967295
unsigned short  2    0                     65535
unsigned long   8    0                     18446744073709551615

Lliçons.jutge.org
Jordi Petit, Salvador Roura
Universitat Politècnica de Catalunya, 2023