C Language Operatori aritmetici

Esempio

Aritmetica di base

Restituisce un valore che è il risultato dell'applicazione dell'operando della mano sinistra all'operando di destra, usando l'operazione matematica associata. Si applicano le normali regole matematiche di commutazione (cioè l'addizione e la moltiplicazione sono commutative, la sottrazione, la divisione e il modulo non lo sono).

Addition Operator

L'operatore di addizione ( + ) viene utilizzato per aggiungere due operandi insieme. Esempio:

#include <stdio.h>

int main(void)
{
    int a = 5;
    int b = 7;

    int c = a + b; /* c now holds the value 12 */

    printf("%d + %d = %d",a,b,c); /* will output "5 + 7 = 12" */

    return 0;
}

Operatore di sottrazione

L'operatore di sottrazione ( - ) viene utilizzato per sottrarre il secondo operando dal primo. Esempio:

#include <stdio.h>

int main(void)
{
    int a = 10;
    int b = 7;

    int c = a - b; /* c now holds the value 3 */

    printf("%d - %d = %d",a,b,c); /* will output "10 - 7 = 3" */

    return 0;
}

Operatore di moltiplicazione

L'operatore di moltiplicazione ( * ) viene utilizzato per moltiplicare entrambi gli operandi. Esempio:

#include <stdio.h>

int main(void)
{    
    int a = 5;
    int b = 7;

    int c = a * b; /* c now holds the value 35 */

    printf("%d * %d = %d",a,b,c); /* will output "5 * 7 = 35" */

    return 0;
}

Da non confondere con l'operatore * dereferenziazione.

Operatore di divisione

L'operatore di divisione ( / ) divide il primo operando del secondo. Se entrambi gli operandi della divisione sono numeri interi, restituirà un valore intero e scarterà il resto (utilizzare l'operatore modulo % per calcolare e acquisire il resto).

Se uno degli operandi è un valore in virgola mobile, il risultato è un'approssimazione della frazione.

Esempio:

#include <stdio.h>

int main (void)
{
    int a = 19 / 2 ; /* a holds value 9   */
    int b = 18 / 2 ; /* b holds value 9   */
    int c = 255 / 2; /* c holds value 127 */
    int d = 44 / 4 ; /* d holds value 11  */
    double e = 19 / 2.0 ; /* e holds value 9.5   */
    double f = 18.0 / 2 ; /* f holds value 9.0   */
    double g = 255 / 2.0; /* g holds value 127.5 */
    double h = 45.0 / 4 ; /* h holds value 11.25 */

    printf("19 / 2 = %d\n", a);    /* Will output "19 / 2 = 9"    */
    printf("18 / 2 = %d\n", b);    /* Will output "18 / 2 = 9"    */
    printf("255 / 2 = %d\n", c);   /* Will output "255 / 2 = 127" */
    printf("44 / 4 = %d\n", d);    /* Will output "44 / 4 = 11"   */
    printf("19 / 2.0 = %g\n", e);  /* Will output "19 / 2.0 = 9.5"    */
    printf("18.0 / 2 = %g\n", f);  /* Will output "18.0 / 2 = 9"      */
    printf("255 / 2.0 = %g\n", g); /* Will output "255 / 2.0 = 127.5" */
    printf("45.0 / 4 = %g\n", h);  /* Will output "45.0 / 4 = 11.25"  */

    return 0;
}

Operatore di modulo

L'operatore modulo ( % ) riceve solo operandi interi e viene utilizzato per calcolare il resto dopo che il primo operando è stato diviso per il secondo. Esempio:

#include <stdio.h>

int main (void) {
    int a = 25 % 2;    /* a holds value 1  */
    int b = 24 % 2;    /* b holds value 0  */
    int c = 155 % 5;   /* c holds value 0  */
    int d = 49 % 25;   /* d holds value 24 */

    printf("25 % 2 = %d\n", a);     /* Will output "25 % 2 = 1"    */
    printf("24 % 2 = %d\n", b);     /* Will output "24 % 2 = 0"    */
    printf("155 % 5 = %d\n", c);    /* Will output "155 % 5 = 0"   */
    printf("49 % 25 = %d\n", d);    /* Will output "49 % 25 = 24"  */

    return 0;
}

Operatori di incremento / decremento

Gli operatori di incremento ( a++ ) e di decremento ( a-- ) sono diversi in quanto modificano il valore della variabile a cui li si applica senza un operatore di assegnazione. È possibile utilizzare gli operatori di incremento e decremento prima o dopo la variabile. Il posizionamento dell'operatore modifica i tempi di incremento / decremento del valore prima o dopo l'assegnazione alla variabile. Esempio:

#include <stdio.h>

int main(void)
{
    int a = 1;
    int b = 4;
    int c = 1;
    int d = 4;

    a++;
    printf("a = %d\n",a);    /* Will output "a = 2" */
    b--;
    printf("b = %d\n",b);    /* Will output "b = 3" */

    if (++c > 1) { /* c is incremented by 1 before being compared in the condition */
        printf("This will print\n");    /* This is printed */
    } else {
        printf("This will never print\n");    /* This is not printed */
    }

    if (d-- < 4) {  /* d is decremented after being compared */
        printf("This will never print\n");    /* This is not printed */
    } else {
        printf("This will print\n");    /* This is printed */
    }
}

Come nell'esempio per c e d , entrambi gli operatori hanno due forme, come notazione prefisso e notazione postfissa. Entrambi hanno lo stesso effetto nell'incrementare ( ++ ) o decrementare ( -- ) la variabile, ma differiscono in base al valore che restituiscono: le operazioni di prefisso eseguono prima l'operazione e quindi restituiscono il valore, mentre le operazioni postfissa determinano prima il valore che deve essere restituito, quindi eseguire l'operazione.

A causa di questo comportamento potenzialmente contro-intuitivo, l'uso di operatori di incremento / decremento all'interno di espressioni è controverso.