Appunti corso Informatica

Introduzione al linguaggio C

PS1 ... SnA1 ... AnL1 ... Ln

Definizione variabile: è un contenitore d'informazione.

Assegnamento

Input / Output

Selezione (if)

Definizione ciclo: porzione di codice che viene ripetuta più volte. Il numero di volte è definito da un'espressione condizionale. L'espressione che

N.B: al fine di comprendere più facilmente il linguaggio C sarebbe meglio che regola la ripetizione del ciclo fosse definita in modo tale che ripeta dal ramo del vero.

Esempio #1 → ciclo a condizione finale viene eseguito almeno una volta. È consigliato quando si ha la certezza che il ciclo debba essere eseguito almeno una volta.

Pb: moltiplicare A (intero) e B (intero). L'utente conosce l'operatore somma, sottrazione e confronto. - Professor Fausto Distante scaglione BOM-CES

Per essere eseguito (almeno) una volta l'espressione regolatrice → ciclo a condizione iniziale deve essere vera. È consigliato quando non si ha la certezza che il ciclo

debba essere eseguito almeno una volta.
Programmazione C Linguaggio-esercizio stampa numero romano: condizione semplice (if) + ciclo a condizione iniziale (while)
#include <stdio.h>
int main (){
    // spazio di memoria (standard) per variabile: intero 2 byte (16 bit) , float 4 byte (32 bit) , char 1 byte (8 bit)
    int numero;
    do{
        printf("Inserire un numero strettamente maggiore di zero: \n");
        scanf("%d", &numero);
    } while (num <= 0);
    
    while (num >= 1000){
        num = num - 1000;
        printf("M");
    }
    
    if (num >= 500){
        num = num - 500;
        printf("D");
    }
    
    while (num >= 100){
        num = num - 100;
        printf("C");
    }
    
    if (num >= 50){
        num = num - 50;
        printf("L");
    }
    
    while (num >=10){
        num = num - 10;
        printf("X");
    }
    
    if (num >= 5){
        num = num - 5;
        printf("V");
    }
    
    while (num >= 1){
        num = num - 1;
        printf("I");
    }
    
    return 0;
}

#include <stdio.h>
int main() {
    int op_uno, op_due, ris;
    char operatore;
    
    printf("Inserire primo termine: \n");
    scanf("%d", &op_uno);
    getchar();
    
    printf("Inserire operatore: \n");
    scanf("%c", &operatore);
    
    printf("Inserire secondo termine: \n");
    scanf("%d", &op_due);
    
    switch (operatore) {
        case '+': {
            ris = op_uno + op_due;
            printf("%d %c %d = %d", op_uno, operatore, op_due, ris);
            break;
        }
        case '-': {
            ris = op_uno - op_due;
            printf("%d %c %d = %d", op_uno, operatore, op_due, ris);
            break;
        }
        case '*': {
            ris = op_uno * op_due;
            printf("%d %c %d = %d", op_uno, operatore, op_due, ris);
            break;
        }
        case '/': {
            if (op_due != 0) {
                ris = op_uno / op_due;
                printf("%d %c %d = %d", op_uno, operatore, op_due, ris);
            } else {
                printf("errore: impossibile eseguire la divisione per zero");
            }
            break;
        }
        default: {
            printf("Operatore non valido");
            break;
        }
    }
    
    return 0;
}

<div>divisione");break;default:printf("errore");}return 0;}precisazione su condizione semplice (if)→ if (espressione) azione;non esegue il contenuto dell' if.→espressione == 0 esegue il contenuto dell' if.→espressione != 0Problema: esiste una soluzione per compattare una serie di dati che l'utente vuole trasmettere?Definizione array: variabile complessa composta da elementi omogenei tra loro.Come posso dichiararla?#include <stdio.h>int main (){ int nome_variabile[dimensione_variabile];/* dimensione_variabile deve essere necessariamente una costante! */→es. int classe [200] 200 interi (400 byte = 3200 bit)–Professor Fausto Distante scaglione BOM-CESCome identificare un singolo elemento dell'array?tutto l'array.classe[i] = 18, dove i è una variabile che scorrepuò essere un'espressionei generica, non necessariamente una costante.il primo elemento dell'array ha spiazzamento→base +

(spiazzamento * dimensione elemento)0, mentre l'ultimo elemento ha spiazzamento 199.

#include <stdio.h>
int main (){
    int classe[200];
    int i;
    i=0;
    while (i < 200){
        printf("Inserire il voto dello studente numero %d: (i\n", + 1));
        /* permette di visulizzare a schermo studente numero 1 e studente numero 200
        anzichè studente numero 0 e studente numero 199 */
        scanf("%d", &classe[i]);
        i = i + 1;
    }
    ...
    return 0;
}

Problema: esiste un modo più semplice e ottimizzato per "scorrere" gli elementi di un array?

Soluzione: ciclo for: for (inizializzazione; condizione permanenza; ultima istruzione prima di un nuovo ciclo / ultime istruzioni).

#include <stdio.h>
int main (){
    int classe[200];
    int i;
    for (i = 0; i < 200; i++){
        printf("Inserire il voto dello studente numero %d: (i + 1));\n",scanf("%d", &classe[i]);
    }
    -Professor Fausto Distante scaglione BOM-CES}
    ...
    return 0;
}

esercizio: visualizzare a schermo il

