Igino Corona

Sistemi Operativi Esercitazione 2: Richiami di programmazione in linguaggio C/C++ Igino Corona igino.corona@diee.unica.it martedi 7 Ottobre 2008

Linguaggi di programmazione Un linguaggio di programmazione è un linguaggio formale tramite il quale vengono espressi e deniti (codice sorgente) i programmi. Dal punto di vista pratico, vi sono due principali tipologie di linguaggi di programmazione: Compilati nei quali il codice sorgente del programma viene processato da un compilatore, che dopo averne vericato la correttezza (in genere sintattica), viene tradotto in un formato (binario) eseguibile dal sistema operativo Interpretati nei quali il codice sorgente del programma viene processato da un interprete che esegue le istruzioni, interagendo col sistema operativo sottostante

Linguaggi di programmazione Il C (C++) è un linguaggio di programmazione compilato. Questo signica che se vogliamo creare un programma tramite C (C++), che sia eseguibile su un certo sistema operativo, dobbiamo avere a disposizione il compilatore specico. Per linux (come per Windows) sono disponibili diversi compilatori C e C++. Nel seguito vedremo i compilatori GNU: gcc (per C) e g++ (per C++).

Linguaggi di programmazione Il C (C++) è un linguaggio di programmazione compilato. Questo signica che se vogliamo creare un programma tramite C (C++), che sia eseguibile su un certo sistema operativo, dobbiamo avere a disposizione il compilatore specico. Per linux (come per Windows) sono disponibili diversi compilatori C e C++. Nel seguito vedremo i compilatori GNU: gcc (per C) e g++ (per C++). Qualche esempio di linguaggio di programmazione interpretato? Tra i più famosi vi sono Java e Python.

Funzioni di libreria statiche e condivise Una funzione è una collezione di istruzioni che permettono di svolgere una determinata operazione e restituire dei valori. Ogni programma fa uso di funzioni, siano esse denite nel programma stesso o (già scritte e) disponibili in librerie. Per libreria si intende un contenitore di funzioni memorizzato in un le in formato codice oggetto. Nei sistemi UNIX, le librerie sono in genere presenti in /usr/lib e /usr/local/lib.

Funzioni di libreria statiche e condivise Una libreria può essere statica: le funzioni referenziate all'interno di un programma vengono estratte dalla libreria e incorporate nel le eseguibile in fase di compilazione (fase di linking) Una libreria può essere condivisa: contiene oggetti che condivisibili da più programmi; i le eseguibili possono contenere solo i riferimenti a tali oggetti, che vengono caricati in memoria (se non già presenti) in fase di esecuzione del programma

Funzioni di libreria statiche e condivise Compilare un programma C in Linux tramite shell Produrre un eseguibile a partire dal codice sorgente C: gcc -o <nome_eseguibile> <nome_sorgente>.c Produrre solo il codice oggetto: gcc -c <nome_sorgente>.c

Funzioni di libreria statiche e condivise Creare una libreria di funzioni Si vuole creare una libreria relativa alle funzioni ascii() e change_case() 1. Creo il codice oggetto relativo alle funzioni: g++ -c ascii.cxx g++ -c change_case.cxx 2. Creo la libreria standard libmy_demo.a, usando ar (UNIX archive utility): ar cr libmy_demo.a ascii.o change_case.o 1 1 ar prevede l'inserimento dei ag (in questo caso cr) senza il trattino...

Funzioni di libreria statiche e condivise Utilizzare la libreria di funzioni creata Creazione dell' header le my_demo.h deve contenere i prototipi delle funzioni ascii() e change_case() Uso della libreria in main.cxx g++ -o main main.cxx -L. -lmy_demo L' opzione -lmy_demo chiede al compilatore di eettuare il link tra il condice oggetto prodotto dalla compilazione di main.cxx e il codice oggetto della libreria libmy_demo.a L' opzione -L. inserisce la directory corrente tra i percorsi in cui il compilatore andrà a cercare libmy_demo.a

Funzioni di libreria statiche e condivise Utilizzare una libreria di funzioni (in generale) Link di librerie gcc -o <nome_eseguibile> <nome_sorgente>.c -l<nome_libreria> -L<PATH_librerie> Il link del codice C scritto dall' utente con le librerie viene eettuato su richiesta L' opzione -l del compilatore viene seguita dal nome della libreria senza il presso lib e l' estensione All' interno del codice sorgente deve essere incluso l' header (es. <math.h>) relativo alla libreria da utilizzare Esempio: g++ -o prgm prgm.cxx -lm Esegue il link della libreria matematica libm.a (oppure.so)