<pre>
<code>
voto dello studente i-esimo partendo dal 200esimo.
#include <stdio.h>
int main (){
    int classe[200];
    int i;
    for (i = 0; i < 200; i++){
        printf("Inserire il voto dello studente numero %d: \n", i + 1);
        &classe[i]);
        scanf("%d", &classe[i]);
    }
    for (i = 199; i >= 0; i--)
        printf("voto dello studente in posizione %d: %d\n", i + 1, classe[i]);
    return 0;
}
</code>
</pre>
→istruzione define permette di avere un programma meno vincolato.
#include <stdio.h>
#define DIM 200
int main (){
    int classe[DIM];
    int i;
    for (i = 0; i < DIM; i++){
        printf("Inserire il voto dello studente numero %d: %d\n", i + 1);
        scanf("%d", &classe[i]);
    }
    for (i = (DIM - 1); i >= 0; i--)
        printf("voto dello studente in posizione %d: %d\n", i + 1, classe[i]);
    return 0;
}
→array bidimensionale int classe[30][200] 30 righe e 200 colonne.
È una variabile complessa composta da elementi (a loro volta

composti da elementi omogenei tra loro. N.B: notiamo che questo array visto in modo bidimensionale ricorda la struttura di una matrice.

base + ([indice riga * numero colonne] + indice colonna) * dimensione elemento

es. scrivere un programma che in un primo momento riempia una matrice R x C e in un secondo momento visualizzi a video la somma delle righe.

#include <stdio.h>
#define R 30
#define C 20
int main (){
    int matrice[R][C];
    int i, j;
    int somma;
    for (i = 0; i < R; i++)
        for (j = 0; j < C; j++){
            printf("Inserire elemento (%d, %d): ", (i + 1), (j + 1));
            scanf("%d", &matrice[i][j]);
        }
    for (i = 0; i < R; i++){
        somma = 0;
        for (j = 0; j < C; j++)
            somma = somma + matrice[i][j];
        printf("somma della riga %d: %d\n", (i + 1), somma);
    }
    return 0;
}

es. scrivere un programma che in un primo momento riempe una matrice R x C e in un secondo momento visualizza a video la somma delle colonne.

#include <stdio.h>
int main (){
    int matrice[R][C];
    int i, j;
    int somma;
    for (i = 0; i < R; i++)
        for (j = 0; j < C; j++){
            printf("Inserire elemento (%d, %d): ", (i + 1), (j + 1));
            scanf("%d", &matrice[i][j]);
        }
    for (j = 0; j < C; j++){
        somma = 0;
        for (i = 0; i < R; i++)
            somma = somma + matrice[i][j];
        printf("somma della colonna %d: %d\n", (j + 1), somma);
    }
    return 0;
}

- Professor Fausto

Distante scaglione BOM-CES
#define R 30
#define C 20

int main () {
    int matrice[R][C];
    int i, j;
    int somma;

    for (i = 0; i < R; i++)
        for (j = 0; j < C; j++) {
            printf("Inserire elemento(%d, %d): ", (i + 1), (j + 1));
            scanf("%d", &matrice[i][j]);
        }

    for (j = 0; j < C; j++) {
        somma = 0;
        for (i = 0; i < R; i++)
            somma = somma + matrice[i][j];
        printf("somma della colonna numero %d: %d\n", (j + 1), somma);
    }

    return 0;
}

definizione stringa: porzione di un array di caratteri che termina con un "tappo".
#include <stdio.h>
#include <string.h> /* è una libreria che ha a che fare con le stringhe */
#define MAXLEN 25 /* 25 possibili caratteri (tappo escluso) */

int main () {
    char frase[MAXLEN + 1]; /* quando dichiaro la stringa devo aggiungere il tappo */
    ...
    return 0;
}

come acquisire una stringa?
1) scanf("%s", &frase);
2) gets(frase) /* necessaria la libreria string.h per acquisire la stringa con la gets */
-Professor Fausto

Distante scaglione BOM-CESes. scrivere un programma che acquisisce una stringa di venti caratteri (minuscoli) e conta tutte le vocali che lo compongono.

#include <stdio.h>
#include <string.h>
#define MAXLEN 20

int main (){
    char frase[MAXLEN + 1];
    int j;
    int contatore_v;
    
    printf("Inserire una frase (massimo 20 char escluso tappo): \n");
    /* scanf("%s", &frase); */
    gets(frase);
    
    contatore_v = 0;
    
    for(j = 0; frase[j] != '\0'; j++){
        if((frase[j] == 'a') || (frase[j] == 'e') || (frase[j] == 'i') || (frase[j] == 'o') || (frase[j] == 'u')){
            contatore_v ++;
        }
    }
    
    printf("contatore_v: %d", contatore_v);
    
    return 0;
}

istruzione i = strcmp(frase1, frase2) /* mette a confronto frase1 e frase2 */

istruzione i = strlen(frase) /* fornisce la lunghezza della stringa al netto del tappo */

istruzione strcat(frase3, frase1, frase1, frase2) /* permette di concatenare frase1 e frase2 e salvare il risultato in frase3 */

1 e 2 /*istruzione strcopy(destinazione, sorgente) */ permette di copiare la frase 1 nella frase 2 
/*istruzione puts(frase) */ permette di visualizzare in output il contenuto della stringa 

Problema: è possibile costruire una variabile che contiene elementi non omogenei tra loro?
Soluzione: record (struct).
Prima di dichiarare una variabile di questo tipo è necessario definirla:

#include ...
#define ...
struct prova{
    Definizione tipo
    int ora;
    float temperatura;
    –Professor Fausto Distante scaglione BOM-CES
}

int main (){
    struct prova a, b, c;
    Dichiarazione variabile...
    return 0;
}

oppure:

#include ...
#define ...
struct prova{
    int ora;
    float temperatura;
} a, b, c;

int main (){
    ...
    return 0;
}

oppure:

#include ...
#define ...