Funzioni di libreria statiche e condivise Librerie standard In genere assieme al compilatore vengono fornite un certo numero di librerie di funzioni predenite (es. librerie per l' input/output, librerie matematiche, etc.) libc è una libreria molto importante che viene utilizzata di default in fase di link per poter creare un eseguibile a partire dal codice C contiene il codice oggetto di funzioni di base quali printf, scanf, open, read, write, etc. Il comando ar consente anche di visualizzare il contenuto di una libreria: ar t /usr/lib/libc.a pr -4 -t N.B. con la concatenazione del comando pr -4 -t (tramite la pipe) si formatta l' output di ar t /usr/lib/libc.a su 4 colonne

Formato dei le eseguibili Il formato di default con cui vengono generati gli eseguibili (Executable and Linking Format) contiene (la denizione si trova nel le intestazione <elf.h>): Un header (intestazione) contenente informazioni sul sistema per cui il codice è stato compilato (tipo di hardware, versione SO, etc.) Informazioni sui segmenti di testo e dati Informazioni relative alla rilocazione Informazioni sulla tabella dei simboli e sulla tabella delle stringhe In linux, come nel resto dei sistemi UNIX, i le eseguibili vengono identicati vericando che questi rispettino il formato ELF, e non tramite l' estensione.exe del le come avviene in Windows.

Argomenti passati dalla shell È possibile accedere agli argomenti passati ad un programma tramite riga di comando facendo uso dei parametri argc e argv della fuzione main() argc: è un valore intero che specica il numero di parametri immessi nella riga di comando (n.b.: include il nome del le eseguibile) argv: è un array di puntatori a stringhe di caratteri. Ogni elemento di argv punta a un argomento fornito nella riga di comando (comprende anche il nome del le eseguibile) Esempio. Se digitiamo cp file1.c file1.bak, la shell assegna i seguenti valori alle variabili: argc = 3 argv[0] = cp argv[1] = file1.c argv[2] = file2.bak argv[3] = NULL

Argomenti passati dalla shell Esempio Esempio. Scriviamo il seguente listato su rigacom.c: void main(int argc, char *argv[]) { int i=0; printf(``nella riga di comando sono stati inseriti %d argomenti:\n\n'', argc); for (i=0; i<argc; i++) printf(``argv[%d] = %s, '', i, argv[i]); } Compiliamo tramite gcc -o rigacom rigacom.c e eseguiamo: rigacom uno due tre quattro cinque Output: Nella riga di comando sono stati insertiti 5 argomenti: rigacom, uno, due, tre quattro, cinque

Argomenti passati dalla shell Variabili di ambiente A livello di shell in genere vengono denite delle variabili d'ambiente (visibili utilizzando il comando env o printenv). Queste possono contenere il nome dell' utente corrente, del gruppo di appartenenza, host, percorsi predeniti, etc. (maggiori informazioni tramite man environ) I processi hanno accesso alle variabili d'ambiente tramite un puntatore (es. p2.7.cxx): extern char **environ; Le variabili d' ambiente possono essere lette/modicate anche attraverso le funzioni getenv() e putenv() denite in <stdlib.h>

Gestione degli errori La chiamata ad una funzione potrebbe non andare a buon ne. Ad esempio utilizzare la funzione open() per tentare di aprire un le inesistente causerà un errore In genere le funzioni predenite del C in caso di errore restituiscono -1 e impostano il valore di una variabile globale chiamata errno La variabile globale errno è una variabile intera che contiene il codice che identica l' errore che è stato riscontrato (tutti i codici sono deniti in genere nel le header /sys/errno.h) La funzione perror() stampa a video una stringa che descrive a parole il codice di errore memorizzato in errno

Gestione degli errori Esempio #include <iostream> #include <cstdio> #include <unistd.h> using namespace std; int main(int argc, char *argv[ ]){ if (argc > 1) { execlp("/bin/cat", "cat", argv[1], (char *) NULL); perror("ho fallito l' esecuzione di cat:"); return 1; } printf("utilizzo: %s text_file\n", argv[0]); return 2; }

Gestione degli errori Esempio Se la chiamata a execlp() fallisce il risultato sarà: Ho fallito l' esecuzione di cat: dell'errore> <descrizione Nota: la funzione execlp è una delle tante funzioni front-end di execve, utile per eseguire un eseguibile di cui si conosce il nome.

Input/Output a le La gestione dell' I/O a le orientata al usso fa riferimento ad un le tramite un puntatore a tipo di dato FILE (FILE *) Le funzioni per la gestione dell'i/o di basso livello utilizzano un valore intero chiamato le handle o descrittore di le

Input/Output a le Apertura o creazione di un le Le funzioni open() e creat() presentano i seguenti prototipi: #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int open(const char *pathname, int flags); int open(const char *pathname, int flags, mode_t mode); int creat(const char *pathname, mode_t mode); dove pathname indica il percorso del le da aprire. Il valore di flags indica la modalità di apertura del le (lettura, scrittura, etc.). Il valore di mode esprime i permessi sul le. In caso di successo le funzioni restituiscono un intero che rappresenta il primo (più piccolo) descrittore di le disponibile. In caso di errore le funzioni restituiscono -1 e impostano l'opportuno valore di errno

Input/Output a le Lettura e scrittura di un le Le funzioni read() e write() presentano i seguenti prototipi: #include <unistd.h> ssize_t read(int fd, void *buf, size_t count); ssize_t write(int fd, const void *buf, size_t count); write() scrive count byte di buf nel le puntato da fd read() legge count byte dal le puntato da fd e li memorizza in buf In caso di errore restituiscono -1 e impostano l'opportuno valore di errno

Input/Output a le Esempio #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #define BUFFER_LENGTH 1024 /* Esegue la copia di un file */ int main(int argc, char *argv[]) { int fd_orig, fd_dest; char buffer[buffer_length]; int num_byte = 0; continua...

Input/Output a le Esempio if ((fd_orig = open(argv[1], O_RDONLY)) == -1) { perror("open del file origine"); exit(2); } if ((fd_dest = open(argv[2], O_RDWR O_CREAT O_TRUNC, S_IRUSR S_IWUSR S_IRGRP S_IWGRP)) == -1) { perror("open del file destinazione"); exit(3); } continua...

Input/Output a le Esempio while(1) { num_byte = read(fd_orig, buffer, BUFFER_LENGTH); if (num_byte == -1 ) { perror("errore in lettura"); exit(4); } else if (num_byte==0) break; if (write(fd_dest, buffer, num_byte) == -1) { perror("errore in scrittura"); exit(5); } continua...

Input/Output a le Esempio } } return 0; /* Fine io_basso_liv.c */

Input/Output a le Verica di tipo e informazioni relative ai le La funzione isatty(): #include <unistd.h> int isatty(int desc); restituisce 1 se desc è legato ad un terminale, altrimenti restituisce 0

Input/Output a le Verica di tipo e informazioni relative ai le Le funzioni stat() e fstat(): #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> int stat(const char *file_name, struct stat *buf); int fstat(int filedes, struct stat *buf); restituiscono informazioni sul le (timestamp dell' ultimo accesso, dell' ultima modica, UID e GID del proprietario, etc.). Le informazioni vengono salvate nella struttura dati buf (es. p2.2.cxx)

Allocazione dinamica della memoria Per questioni di ecienza e essibilità nei programmi C e C++ si utilizza spesso l'allocazione dinamica della memoria assegnata ad un certo tipo di dato L' allocazione dinamica della memoria avviene attraverso funzioni dedicate che rendono disponibile un area contigua di memoria, di dimensione (in byte) specicata, restituendone l' indirizzo della prima locazione N.B. Parliamo di memoria virtuale

Allocazione dinamica della memoria Funzioni C Le funzioni del C per l' allocazione dinamica della memoria sono: #include <stdlib.h> void *calloc(size_t nmemb, size_t size); void *malloc(size_t size); void free(void *ptr); void *realloc(void *ptr, size_t size);

Allocazione dinamica della memoria Funzioni C calloc() alloca memoria per un array di nmemb elementi di dimensione size. La memoria allocata viene inizializzata a 0 malloc() alloca size byte di memoria (non inizializza le locazioni allocate) free() libera la memoria precedentemente allocata puntata da ptr realloc() cambia la dimensione del blocco di memoria puntato da ptr calloc(), malloc() e realloc() restituiscono un puntatore al blocco di memoria allocato, oppure NULL in caso di fallimento; free() non restituisce alcun valore.

Allocazione dinamica della memoria Esempio #define SIZE_MAX 20 int func(unsigned numchar) { char *stringa = NULL; /* prevedere dei limiti all' allocazione dinamica */ if (numchar > SIZE_MAX) { numchar = SIZE_MAX; /* effettuare il cast */ stringa = (char *) malloc(sizeof(char)*numchar); if ( stringa == NULL) return -1; /* SEMPRE deallocare la memoria non piu' utile */ free(stringa); return 1; }

Allocazione dinamica della memoria Funzioni C++ Operatori new e delete: string *sp; sp = new string(``ciao''); delete sp; Allocazione di un array di oggetti: int *sp; sp = new int[10]; delete [] sp; Vedere es. mem_alloc.c e mem_alloc.cpp

Allocazione dinamica della memoria I/O da terminale in C++ Gli oggetti cin, cout e cerr cin, cout e cerr sono variabili globali dichiarate in <iostream> cin è un oggetto di tipo istream collegato allo standard input cout è un oggetto di tipo ostream collegato allo standard output cerr è un oggetto di tipo ostream collegato allo standard error

Allocazione dinamica della memoria I/O da terminale in C++ #include <iostream> using namespace std; // omettendo questa istruzione bisogna // riferirsi a cout e cin come std::cout e std::cin int main() { int i, j, k; cout << ``Inserisci tre numeri separati da uno spazio:''; cin >> i >> j >> k; if(i>100 j>100 k>100) cerr << ``Errore: i numeri devono essere < 100!'' << endl; continua...

Allocazione dinamica della memoria I/O da terminale in C++ } else cout << ``Sono stati inseriti i seguenti valori: i='' << i << ``, j='' << j << ``, k='' << k << endl; return 0;

Risorse utili John Shapley Gray, Interprocess Communications in LINUX, The Nooks & Crannies B. W. Kernighan, D. M. Ritchie, Il Linguaggio C, Prentice Hall Herbert Schildt, Guida al C++, Mc Graw Hill GNU/Linux, pagine man