MASSIMO UBERTINI

VISUAL C++

WWW.UBERTINI.IT

C e C++ um 1 di 299

MODULO 1

LINGUAGGIO C Introduzione

C e C++ um 2 di 299

INTRODUZIONE

GENERALITÀ Caratteristiche. Portabile. Case-sensitive. Modulare, sciolto e flessibile. Non ha funzioni d’I/O, ogni utente se le costruisce e le memorizza nella libreria. Le funzioni disponibili sono di due tipi. 1. System I/O, veloci ma non compatibili. 2. Standard I/O, lente e voluminose. Il linguaggio ha poche primitive e non ha un forte controllo di tipo, come ad esempio il linguaggio Pascal. Strumento per professionisti È possibile produrre applicazioni la cui efficienza è paragonabile a quella delle applicazioni scritte in assembly, potendo però usufruire dei vantaggi di un linguaggio ad alto livello. Linguaggio di medio livello Perché unisce elementi dei linguaggi ad alto livello con le funzionalità dell’assembly, quindi consente la gestione di bit, byte e indirizzi, queste possibilità sono adatte alla programmazione di SO (Sistema Operativo). Il programmatore deve considerare il codice macchina che la sua applicazione genera.

.

MAPPATURA DELLA MEMORIA

Un’applicazione crea e usa quattro aree di memoria distinte. 1. Programma: è memorizzato il codice eseguibile. 2. Varibili globali. 3. Heap: è una regione di memoria libera che può essere richiesta dall’applicazione tramite

le funzioni di allocazione dinamica. 4. Stack: memorizza: l’indirizzo di ritorno delle funzioni, i parametri passati alle funzioni, le

variabili locali e lo stato della CPU.

C e C++ um 3 di 299

Struttura di un’applicazione Tutte le parole chiave sono minuscole. Tutte le applicazioni sono costituite da una o più funzioni. L’unica che dev’essere sempre presente è il main perché è la prima cui è ceduto il controllo quando inizia l’esecuzione di un’applicazione. È buona regola di programmazione usare main per chiamare altre funzioni e non per eseguire elaborazioni. /* direttive del preprocessore*/ #include #define N 10 /* dichiarazione dei prototipi di funzione: dichiarazione in anticipo della funzione che si utilizzerà con il tipo dei parametri e il tipo della variabile da restituire: questo permette un forte controllo di tipo. */ int stampa1 (int n); /* dichiarazione di tipi */ typedef int vettore[N]; /* dichiarazioni di variabili globali*/ int i; /* main program: definire sempre che il main non possiede parametri */ int main(void) { dichiarazioni; istruzioni; return(0); } /* definizioni di funzioni */ int stampa1 (int n) { printf ("%d ",n); return (0); } Direttiva #include #include Chiede al compilatore d’includere un determinato file all’interno del file che contiene questa direttiva. Per esempio, le funzioni di libreria del C lavorano con i loro specifici tipi di dati e con le variabili alle quali l’applicazione deve poter accedere. Questi tipi di dati e variabili sono definiti nei file d’intestazione o file header (*.h), forniti insieme al compilatore che vanno inseriti all’inizio di ogni applicazione che li richiede; in questo modo il programmatore leggendo il file header può individuare le dichiarazioni di variabili e funzioni che permettono l’utilizzo di quella libreria pur non conoscendone l’implementazione. Racchiudendo la direttiva (< >) il file sarà cercato nella cartella predefinita. Racchiudendo la direttiva (“ ”) il file sarà cercato prima nella cartella corrente. I file d’intestazione sono di tipo testo e si trovano nella cartella \INCLUDE. È permesso che file inclusi contengano a loro volta le direttive #include, in questo caso si parla d’include annidate.

C e C++ um 4 di 299

Direttiva #undef Elimina la definizione di un nome di macro che è stato precedentemente definito con la direttiva #define. L’utilizzo è quello di limitare le definizioni dei nomi di macro all’interno di porzioni di codice.

SISTEMA D’I/O Il C possiede due tipi di funzioni d’I/O. 1. Presente sia nello standard ANSI sia nello Unix: sistema a file bufferizzato, noto anche

come ad alto livello oppure formattato . 2. Presente solo nello standard Unix: sistema a file non bufferizzati, oppure non formattato

o ancora Unix-like . Il sistema d’I/O del C fornisce un’interfaccia astratta che è indipendente dal particolare dispositivo fisico impiegato. Il livello di astrazione è chiamato stream, canale, mentre il dispositivo fisico è detto file. All’inizio dell’applicazione sono aperti automaticamente cinque stream standard d’I/O. Nome Stream I/O Modo Dispositivo stdin standard input input testo tastiera (CON) stdout standard output output testo monitor (CON) stderr standard error output testo monitor (CON) stdprn standard printer I/O binario stampante (LPT1) stdaux standard auxiliary output binario seriale (COM1) Il marcatore di end of file varia a seconda del SO. Le funzioni di libreria del C fanno sembrare che ogni riga termini con un singolo carattere newline, indipendentemente dal fatto che il file d’input contenga un carattere CR (Carriage Return), un carattere LF (Line Feed) o entrambi. Le funzioni di libreria d’input restituiscono un unico carattere newline. Le funzioni di libreria di output eseguono la traduzione inversa. Se un’applicazione chiama una funzione di libreria per scrivere il carattere newline, la funzione tradurrà il carattere nel marcatore end of file appropriato. Questo approccio rende le applicazioni C portabili. I/O formattato Il termine formattato si riferisce al fatto che le operazioni svolte dalle funzioni avvengono sempre con un formato che rimane sotto il controllo del programmatore. Le funzioni di libreria utilizzano delle stringhe di formato per controllare l’I/O, possiedono l’abilità di convertire i dati dalla forma testuale a quella numerica durante l’input e dalla forma numerica a quella testuale durante l’output. Nessuna delle altre funzioni d’I/O è in grado di effettuare questo tipo di conversioni. printf La funzione printf è progettata per visualizzare il contenuto di una stringa, assieme a valori inseriti in specifici punti della stringa stessa. Scrive un numero variabile di dati nello stream di output utilizzando una stringa di formato che controlla il modo di presentarsi dell’output e ritorna il numero di caratteri scritti, un valore negativo indica che si è verificato un errore. La funzione possiede un numero variabile di parametri. int printf (const char *format [, argument]... ); La stringa di formato contiene normali caratteri e/o delle specifiche di conversione.

C e C++ um 5 di 299

I normali caratteri sono stampati così come sono. Le specifiche di conversione descrivono come i restanti parametri debbano essere convertiti nella forma testuale. Una specifica di conversione è costituita dal simbolo (%) seguito fino da cinque oggetti distinti.

(%) è un segnaposto che indica dove dev’essere inserito durante la stampa il valore da stampare. Flag Opzionale, ne è permesso più di uno. (-) allinea a sinistra all’interno del campo, per default l’allineamento è a destra. (+) i numeri prodotti dalle conversioni con segno iniziano sempre con (+) o (-). Blank: i numeri non negativi prodotti dalle conversioni con segno sono preceduti da un blank, (+) annulla il blank. (#) i numeri ottali iniziano con (o), i numeri esadecimali diversi da zero iniziano con (0x) o (0X), i numeri reali hanno sempre il punto decimale, gli zeri trascinati non sono sempre rimossi dai numeri stampati con le conversioni (g) e (G). Zero: i numeri sono espansi con degli zero fino a riempire tutta la larghezza del campo, lo zero è ignorato se lo specificatore di conversione è uno tra (d), (i), (o), (u), (x) o (X) e se è stata specificata la precisione, (-) annulla l’effetto di zero. Lunghezza minima del campo Opzionale, un oggetto che fosse troppo piccolo per occupare questo numero di caratteri sarebbe espanso, per default sono aggiunti dei blank alla sinistra dell’oggetto, allineandolo a destra all’interno del campo. Un oggetto che fosse troppo grande per la larghezza del campo sarebbe visualizzato comunque nella sua interezza. La larghezza del campo può essere sia un intero sia il carattere (*), in questo caso la larghezza del campo è ottenuta dall’argomento successivo. Precisione Opzionale, dipende dalla conversione usata. (d), (i), (o), (u), (x), (X): numero minimo di cifre, degli zeri sono aggiunti nel caso in cui il numero avesse meno cifre. (a), (A), (e), (E), (s), (F): numero di cifre dopo il punto decimale. (g), (G): numero di cifre significative. s: numero massimo di byte. La precisione è costituita da un (.) seguito da un intero o dal carattere (*), in questo caso la precisione è ottenuta dall’argomento successivo. Se è presente solo il (.) la precisione è pari a zero. Modificatore della lunghezza Opzionale, indica che l’oggetto che dev’essere visualizzato è di un tipo che è più lungo o più corto del normale rispetto alla particolare specifica di conversione in uso. Per esempio, %d si riferisce ad un valore int, %hd è utilizzato per visualizzare uno short int e &ld è usato per i long int.

C e C++ um 6 di 299

Specificatore di conversione (d), (i) converte un valore int nel formato decimale. (o), (u), (x), (X) converte un valore unsigned int in base 8 (o), base 10 (u) o in base 16 (x) visualizza le cifre esadecimali (a – f) come lettere minuscole, (X) le visualizza come lettere maiuscole. (f) converte un valore double nella forma decimale mettendo il punto decimale nella posizione corretta, se non è specificata alcuna precisione, visualizza 6 cifre dopo il punto decimale. (e), (E) converte un valore double nella notazione scientifica, se non è specificata alcuna precisione, visualizza 6 cifre dopo il punto decimale; se è scelto (e) l’esponente è preceduto dalla lettera (e); se è scelto (E) l’esponente è preceduto dalla lettera (E). (g) converte un valore double o nel formato (f) o (e) se l’esponente è minore di (- 4) oppure è maggiore o uguale alla precisione, gli zeri seguenti non sono visualizzati a meno che non sia usato (#); il punto decimale è presente solo quando è seguito da una cifra; (G) sceglie tra i formati (F) e (E). (c) visualizza un valore int come un carattere senza segno. (s) scrive i caratteri puntati dall’argomento, interrompe la scrittura quando è raggiunto il numero di byte specificati dalla precisione, se presente o quando è incontrato il carattere blank o TAB, una newline o NULL. Un blank dopo il (%) lascia uno spazio davanti ai numeri positivi, mentre non altera il meno davanti ai negativi. Il compilatore non controlla se il numero di specifiche di conversione presenti in una stringa di formato corrisponda al numero di oggetti da stampare. (/n) newline avanza automaticamente alla linea successiva dell’output quando termina la stampa. Esempio, stampare i primi tre caratteri della stringa indicata, allineati a sinistra in un campo di 5 spazi, i due asterischi sono aggiunti per vedere i limiti del campo. printf("*%-5.3s*","ciclista"); /* stampa *cic * */ Esempio, i due asterischi non fanno parte della specifica di stampa ma sono normali caratteri aggiunti per evidenziare inizio e fine della stampa del numero. #include #include int main(void) { int x = 777; system("cls"); printf("\tAllineamenti di numeri con printf:\n\n"); printf("Stampa normalmente:\t\t\t*%d*\n\n",x); printf("Allinea a destra in campo largo 8:\t*%8d*\n",x); printf("Allinea a sinistra in campo largo 8:\t*%-8d*\n\n",x); printf("Stampa in campo troppo stretto:\t\t*%2d*\n",x); printf("Stampa in campo largo 6, con zeri:\t*%06d*\n",x); printf("Stampa un minimo di 6 cifre:\t\t*%.6d*\n\n",x); printf("Stampa un numero negativo:\t\t*%d*\n\n",-x); printf("Segno su numero positivo:\t\t*%+d*\n",x); printf("Segno su numero negativo:\t\t*%+d*\n\n",-x); printf("Spazio su numero positivo:\t\t*% d*\n",x); printf("Spazio su numero negativo:\t\t*% d*\n",-x);

C e C++ um 7 di 299

system("pause");return (0); }

scanf La funzione scanf è progettata per leggere dei dati dallo stream d’input utilizzando una stringa di formato per indicare la disposizione dell’input stesso. Dopo la stringa di formato segue un numero qualsiasi di puntatori, ognuno punta ad un oggetto. Gli oggetti d’input sono convertiti in accordo con le specifiche di conversione presenti nella stringa di formato e salvati in questi oggetti. Termina prematuramente se non possono essere letti altri caratteri d’input oppure i caratteri non si adattano alla stringa di formato. int scanf (const char *format [, argument]... ); La stringa di formato rappresenta un pattern che la funzione cerca di far combaciare con l’input che legge, contiene tre cose. 1. Specifiche di conversione: salta i caratteri blank presenti all’inizio di un oggetto d’input

ma mai quelli che seguono. 2. Caratteri blank: uno o più caratteri blank consecutivi presenti all’interno di una stringa di

formato si accoppiano con zero o più caratteri blank presenti nello stream d’input; un carattere di spaziatura fa in modo che dalla stringa proveniente da stdin siano letti, senza essere memorizzati, un certo numero di caratteri di spaziatura, anche nessuno, fino al successivo carattere che non sia di spaziatura, sono caratteri di spaziatura il blank, l’INVIO e la tabulazione; quando nella stringa è presente un carattere diverso da quelli di spaziatura è letto e scartato, %d,%d si scarta la virgola.

3. Caratteri non blank: un carattere che non sia blank, eccetto (%), si accoppia nello stream d’input con lo stesso carattere.

Una specifica di conversione consiste nel carattere (%) seguito dagli elementi elencati di seguito. * Opzionale, un oggetto d’input è letto ma non assegnato, non è incluso nel conto dei caratteri letti. Larghezza massima del campo Opzionale, mette un limite al numero di caratteri presenti in un oggetto d’input, la conversione termina se questo numero è raggiunto, i blank saltati all’inizio della conversione non contano.

C e C++ um 8 di 299

Modificatore della lunghezza Opzionale, indica che l’oggetto nel quale sarà salvato l’input è di un tipo che è più grande o più piccolo del normale per una particolare specifica di conversione. Specificatori di conversione (d) un intero in base 10, tipo int. (i) un intero, tipo int, se inizia con zero è ottale, con (x, X) esadecimale. (0) un intero ottale, tipo unsigned int. (u) un intero in base 10, tipo unsigned int. (x, X) un intero esadecimale, tipo unsigned int. (e, E), (f), (g), (G) un float. (c) si combina con n caratteri, dove n è la larghezza massima del campo oppure un carattere se la larghezza del campo non è stata specificata, non aggiunge il carattere NULL al termine. (s) si combina con una sequenza di caratteri non rappresentanti blank e aggiunge il carattere NULL al termine. Le variabili usate per ricevere i parametri letti da scanf devono essere passate per indirizzo (&), in pratica sono puntatori alle vere variabili. L’asterisco posto tra (%) e il carattere di conversione fa in modo che sia letto il dato corrispondente ma senza essere memorizzato, quando è chiamata la scanf inizia a elaborare le informazioni presenti nella stringa partendo dalla sinistra. Esempio, salta i blank che precedono l’inizio della stringa e si ferma a qualsiasi carattere che rappresenti un blank. #include #include #define N 80 int main(void) { char str[N+1]=""; system("cls"); printf ("Inserisci la frase: "); scanf ("%s",str); printf("\n%s\n",str); system("pause");return (0); }

La scanf non salta i blank, se il successivo carattere non letto è un blank, allora la variabile di lettura conterrà un blank dopo il ritorno della funzione scanf. #include #include int main(void) { char a,b,c; system("cls"); printf ("Inserisci tre caratteri: "); scanf ("%c%c%c",&a,&b,&c); printf("Sono stati inseriti: a=%c b=%c c=%c\n",a,b,c);

C e C++ um 9 di 299

system("pause");return (0); }

Per forzare la scanf a saltare i blank prima della lettura di un carattere si deve mettere un blank all’interno della stringa di formato. #include #include int main(void) { char a,b,c; system("cls"); printf ("Inserisci tre caratteri: "); scanf ("%c %c %c",&a,&b,&c); printf("Sono stati inseriti: a=%c b=%c c=%c\n",a,b,c); system("pause");return (0); }

Dato che la scanf di norma non salta i blank, è facile trovare la fine di una riga d’input: è sufficiente controllare se il carattere appena letto è newline. do { scanf ("%c",&c); } while (c != '\n'); Esempio, lettura di una frazione immessa dall’utente, somma di frazioni. #include #include int main(void) { int n1=0,d1=0,n2=0,d2=0,rn=0,rd=0; system("cls"); printf ("Inserisci la prima frazione:\t"); scanf ("%d%/%d",&n1,&d1); printf ("Inserisci la seconda frazione:\t"); scanf ("%d%/%d",&n2,&d2); rn=n1*d2+n2*d1; rd=d1*d2; printf("La somma vale: %d/%d\n",rn,rd); system("pause");return (0); }

C e C++ um 10 di 299

Esempio, saltare tutti i caratteri fino al primo carattere newline. scanf ("%*[^\n]"); I/O di caratteri Leggono e scrivono singoli caratteri come valori di tipo int e non char. Funzioni di output La funzione putchar scrive un carattere sullo stream stdout. Le funzioni putc e fputc scrivono un carattere in uno stream qualsiasi. Se si verifica un errore in scrittura, tutte e tre le funzioni, impostano l’indicatore di errore dello stream e restituiscono EOF altrimenti restituiscono il carattere che è stato letto. int putchar (int c); int putc(int c, FILE *stream); int fputc (int c, FILE *stream ); Funzioni d’input La funzione getchar legge un carattere dallo stream stdin. Le funzioni fgetc e getc leggono un carattere da uno stream qualsiasi. Tutte e tre le funzioni trattano il carattere come un unsigned char che è poi convertito in int prima di essere restituito. Indicano una condizione di fine file o di errore per mezzo del valore restituito EOF che è una costante intera negativa. int getchar(void); int getc (FILE *stream ); int fgetc (FILE *stream ); int ungetc (int c, FILE *stream ); La funzione ungetc rimette a posto un carattere letto dallo stream e azzera EOF, utile perché legge il carattere successivo. Esempio, leggere una serie di cifre e fermarsi al primo carattere che non sia una cifra. while (isdigit (ch=getc(fp))) { ..... } ungetc (ch,fp); /* rimette a posto l'ultimo carattere letto */ Utilizzare getchar e putchar, invece di scanf e printf, permette di risparmiare tempo durante l’esecuzione dell’applicazione. Le due funzioni sono veloci per due motivi. 1. Sono più semplici rispetto a scanf e printf. 2. Sono implementate come macro. I/O di righe Leggono e scrivono righe, usate con gli stream di testo. Funzioni di output La funzione puts scrive una stringa sullo stream stdout, dopo aver scritto aggiunge sempre il carattere newline. La funzione fputs scrive una stringa in uno stream qualsiasi, dopo aver scritto non aggiunge il carattere newline.

C e C++ um 11 di 299

Entrambe restituiscono EOF nel caso si verificasse un errore di scrittura, negli altri casi restituiscono un valore non negativo. int puts (const char *str ); int fputs ( const char *str, FILE *stream ); Funzioni d’input La funzione gets legge una riga d’input dallo stream stdin, legge i caratteri uno alla volta e li salva nell’array, fino a quando non legge il carattere newline che è scartato, inserisce il carattere NULL che funge da terminatore per la stringa. La funzione fgets legge una stringa da uno stream qualsiasi, pone un limite al numero di caratteri da leggere. Restituiscono un puntatore nullo nel caso si verificasse un errore in lettura o nel caso incontrassero la fine dello stream d’input prima di aver salvato qualsiasi carattere, in pratica se l’utente batte CTRL-Z o il tasto funzione F6. Non è possibile sapere quanti caratteri l’utente scriverà prima di premere INVIO, per evitare di uscire dalla stringa, si deve dimensionare l’array per il massimo numero possibile di caratteri, per esempio nei PC la gets non può leggere oltre 127 caratteri, più (\0) finale. char *gets ( char *buffer ); char *fgets ( char *str, int n, FILE *stream ); Esempio. #include #include #define N 80 int main(void) { char str[N+1]=""; system("cls"); printf ("Inserisci la frase: "); gets (str); printf("%s\n",str); system("pause");return (0); }

Modificare il ciclo scanf per saltare la parte rimanente di una riga. while (getchar() != '\n'); Esempio, leggere la stringa dalla tastiera e stampare la sua lunghezza. #include #include #include #define N 10 int main(void) { char s[N]; system("cls"); printf ("Inserisci la frase: ");

C e C++ um 12 di 299

gets (s); printf ("La lunghezza della stringa e' %d\n",strlen(s)); system("pause");return (0); }

I/O di stringhe Leggono e scrivono dati utilizzando una stringa come se fosse uno stream. Funzioni di output La funzione sprintf scrive il suo output in un array di caratteri invece che in uno stream. Quando ha terminato la scrittura, aggiunge il carattere NULL e restituisce il numero di caratteri salvati, senza contare il carattere NULL. Se si verifica un errore ritorna un valore negativo. La funzione _snprintf è uguale a sprintf ma possiede il parametro in più n, nella stringa non saranno scritti più di (n – 1) caratteri, senza contare il carattere NULL che è sempre scritto. int sprintf (char *buffer, const char *format [, argument] ... ); int _snprintf (char *buffer, size_t count, const char *format [, argument] ... ); int sprintf_s (char *buffer, size_t sizeOfBuffer, const char *format [, argument] ... ); Esempio. #include #include int main( void ) { char buffer[200], s[] = "PC", c = 'M'; int i = 35, j=0; float fp = 1.7320534f; system("cls"); j = sprintf_s( buffer, 200, " Stringa:\t%s\n", s ); j += sprintf_s( buffer + j, 200 - j, " Carattere:\t%c\n", c ); j += sprintf_s( buffer + j, 200 - j, " Integer:\t%d\n", i ); j += sprintf_s( buffer + j, 200 - j, " Real:\t\t%f\n", fp ); printf_s( "Output:\n%s\nNumero caratteri = %d\n", buffer, j ); system("pause");return(0); }

Le funzioni seguenti. int vfprintf(FILE *stream, const char *format, va_list argptr ); int vprintf(const char *format,va_list argptr ); int vsnprintf(char *buffer, size_t count, const char *format, va_list argptr ); int vsprintf(char *buffer,const char *format,va_list argptr );

C e C++ um 13 di 299

Ognuna di queste funzioni ha come ultimo argomento un valore va_list, quindi hanno un numero variabile di parametri. In pratica, queste funzioni sono usate per scrivere funzioni wrapper, involucro che accettino un numero variabile di parametri che sono passati alla funzione. Funzioni d’input La funzione sscanf legge da una stringa invece che da uno stream, consente quindi di semplificare le operazioni d’input, evitando tutti i problemi della scanf. Ritorna il numero di dati letti, EOF se raggiunge la fine della stringa terminata con il carattere NULL prima di trovare il primo dato. int sscanf (const char *buffer, const char *format [, argument ] ... ); È utile per estrarre dati da una stringa che è stata letta con un’altra funzione d’input. fgets (str,sizeof(str),stdin); /* legge una riga d'input */ sscanf (str,"%d%d",&a,&b) /* estrae due interi */ È possibile esaminare una riga d’input tutte le volte che è necessario e non solamente una. #include #include int main(void) { int giorno=0, mese=0,anno=0; char str[]="31/12/2011" ; system("cls"); if (sscanf (str,"%d /%d /%d",&giorno, &mese, &anno)==3) printf ("Giorno: %d, mese: %d, anno: %d\n",giorno, mese,anno); else if (sscanf (str,"%d -%d -%d",&giorno, &mese, &anno)==3) printf ("Giorno: %d, mese: %d, anno: %d\n",giorno, mese,anno); else printf ("Data non corretta!"); system("pause");return(0); }

Esempio, la scanf ignora l’INVIO e lascia caratteri nel buffer di linea se non trova esattamente ciò che cerca, basta, infatti, eseguire un semplice input di un’intera linea con la gets e poi analizzare questa linea con una sscanf. #include #include #define N 80 /* massimo numero di caratteri letti*/ int main(void) { char str[N+1]; /* array di caratteri dove si salva l'input*/ int c=0, i=0; system("cls"); printf ("Inserisci gli incassi, le spese: "); gets (str);

C e C++ um 14 di 299

sscanf(str,"%d,%d",&c,&i); printf("\n%d %d\n",c,i); system("pause");return (0); }

La sscanf legge dall’array str[] e deve trovare due numeri interi separati da una virgola, i rispettivi valori sono scritti nelle variabili c e i. La correttezza della lettura si verifica esaminando il valore ritornato da sscanf, anche in caso di errore, l’utente ha introdotto esattamente una linea e non ci sono problemi di caratteri avanzati nel buffer di linea. La sscanf è una completa e versatile funzione d’input ma è anche alquanto ingombrante e relativamente lenta. Filtrare i dati in input È indispensabile impedire che l’utente alla richiesta, per esempio, di un numero possa digitare una lettera. int: caratteri validi 0 .. 9. float, double: caratteri validi 0 .. 9 e il “.”. char: caratteri validi A .. Z, a .. z e ( , ; . :). Sequenze di escape Alcuni caratteri speciali, per esempio newline, non possono essere scritti come caratteri tra singoli apici perché non sono stampabili. Per poter utilizzare questi caratteri, il C mette a disposizione una notazione speciale: le sequenze di escape che sono di due tipi. 1. I caratteri di escape. 2. Gli escape numerici: valori decimali, ottali ed esadecimali. Quando il carattere backslash (\) precede un altro carattere, quest’ultimo è interpretato come carattere speciale. \a alert (bell), produce un beep 0x07 \b backspace, una battuta indietro 0x08 \f form feed, pagina nuova 0x0C \n newline, ritorno a capo su una nuova linea 0x0A \r carriage return, ritorno carrello, porta il cursore all’inizio della riga 0x0D \t tab, tabulazione orizzontale 0x09 \v tabulazione verticale 0x0B \\ backslash, barra rovesciata 0x5C \” apici doppi \’ apice singolo, 0x27 \0 NULL, fine stringa \? punto interrogativo Quando l’utente immette l’input e preme INVIO, l’applicazione dovrebbe leggere due caratteri: CR e LF. Per eredità da Unix, il C considera sempre la fine di una riga come delimitata da un singolo carattere di LF. La libreria del C traduce l’INVIO in un carattere LF.

C e C++ um 15 di 299

Conversione di tipo Il C usa solo variabili che siano state precedentemente dichiarate per due motivi. 1. Ottimizzare l’uso della memoria. 2. Aumentare l’affidabilità. Il tipo di una variabile è statico, in altre parole non può essere modificato in esecuzione. Il tipo è assegnato automaticamente in base al valore assegnato alle variabili. Si riferisce alla situazione in cui sono impiegate variabili di tipi differenti all’interno di un’unica espressione. Quando in un’espressione sono utilizzati tipi di dati differenti, il compilatore li converte tutti nello stesso tipo e in particolare nel tipo che occupa più memoria, operazione per operazione come descritto dalle due regole seguenti. 1. È promosso l’operando con il tipo più piccolo, per esempio tutti i float sono convertiti in

double, i char e gli short int in int. 2. Per tutte le coppie di operandi si applica la seguente sequenza: per esempio se un

operando è double, l’altro operando è convertito in double. Dopo che il compilatore ha applicato questa regola, ogni coppia di operandi risulta dello stesso tipo che sarà anche il tipo del risultato. La possibilità di convertire il tipo di una variabile in un altro tipo: si chiama casting. In C la conversione di tipo può avvenire in due modi. 1. Conversione implicita Sono quelle che avvengono senza il rischio di perdita d’informazioni. In un’espressione che usa diversi tipi interi il risultato sarà convertito implicitamente, in altre parole trasparente, dal compilatore. char c; short int s;int i;unsigned int u; long int l; unsigned long int ul; float f;double d; long double ld; i +=c; /* c è convertito in int */ i += s; /* s è convertito in int */ u +=i; /* i è convertito in unsigned int */ l +=u; /* u è convertito in long int */ ul +=l; /* l è convertito in unsigned long int */ f +=ul; /* ul è convertito in float */ d +=f; /* f è convertito in double */ ld +=d; /* d è convertito in long double */ Le conversioni aritmetiche non si applicano alle assegnazioni, il C segue la regola di convertire l’espressione presente nel lato destro dell’assegnazione, nel tipo di variabile presente nel lato sinistro. char c; int i; float f; double d; i =c; /* c è convertito in int */ f =i; /* i è convertito in float */ d =f; /* f è convertito in double */ Gli altri casi sono problematici. #include #include

C e C++ um 16 di 299

int main(void) { int y=0; float x=7.7; system("cls"); y=x; printf ("%d\n",y); system("pause");return(0); }

2. Conversione esplicita Sono quelle che avvengono con perdita d’informazioni perché il tipo di destinazione non è in grado di rappresentare l’intero dominio dei valori del tipo di origine. Il programmatore deve specificare tramite l’operatore di casting l’intenzione di voler compiere una conversione di tipo. Si esegue facendo precedere l’espressione di cui si vuole convertire il valore, dal tipo di destinazione racchiuso tra parentesi tonde. Un’espressione di cast ha la forma seguente. (nome_del_tipo) espressione Dove (nome_del_tipo) specifica il tipo nel quale sarà convertita l’espressione. #include #include int main(void) { int y=0; float x=7.7; double z=0.0; system("cls"); y= (int) x; z=(double)x; printf ("%d\t%f\n",y,z); system("pause");return(0); }

#include #include int main(void) { int a=20, b=7; float c=0.0, d=0.0; system("cls"); c = a/b; d = (float) a/b; printf("a\t\t= %d\n",a); printf("b\t\t= %d\n",b); printf("a/b\t\t= %f\n",c); printf("a/b\t\t= %f\n",d);

C e C++ um 17 di 299

printf("(float) a/b\t= %f\n",d); system("pause");return (0); }

SPECIFICATORI DELLA CLASSE DI MEMORIZZAZIONE Ci sono quattro classi di memorizzazione, in una dichiarazione può comparire al massimo una classe di memorizzazione e, se presente, deve comparire come primo specificatore. Lo scopo è quello di comunicare al compilatore come si desidera che siano mantenute in memoria le variabili. auto Sono memorizzate nello stack, tutte le variabili locali senza alcun specificatore per default sono auto(matic); appartengono a questa classe le variabili locali, se non sono inizializzate in dichiarazione o all’interno del blocco dove sono definite, sono indefinite. extern Nella programmazione modulare esiste il problema di far conoscere a tutti i moduli che compongono il progetto la presenza di variabili globali, questo compito è delegato al linker. Un inconveniente sorge nel caso in cui si dichiara in ogni modulo tutte le variabili globali dell’intera applicazione, in quanto ci sarebbero uno o più casi di omonimia. Il compilatore non è in grado di segnalare la presenza di questo tipo di errore perché ogni modulo è compilato separatamente dagli altri. Questo problema lo incontra il linker perché non sa quale delle variabili omonime dev’essere utilizzata. La soluzione consiste nel dichiarare tutte le varibili in uno solo dei moduli del progetto e nel farle precedere dalla parola chiave extern nei moduli rimanenti, all’inizio sono inizializzate a zero. extern int x, y; static Può essere utilizzata con tutte le variabili, indipendentemente da dove queste siano state dichiarate, all’inizio sono inizializzate a zero. Aiuta ad implementare la tecnica information hiding, in altre parole nascondere deliberatamente alcune informazioni. Una variabile statica dichiarata dentro un blocco risiede nella stessa locazione di memoria durante tutta l’esecuzione dell’applicazione. Le variabili statiche possiedono le seguenti proprietà. Una variabile statica presente in un blocco è inizializzata solamente una volta, prima

dell’esecuzione dell’applicazione. Una variabile statica mantiene il suo valore indefinitamente. Ogni volta che una funzione è chiamata ricorsivamente ottiene un nuovo insieme di

variabili auto ma se possiede una variabile static, questa è condivisa da tutte le chiamate alla funzione.

register Applicata solo ai tipi int e char, dichiarati come variabili locali o PF, le variabili sono

C e C++ um 18 di 299

mantenute all’interno di uno dei registri della CPU, anziché in una cella di memoria, usata nelle variabili di controllo dei cicli. Il compilatore C lo fa automaticamente ma memorizza solo due variabili register perché il numero di registri della CPU è limitato. Funzioni Le dichiarazioni e le definizioni delle funzioni, come le dichiarazioni delle variabili, possono includere una classe di memorizzazione ma le uniche opzioni disponibili sono extern e static.

Preprocessore Il preprocesore obbedisce ai comandi, direttive che iniziano con (#), questo processo è automatizzato perché il preprocessore è integrato nel compilatore. Le direttive terminano sempre con newline, non con il carattere punto e virgola; possono trovarsi in qualsiasi punto dell’applicazione ma è buona regola di programmazione metterle all’inizio. Non sono tradotte in codice macchina ma espandono l’ambiente di programmazione. # /* direttiva nulla */ Per esempio, #define assegna dei nomi alle costanti in questo modo si rendono le applicazioni più leggibili e modificabili facilmente. Per esempio, la direttiva #include dice al preprocessore di aprire un file e d’includere il suo contenuto come parte del file che dev’essere compilato. Quando un progetto include molti header, l’ordine con cui si scrivono le #include non ha alcuna importanza.

L’input del preprocessore è un’applicazione C che contiene direttive. Durante il processo il preprocessore esegue le direttive, l’output del preprocessore è un’altra applicazione C senza le direttive. L’output del preprocessore va in input al compilatore che lo traduce in codice oggetto. Macro predefinite Ogni macro rappresenta una costante intera o stringa. #include #include int main (void) { system("cls"); printf ("FILE: %s\nLINEA: %d\nDATA: %s\nORA: \%s\n",

C e C++ um 19 di 299

__FILE__,__LINE__,__DATE__,__TIME__); system("pause");return(0); }

Compilazione condizionale È una tecnica che permette di fornire al compilatore solo le parti di un’applicazione che devono essere compilate. #if righe che devono essere incluse se expression1 è vera(1) #else righe che devono essere incluse se expression1 è falsa (0) #endif #if #elif righe che devono essere incluse se expression1 è falsa(0) ma expression2 è diversa da 0 #endif Utile nella fase di debugging di un’applicazione. #include #include #define DEBUG 1 int main (void) { system("cls"); #if DEBUG /* l'alternativa è Release */ /* codice da eseguire solo in debug */ printf ("Valore di c: \n"); # else /* altro codice */ #endif system("pause");return(0); }

La #define definisce l’identificatore DEBUG. La #if controlla il valore di DEBUG, il suo valore è vero (1), allora il preprocessore lascia al suo posto la printf; se DEBUG è posto a falso (0), allora il preprocessore rimuove le tre righe di codice dall’applicazione. La #endif termina la direttiva condizionale. La #if tratta gli identificatori non definiti come delle macro con valore falso (0), quindi se non si definisce l’identificatore DEBUG il test fallisce. #include #include

C e C++ um 20 di 299

#define MAX 100 int main (void) { system("cls"); #if MAX>99 printf ("Maggiore.\n"); #else printf ("Minore.\n"); #endif system("pause");return (0); }

Utile per scrivere applicazioni portabili su macchine o SO diversi. All’inizio dell’applicazione dev’essere definita una e una solo macro al fine di selezionare il tipo di SO. #if defined (WIN32) printf("Applicazioni IA32."); #elif defined (MAC_OS) printf("Applicazioni Apple."); #elif defined (LINUX) printf("Applicazioni Ubuntu."); #endif Direttiva #error #if MAX

C e C++ um 21 di 299

Operatore defined Quando è applicato ad un identifiactore produce il valore vero (1) se l’identificatore è definito, falso (0) altrimenti. #if defined (DEBUG) printf ("Definito."); #endif

Librerie Permettono di radunare sottoprogrammi da utilizzare nella gestione di applicazioni complesse. Quando un’applicazione, composta da più moduli oggetto, è linkata, tutto il codice di ogni modulo è compattato per far parte di un unico eseguibile, anche quelle parti di codice che non saranno mai utilizzate. La libreria è costituita da un insieme di funzioni, per cui memorizza il nome, il codice oggetto, le informazioni di rilocazione di ogni funzione. Quando un’applicazione fa riferimento a una funzione contenuta in una libreria, il linker cerca questa funzione e ne aggiunge il codice all’eseguibile. Non è consentito scrivere una funzione che abbia lo stesso nome di una funzione della libreria standard anche quando non s’include l’header al quale appartiene la funzione. Libreria standard Gli header standard consistono di prototipi di funzioni, definizione di tipi e macro. Non si possono utilizzare i nomi di macro definite negli header standard. Gli identificatori che iniziano con il carattere (_) seguito da una lettera maiuscola o da un secondo carrattere (_) sono riservati alla libreria standard. Gestione errori La macro assert, usata come una funzione, permette ad un’applicazione di monitorare il suo comportamento e rilevare i possibili problemi. Ogni volta che è eseguita, controlla expression, se è vera (1), non fa nulla; se è falsa (0) scrive un messaggio su stderr e chiama la funzione abort per terminare l’esecuzione dell’applicazione. void assert(expression); Esempio, controllare l’indice dell’array. #include #include #include int main(void) { int vet[10]; int i=15; system("cls"); assert (0

C e C++ um 22 di 299

Alcune funzioni della libreria standard salvano un codice di errore, un intero positivo, all’interno di errno, una variabile di tipo int che è dichiarata nell’header . Alcune volte il valore contenuto in errno è di fue tipi. 1. Errori di dominio EDOM (Domain error). 2. Errori d’intervallo ERANGE (Result too large). Esempio, controllare la chiamata alla funzione sqrt. #include #include #include #include int main(void) { double x = -16, y=0.0; system("cls"); y=sqrt(x); if (errno !=0) { printf ("sqrt Errore; applicazione terminata.\n"); system("pause"); exit (EXIT_FAILURE); } printf ("%f\n",y); system("pause");return(0); }

Per visualizzare un messaggio che indichi la natura dell’errore si usa la funzione seguente. void perror (const char *s); Esempio. #include #include #include #include

C e C++ um 23 di 299

int main(void) { double x = -16, y=0.0; y=sqrt(x); system("cls"); if (errno !=0) { perror ("sqrt Errore; applicazione terminata"); system("pause");exit (EXIT_FAILURE); } printf ("%f\n",y); system("pause");return(0); }

La funzione stampa nell’ordine i seguenti oggetti. 1. L’argomento. 2. Il carattere due punti. 3. Il carattere spazio. 4. Il tipo di errore determinato dal valore di errno. 5. Il carattere newline. Gestione segnali Gestione delle condizioni eccezionali chiamate segnali, si dividono in due categorie. 1. Errori di run-time: per esempio una divisione per zero. 2. Eventi causati al di fuori dell’applicazione: per esempio l’interruzione dell’applicazione

genera un segnale. La funzione signal installa una funzione per la gestione di un segnale in modo che possa essere utilizzata se in un secondo momento dovesse verificarsi il segnale stesso. Il primo parametro è il codice di un generico segnale, il secondo parametro è un puntatore ad una funzione per la gestione del segnale. void (*signal (int sig, void (*func)(int)))(int); Oltre a progettare un gestore, handler, per i segnali, si possono usare quelli predefiniti. #define SIG_DFL (void (__cdecl *)(int))0 /* default signal action */ #define SIG_IGN (void (__cdecl *)(int))1 /* ignore signal */ #define SIG_GET (void (__cdecl *)(int))2 /* return current value */ #define SIG_SGE (void (__cdecl *)(int))3 /* signal gets error */ #define SIG_ACK (void (__cdecl *)(int))4 /* acknowledge */ #define SIG_ERR (void (__cdecl *)(int))-1 /* signal error value */ Esempio. #include #include #include void SignalHandler(int signal); int main(void) { system("cls"); if (signal(SIGINT,SignalHandler) ==SIG_ERR) perror ("signal(SIGINT),handler) fallito");

C e C++ um 24 di 299

system("pause");return(0); } void SignalHandler(int signal) { printf("Gestore segnali...\n");} Alcune volte per un’applicazione è utile provocare il verificarsi di un dato segnale. int raise (int sig); Esempio, testare i segnali. #include #include #include void SignalHandler(int signal); void RaiseSig (void); int main(void) { void (*OrigHandler)(int); system("cls"); printf ("Installazione del gestore segnali per il segnale %d: \n",SIGINT); OrigHandler=signal(SIGINT,SignalHandler); RaiseSig(); printf ("Store gestore segnali per SIG_IGN\n"); signal(SIGINT,SIG_IGN); RaiseSig(); printf ("Restore gestore segnali originale\n"); signal(SIGINT,SignalHandler); RaiseSig(); system("pause");return(0); } void SignalHandler(int signal) { printf("Gestore segnali chiamato per il segnale: %d\n",signal);} void RaiseSig (void) {raise (SIGINT);}

Localizzazione Localizzazione è una nazione o area geografica nella quale è parlata una particolare lingua e include le seguenti caratteristiche. Formattazione dei numeri: LC_NUMERIC. Formattazione della moneta: LC_MONETARY. Il set di caratteri: ASCII (American Standard Code for Information Interchange), ASCII

esteso, Unicode. Aspetto della data e dell’ora: LC_TIME. La funzione seguente cambia la localizzazione corrente. char *setlocale(int category, const char *locale );

C e C++ um 25 di 299

Esempio. #include #include #include int main(void) { system("cls"); setlocale( LC_ALL, "English" ); setlocale( LC_MONETARY, "French" ); setlocale( LC_ALL, NULL ); system("pause");return(0); } Ritorna informazioni sulla localizzazione corrente. struct lconv *localeconv( void ); Data e ora Permette di determinare l’ora, includendo la data, eseguire aritmetica sulle ore e formattarle per la stampa. Le ore sono memorizzate nei tre modi seguenti. 1. clock_t: un valore orario misurato in tick di clock. 2. time_t: un formato compatto, calendar time, per la codifica dell’ora e della data. 3. struct tm: un valore orario che è stata diviso in secondi, minuti e ore, chiamato broken

down time. clock_t clock( void ); double difftime(time_t timer1, time_t timer0); time_t mktime(struct tm *timeptr); time_t time(time_t *timer); La funzione mktime converte un’ora dal formato broken down al formato calendar. La funzione clock restituisce un valore clock_t rappresentante il tempo di CPU usato dall’applicazione a partire dall’inizio dell’esecuzione. #include #include #include void sleep(clock_t wait); int main( void ) { system("cls"); clock_t inizio =clock(); sleep( (clock_t)3 * CLOCKS_PER_SEC ); printf( "Tempo usato dalla CPU: %g sec.\n", (clock () - inizio) / (double)CLOCKS_PER_SEC ); system("pause");return(0); } /* pausa per uno specifico numero di millisecondi */ void sleep( clock_t wait ) { clock_t goal; goal = wait + clock(); while( goal > clock() ); }

C e C++ um 26 di 299

Per convertire questo valore in secondi si deve dividerlo per CLOCKS_PER_SEC. Per determinare il tempo di esecuzione occorre chiamarla due volte: una all’inizio del main e una alla fine. La ragione della chiamata iniziale è che l’applicazione utilizzerà un po’ di tempo di CPU prima di raggiungere il main a causa del codice nascosto di start-up. La funzione difftime restituisce la differenza espressa in secondi tra due time, è usata per calcolare il tempo di esecuzione dell’applicazione, non il tempo di CPU. #include #include #include int main( void ) { time_t app, fine; double elapsed_time=0.0; system("cls"); /* inizio calcolo tempo di esecuzione dell'applicazione */ printf( "Moltiplico 2 numeri reali ...\n" ); time( &app); /* inizio calcolo tempo di CPU */ clock_t cpu =clock(); for(long loop = 0; loop < 500000000; loop++ ) double result = 3.63456789 * 5.274567123; printf( "Tempo usato dalla CPU:\t\t%6.0f secondi.\n", (clock () - cpu) / (double)CLOCKS_PER_SEC ); /* fine calcolo tempo di CPU */ time( &fine ); elapsed_time = difftime( fine, app ); printf( "Tempo usato dall'applicazione:\t%6.0f secondi.\n", elapsed_time ); /* fine calcolo tempo di esecuzione dell'applicazione */ system("pause");return(0); }

Esempio di funzione time. #include #include #include int main(void) { char tmpbuf[128], timebuf[26], ampm[] = "AM"; system("cls"); time_t ltime; _strtime_s( tmpbuf, 128 ); printf( "Ora del sistema operativo:\t%s\n", tmpbuf ); _strdate_s( tmpbuf, 128 ); printf( "Data del sistema operativo:\t%s\n", tmpbuf ); time( &ltime );

C e C++ um 27 di 299

/* Universal Time Coordinated */ printf( "Tempo in secondi UTC:\t\t%ld\n", ltime ); system("pause");return(0); }

Le funzioni seguenti convertono ore di tipo calendar in ore di tipo broken down. char *asctime(const struct tm *timeptr); char *ctime(const time_t *timer); struct tm *gmtime(const time_t *timer); struct tm *localtime(const time_t *timer); size_t strftime(char *strDest,size_t maxsize,const char *format,const struct tm *timeptr); ISO (International Standard Organization) 8061 È lo standard che descrive i modi per rappresentare la data, YYYY-MM-DD e l’ora, HH:MM:SS, sono numeriche e le ore espresse con le 24 ore. Esempio, visualizzare la data e l’ora. #include #include #include int main( void ) { time_t corrente = time(NULL); struct tm *ptr; char data_ora[21]; int ore=0; char a; system("cls"); /* stampa la data e l'ora nel formato di default */ puts (ctime(&corrente)); /* stampa la data e l'ora con la strftime */ strftime(data_ora,sizeof(data_ora),"%m-%d-%Y %I:%M %p\n",localtime(&corrente)); puts (data_ora); /* stampa la data e l'ora con la printf */ ptr=localtime(&corrente); ore=ptr->tm_hour; if (oretm_mon+1,ptr->tm_mday,ptr->tm_year+1900,ore,ptr->tm_min,a); system("pause");return(0); }

C e C++ um 28 di 299

FUNZIONI PER LA GENERAZIONE DI SEQUENZE PSEUDO CASUALI Utili nelle applicazioni di simulazione e nei giochi. La gestione si trova nell’header e fornisce due tipi di funzioni. int rand(void); void srand(unsigned int seed ); Ogni volta che è chiamata rand restituisce un numero compreso tra 0 e RAND_MAX, i numeri non sono veramente casuali ma sono generati a partire da un seme, seed. La funzione srand fornisce il seme per la rand, se la rand è chiamata prima della srand, il valore del seme è assunto uguale a 1, ogni seme determina una particolare sequenza di numeri pseudo casuali, la srand permette al programmatore di selezionare qualsiasi sequenza. È buona regola di programmazione rendere casuale il valore usato per il seme, per fare questo basta chiamare la funzione time che restituisce un numero che codifica la data e l’ora corrente. #include #include #include int main(void) { system("cls"); /* inizia sessione random */ srand(time(NULL)); /* numero compreso tra 1 e 10 */ unsigned int r = rand() % 10 + 1; printf("Il numero generato casualmente tra 1 e 10 vale: %d\n", r); system("pause");return (0); }

#include #include #include #define N 5 int main(void) { system("cls"); /* inizia sessione random */ srand(time(NULL)); for (int i = 0; i

C e C++ um 29 di 299

}

Esempio, generazione di un numero casuale compreso tra 0 e 99. #include #include #include int main(void) { unsigned int n=0; system("cls"); printf("Generazione di un numero casuale.\n\n"); printf ("Premere un tasto qualsiasi per generare.\n\n"); while (!kbhit()) n += 7; /* n è aumentata di 7 a ogni iterazione, quando si esce si prende il resto della divisione */ n %= 100; printf("Numero generato = %d\n\n", n); system("pause");return(0); }

Esempio. #include #include #include #define N 10 void SimpleRandDemo(void); void RangedRandDemo(int range_min, int range_max); int main(void) { system("cls"); srand((unsigned)time(NULL)); SimpleRandDemo(); printf("\n"); RangedRandDemo(1, 100); system("pause"); return(0); } /* stampa 10 numeri pseudo casuali */ void SimpleRandDemo(void) { for (int i = 0; i < N; ++i) printf("%6d\n", rand()); }

C e C++ um 30 di 299

/* genera 10 numeri nell'intervallo (range-min

C e C++ um 31 di 299

++l||a[i]

C e C++ um 32 di 299

MODULO 2

MICROSOFT VISUAL C++ Microsoft Visual C Tools Visual Studio C++ Microsoft Visual C++ Microsoft Visual C++ CLR

C e C++ um 33 di 299

MICROSOFT VISUAL C

COMPILAZIONE CLI

C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC>cl /help Microsoft (R) C/C++ Optimizing Compiler versione 19.00.23026 per x64 Copyright (C) Microsoft Corporation. Tutti i diritti riservati. OPZIONI DEL COMPILATORE C/C++ -OTTIMIZZAZIONE- /O1 Riduce al minimo lo spazio /O2 Ottimizza la velocità /Ob Espansione inline (n predefinito=0) /Od Disabilita le operazioni di ottimizzazione (predefinita) /Og Abilita l'ottimizzazione globale /Oi[-] Abilita le funzioni intrinseche /Os Ottimizza lo spazio del codice /Ot Ottimizza la velocità del codice /Ox Combina le opzioni di ottimizzazione /favor: seleziona il processore per cui effettuare l'o ttimizzazione. Scegliere una delle seguenti opzioni: blend Combinazione di ottimizzazioni per più processori x64 diversi AMD64 Processori AMD a 64 bit INTEL64 Processori con architettura Intel(R)64 ATOM - processori Intel(R) Atom(TM) -GENERAZIONE DEL CODICE- /GF Abilita la condivisione delle stringhe in sola lettura /Gm[-] Abilita la ricompilazione minima /Gy[-] Separa le funzioni per il linker /GS[-] Abilita i controlli di sicurezza /GR[-] Abilita RTTI di C++ /GX[-] Abilita EH (equivalente a /EHsc) di C++ /EHs Abilita EH (senza eccezioni SEH) di C++ /EHa Abilita EH con eccezioni SEH) di C++ /EHc Usa nothrow come impostazione predefinita di extern "C" /fp: Scegliere il modello a virgola mobile: except[-] Considera le eccezioni di virgola mobile durante la generazione del codice fast Modello a virgola mobile "fast"; i risultati sono meno prevedibili precise Modello a virgola mobile "precise"; i risultati sono prevedibili strict Modello a virgola mobile "strict" (implica /fp:except) /Qfast_transcendentals Genera intrinseci FP inline anche con /fp:except /Qpar[-] enable parallel code generation /Qpar-report:1 auto-parallelizer diagnostic; indicate parallelized loops /Qpar-report:2 auto-parallelizer diagnostic; indicate loops not parallelized /Qvec-report:1 auto-vectorizer diagnostic; indicate vectorized loops /Qvec-report:2 auto-vectorizer diagnostic; indicate loops not vectorized /GL[-] enable link-time code generation /volatile: choose volatile model: iso - Acquire/release semantics not guaranteed on volatile accesses ms - Acquire/release semantics guaranteed on volatile accesses /GA Ottimizza per l'applicazione Windows /Ge Impone il controllo dello stack per tutte le funzioni

C e C++ um 34 di 299

/Gs[num] Controlla le chiamate di verifica dello stack /Gh Abilita la chiamata di funzione _penter /GH Abilita la chiamata di funzione _pexit /GT Genera accessi TLS indipendenti da fiber /RTC1 Abilita i controlli rapidi (/RTCsu) /RTCc Converte in controlli di tipo più limitato /RTCs Verifica runtime dello stack frame /RTCu Controlli di utilizzo locale non inizializzati /clr[:opzione] Compila per Common Language Runtime, dove opzione è: pure Produce un file di output solo IL (senza codice eseguibile nativo) safe Produce un file di output verificabile solo IL oldSyntax Accetta la sintassi delle estensioni gestite di Visual C++ 2002/2003 initialAppDomain Abilita il comportamento AppDomain iniziale di Visual C++ 2002 noAssembly Non produce un assembly nostdlib - ignora la directory \clr predefinita /homeparams Impone la scrittura nello stack dei parametri passati nei registri /GZ Abilita i controlli dello stack (/RTCs) /arch:AVX Consente di utilizzare le istruzioni delle estensioni Intel(R) Advance d Vector Extension -FILE DI OUTPUT- /Fa[file] Specifica un file di listato dell'assembly /FA[scu] Configura il listato dell'assembly /Fd[file] Specifica un file PDB /Fe Specifica un file eseguibile /Fm[file] Specifica un file map /Fo Specifica un file oggetto /Fp Specifica un file di intestazione precompilata /Fr[file] Specifica il file di origine del browser /FR[file] Specifica un file SBR esteso /Fi[file] Specifica un file pre-elaborato /doc[file] Elabora i commenti relativi alla documentazione XML ed eventualmente specifica il file XDC -PREPROCESSORE- /AI Specifica il percorso di ricerca dell'assembly /FU Impone l'utilizzo di assembly/modulo /C Non rimuove i commenti /D{=|#} Definisce una macro /E Pre-elabora in stdout /EP Pre-elabora in, senza istruzione #line /P Pre-elabora nel file /Fx Esegue il merge del codice inserito al file /FI Specifica il file di inclusione da utilizzare /U Rimuove la macro definita in precedenza /u Rimuove tutte le macro definite in precedenza /I Specifica il percorso di ricerca/X Ignora "posizioni standard" -LINGUAGGIO- /Zi Abilita le informazioni di debug /Z7 Abilita informazioni di debug obsolete /Zp[n] Comprime le strutture allineandole su un limite di n byte /Za Disabilita le estensioni /Ze Abilita le estensioni (predefinita) /Zl Omette il nome della libreria predefinita in OBJ /Zg Genera i prototipi delle funzioni /Zs Solo controllo della sintassi /vd{0|1|2} Abilita/disabilita vtordisp /vm Tipo di puntatori ai membri /Zc:arg1[,arg2] Conformità al linguaggio C++, i cui argomenti possono essere: forScope[-] Impone C++ standard per le regole di ambito wchar_t[-] wchar_t è il tipo nativo, non un typedef auto[-] Impone il nuovo significato di C++ standard per auto

C e C++ um 35 di 299

trigraphs[-] Abilita i trigrammi (disattivato per impostazione predefinita) /ZW abilita le estensioni del linguaggio WinRT /openmp Abilita le estensioni del linguaggio OpenMP 2.0 -VARIE- @ Opzioni dei file di risposta /?, /help Visualizza questo argomento della Guida /bigobj Genera il formato di oggetto esteso /c Solo compilazione, nessun collegamento /errorReport:opzione Segnala a Microsoft gli errori interni del compilatore none Non invia la segnalazione prompt Richiede l'invio immediato della segnalazione queue Al successivo accesso di amministratore, richiede l'invio della segnalazione (predefinita) send Invia la segnalazione automaticamente /FC Utilizza i percorsi completi nella diagnostica /H Lunghezza massima dei nomi esterni Il tipo char predefinito /J è unsigned /MP[n] Utilizza fino a 'n' processi per la compilazione /nologo Non visualizza le informazioni sul copyright /sdl abilita ulteriori avvisi e funzionalità di sicurezza /showIncludes Visualizza i nomi dei file di inclusione /Tc Compila il file come file .c /Tp Compila il file come file .cpp /TC Compila tutti i file come file .c /TP Compila tutti i file come file .cpp /V Imposta la stringa di versione /w Disabilita tutti gli avvisi /wd Disabilita l'avviso n /we Considera l'avviso n come un errore /wo Riporta l'avviso n una sola volta /w Imposta il livello di avviso 1-4 per n /W Imposta il livello di avviso (valore predefinito n=1) /Wall Abilita tutti gli avvisi /WL Abilita le informazioni di diagnostica su una sola riga /WX Considera gli avvisi come errori /Yc[file] Crea un file PCH /Yd Inserisce informazioni di debug in ogni OBJ /Yl[sym] Inserisce riferimenti PCH per la libreria di debug /Yu[file] Utilizza il file PCH /Y- Disabilita tutte le opzioni PCH /Zm Massima allocazione di memoria (% del valore predefinito) /Wp64 Abilita gli avvisi relativi alla portabilità a 64 bit - COLLEGAMENTO - /LD Crea un file .DLL /LDd Crea un libreria di debug .DLL /LN Crea un .netmodule /F Imposta la dimensione dello stack /link [librerie e opzioni del linker] /MD Effettua il collegamento con MSVCRT.LIB /MT Effettua il collegamento con LIBCMT.LIB /MDd Effettua il collegamento con la libreria di debug MSVCRTD.LIB /MTd Effettua il collegamento con la libreria di debug LIBCMTD.LIB

C e C++ um 36 di 299

APPLICAZIONE CONSOLE Sono semplici da costruire, non hanno grafica e hanno interfaccia CUI (Character User Interface) che permette all’utente d’interagire con la tastiera e una finestra. /* Nome dell’applicazione: hello.c Programmatore: Descrizione: */ #include #include int main (void) { printf ("Ciao, mondo in .NET\n"); system("pause");return(0); }

PREPROCESSORE Usare l’opzione seguente dall’ambiente MDE (Microsoft Development Environment), per ottenere un file con estensione .I. Selezionare il menu Progetto/Proprietà….

C e C++ um 37 di 299

TOOLS

LINK.EXE C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC>link /? Microsoft (R) Incremental Linker Version 14.00.23026.0 Copyright (C) Microsoft Corporation. All rights reserved. uso: LINK [opzioni] [file] [@commandfile] opzioni: /ALIGN:# /ALLOWBIND[:NO] /ALLOWISOLATION[:NO] /APPCONTAINER[:NO] /ASSEMBLYDEBUG[:DISABLE] /ASSEMBLYLINKRESOURCE:nomefile /ASSEMBLYMODULE:nomefile /ASSEMBLYRESOURCE:nomefile[,[nome][,PRIVATE]] /BASE:{indirizzo[,dimensione]|@nomefile,chiave} /CLRIMAGETYPE:{IJW|PURE|SAFE|SAFE32BITPREFERRED} /CLRLOADEROPTIMIZATION:{MD|MDH|NONE|SD} /CLRSUPPORTLASTERROR[:{NO|SYSTEMDLL}] /CLRTHREADATTRIBUTE:{MTA|NONE|STA} /CLRUNMANAGEDCODECHECK[:NO] /DEBUG /DEF:nomefile /DEFAULTLIB:libreria /DELAY:{NOBIND|UNLOAD} /DELAYLOAD:dll /DELAYSIGN[:NO] /DLL /DRIVER[:{UPONLY|WDM}] /DYNAMICBASE[:NO] /ENTRY:simbolo /ERRORREPORT:{NONE|PROMPT|QUEUE|SEND} /EXPORT:simbolo /FIXED[:NO] /FORCE[:{MULTIPLE|UNRESOLVED}] /FUNCTIONPADMIN[:dimensione] /HEAP:reserve[,commit] /HIGHENTROPYVA[:NO] /IDLOUT:nomefile /IGNOREIDL /IMPLIB:nomefile /INCLUDE:simbolo /INCREMENTAL[:NO] /KERNEL /KEYCONTAINER:nome /KEYFILE:nomefile /LARGEADDRESSAWARE[:NO] /LIBPATH:dir /LTCG[:{NOSTATUS|PGINSTRUMENT|PGOPTIMIZE|PGUPDATE|STATUS}] /MACHINE:{ARM|EBC|X64|X86}

C e C++ um 38 di 299

/MANIFEST[:{EMBED|NO}] /MANIFESTDEPENDENCY:dipendenza manifesto /MANIFESTFILE:nomefile /MANIFESTINPUT:nomefile /MANIFESTUAC[:{NO|UAC fragment}] /MAP[:nomefile] /MAPINFO:{EXPORTS} /MERGE:da=a /MIDL:@filedicomandi /NOASSEMBLY /NODEFAULTLIB[:libreria] /NOENTRY /NOLOGO /NXCOMPAT[:NO] /OPT:{ICF[=iterations]|NOICF|NOREF|REF} /ORDER:@nomefile /OUT:nomefile /PDB:nomefile /PDBSTRIPPED:filename /PGD:filename /POGOSAFEMODE /PROFILE /RELEASE /SAFESEH[:NO] /SECTION:nome,[[!]{DEKPRSW}][,ALIGN=#] /STACK:reserve[,commit] /STUB:filename /SUBSYSTEM:{BOOT_APPLICATION|CONSOLE|EFI_APPLICATION| EFI_BOOT_SERVICE_DRIVER|EFI_ROM|EFI_RUNTIME_DRIVER| NATIVE|POSIX|WINDOWS}[,#[.##]] /SWAPRUN:{CD|NET} /TLBID:# /TLBOUT:nomefile /TSAWARE[:NO] /VERBOSE[:{CLR|ICF|INCR|LIB|REF|SAFESEH|UNUSEDLIBS}] /VERSION:#[.#] /WINMD[:{NO|ONLY}] /WINMDDELAYSIGN[:NO] /WINMDFILE:nomefile /WINMDKEYCONTAINER:name /WINMDKEYFILE:filename /WX[:NO]

C e C++ um 39 di 299

Usare l’opzione seguente dall’ambiente MDE, per ottenere un file con estensione .MAP. Selezionare il menu Progetto/Proprietà….

File HELLO.MAP hello Timestamp is 55d96d67 (Sun Aug 23 08:51:19 2015) Preferred load address is 0000000140000000 Start Length Name Class 0001:00000000 00010000H .textbss DATA 0002:00000000 00005520H .text$mn CODE 0002:00005520 00001016H .text$mn$00 CODE 0002:00006540 000010f1H .text$x CODE 0003:00000000 00000109H .CRT$XCA DATA ……………………………………………………………… 0008:00000170 000002ccH .rsrc$02 DATA Address Publics by Value Rva+Base Lib:Object 0000:00000000 ___safe_se_handler_table 0000000000000000 0000:00000000 __ImageBase 0000000140000000 ……………………………………………………………………………….. 0001:00000000 __enc$textbss$begin 0000000140001000 0001:00010000 __enc$textbss$end 0000000140011000 0002:00000bb0 _RTC_Shutdown 0000000140011bb0 f MSVCRTD:_init_.obj

CVTRES.EXE C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC>cvtres /? Microsoft (R) Windows Resource To Object Converter versione 14.00.23026.0 Copyright (C) Microsoft Corporation. Tutti i diritti riservati. sintassi: CVTRES [opzioni] [file] opzioni: /DEFINE:simbolo /FOLDDUPS /MACHINE:{ARM|EBC|IA64|X64|X86} /NOLOGO /OUT:nomefile /READONLY /VERBOSE

C e C++ um 40 di 299

DUMPBIN.EXE C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC>dumpbin /? Microsoft (R) COFF/PE Dumper Version 14.00.23026.0 Copyright (C) Microsoft Corporation. All rights reserved. uso: DUMPBIN [opzioni] file opzioni: /ALL /ARCHIVEMEMBERS /CLRHEADER /DEPENDENTS /DIRECTIVES /DISASM[:{BYTES|NOBYTES}] /ERRORREPORT:{NONE|PROMPT|QUEUE|SEND} /EXPORTS /FPO /HEADERS /IMPORTS[:nomefile] /LINENUMBERS /LINKERMEMBER[:{1|2}] /LOADCONFIG /OUT:nomefile /PDATA /PDBPATH[:VERBOSE] /RANGE:vaMin[,vaMax] /RAWDATA[:{NONE|1|2|4|8}[,#]] /RELOCATIONS /SECTION:nome /SUMMARY /SYMBOLS /TLS /UNWINDINFO

EDITBIN.EXE C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC>editbin /? Microsoft (R) COFF/PE Editor Version 14.00.23026.0 Copyright (C) Microsoft Corporation. All rights reserved. uso: EDITBIN [opzioni] [file] opzioni: /ALLOWBIND[:NO] /ALLOWISOLATION[:NO] /APPCONTAINER[:NO] /BIND[:PATH=path] /DYNAMICBASE[:NO] /ERRORREPORT:{NONE|PROMPT|QUEUE|SEND} /HEAP:reserve[,commit] /HIGHENTROPYVA[:NO] /LARGEADDRESSAWARE[:NO] /NOLOGO /NXCOMPAT[:NO] /REBASE[:[BASE=address][,BASEFILE][,DOWN]] /RELEASE /SECTION:name[=newname][,[[!]{CDEIKOMPRSUW}][A{1248PTSX}]] /STACK:reserve[,commit]

C e C++ um 41 di 299

/SUBSYSTEM:{BOOT_APPLICATION|CONSOLE|EFI_APPLICATION| EFI_BOOT_SERVICE_DRIVER|EFI_ROM|EFI_RUNTIME_DRIVER| NATIVE|POSIX|WINDOWS}[,#[.##]] /SWAPRUN:{[!]CD|[!]NET} /TSAWARE[:NO] /VERSION:#[.#]

PGOCVT.EXE C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC>pgocvt /? Microsoft (R) Profile Guided Optimization Database to Object Converter 14.00.23026.0 Copyright (C) Microsoft Corporation. Tutti i diritti riservati. uso: PGOCVT [opzioni] [file] opzioni: /NOLOGO /OUT:nomefile /MACHINE:computerdidestinazione /VERBOSE

PGOMGR.EXE C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC>pgomgr /? Microsoft (R) Profile Guided Optimization Manager 14.00.23026.0 Copyright (C) Microsoft Corporation. Tutti i diritti riservati. uso: PGOMGR [opzioni] [Percorsi-conteggio-profili...] Database-profilo opzioni: /? Visualizza questo argomento della Guida /help Visualizza questo argomento della Guida /clear Rimuove tutti i dati di unione da questo database /detail Visualizza statistiche dettagliate sul programma /merge[:n] Unisce i file PGC specificati, con il peso integer opzionale /summary Visualizza le statistiche sul programma /unique Visualizza i nomi decorati delle funzioni

PGOSWEEP.EXE C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC>pgosweep /? Microsoft (R) Profile Guided Optimization Sweeping Utility 14.00.23026.0 Copyright (C) Microsoft Corporation. Tutti i diritti riservati. uso: PGOSWEEP [opzioni] Nome-PGC-output-eseguibile-instrumentato opzioni: /? Visualizza questo argomento della Guida /help Visualizza questo argomento della Guida /noreset Non reimposta a zero i conteggi dopo lo sweep

UNDNAME.EXE C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC>undname /? Microsoft (R) C++ Name Undecorator Copyright (C) Microsoft Corporation. All rights reserved. Usage: undname [flags] fname [fname...] or: undname [flags] file

C e C++ um 42 di 299

VISUAL STUDIO

SVILUPPO DI APPLICAZIONI Console. Windows Forms. WPF (Windows Presentation Foundation). WCF (Windows Communication Foundation). EF (Entity Framework). LINQ (Language INtegrated Query). Programmazione parallela. Office. SharePoint. Web: ASP.NET (Active Server Pages). Silverlight. Cloud computing: Windows Azure.

Estensioni Visual Studio è estendibile con funzionalità che possono essere aggiunte mediante l’installazione di add-in che possono essere realizzati in proprio, creando apposite applicazioni attraverso lo stesso ambiente di sviluppo di Visual Studio. Oppure possono essere scaricati e installati, visitando l’apposito portale su Internet, da un repository creato appositamente e denominato Visual Studio Gallery. Alcuni add-in sono commerciali e sono forniti in versione in prova. Nell’angolo superiore destro della pagina si trova una casella a discesa che permette di scegliere la lingua preferita, compreso l’italiano. Cliccando sul nome di un add-in, si apre una pagina che permette di esaminare le caratteristiche dell’add-in stesso, la versione di Visual Studio su cui può essere installato, la votazione degli utenti, il numero di volte che è stato scaricato, la versione attuale, la data e ora dell’ultimo aggiornamento, l’indicazione se è un prodotto gratuito o in prova.

C e C++ um 43 di 299

C’è il pulsante che permette di scaricare e installare l’add-in. Sviluppo di applicazioni mobili e videoludiche: XNA (XNA is Not Acronymed).

C e C++ um 44 di 299

DynamicDataDisplay È gratis, libreria di controlli WPF e Silverlight per la visualizzazione dinamica e grafica di dati. Le simulazioni che sono messe a disposizione arrivando a tracciare i punti in continuazione, cambiando la scala del grafico man mano che sono aggiunti i punti. L’esempio MapSample permette di visualizzare una mappa mondiale, scendendo fino al livello delle strade cittadine e mostra in una lente d’ingrandimento i dettagli.

L’esempio CoastlineSampleApp permette di visualizzare la linea delle coste di tutto il mondo. L’esempio IsolineSampleApp permette di visualizzare le isolinee, linee appartenenti allo stesso piano, muovendo il mouse sul grafico.

C e C++ um 45 di 299

Fare clic su Strumenti/Estensioni e aggiornamenti….

NuGet È uno strumento di Visual Studio che permette d’integrare nelle applicazioni delle librerie sviluppate da terzi. Fare clic su Strumenti/Gestione pacchetti NuGet/Impostazioni di Gestione pacchetti.

C e C++ um 46 di 299

MDE Ambiente integrato: è possibile gestire l’intero ciclo di sviluppo di applicazioni di qualsiasi tipo esse siano, racchiude l’editor per tutti i linguaggi di programmazione supportati dalla piattaforma .NET. Visual Studio è un’applicazione MDI (Multiple Document Interface), in grado di consentire l’apertura contemporanea di più documenti, all’interno di schede. È possibile realizzare applicazioni utilizzando più linguaggi all’interno della stessa soluzione perché condividono anche la stessa organizzazione dei file sorgenti. Start/Tutte le app/Visual Studio 2015

È possibile personalizzare l’ambiente di sviluppo tramite macro scritte con VBA, utilizzando un editor analogo a quello disponibile in Office. L’area di lavoro è suddivisa in zone, dove nella parte centrale si trova l’editor. Progetto È l’insieme dei file (sorgenti e risorse) che concorrono alla creazione dell’applicazione. Visual studio contiene un numero elevato di template: insieme già pronto di file configurati per sviluppare uno specifico tipo di progetto, raggruppati in aree così che sia più facile individuarli. Soluzione È l’insieme di più progetti, nelle applicazioni semplici la soluzione contiene un solo progetto, in scenari più complessi ci sono più progetti all’interno della soluzione. Per aggiungere un nuovo progetto alla soluzione, fare clic su File/Aggiungi/Nuovo progetto…. Per aggiungere un progetto esistente alla soluzione, fare clic su File/Aggiungi/Progetto

C e C++ um 47 di 299

esistente…. Quando una Soluzione è composta da più progetti, il progetto di default all’avvio, è quello in grassetto, per modificare il progetto di avvio, fare clic in Esplora soluzioni e dal menu contestuale selezionare la voce Imposta come progetto di avvio.

È possibile cambiare in qualsiasi momento il nome della soluzione e dei progetti. Nel caso di questi ultimi, occorre prestare attenzione al fatto che per cambiare il nome del namespace è necessario accedere al menu Progetto/Proprietà…. Cambiare il nome degli elementi all’interno di Esplora soluzioni è la scelta migliore, perché ha effetto sul nome fisico del file e consente di mantenere intatta e valida la struttura della soluzione. Avviando per la prima volta Visual Studio, sarà visualizzata nella parte centrale della finestra una serie di opzioni utili per personalizzare l’ambiente di sviluppo; esse saranno comunque accessibili anche in futuro all’interno della finestra Strumenti/Opzioni... Per esempio, la possibilità di usare l’accelerazione H/W che è automaticamente abilitata.

Possibilità di modificare la disposizione di finestre e pannelli grazie ai gadget per l’ancoraggio che appaiono quando si trascinano le finestre, lo strumento appare come una croce che indica quale posizione avrà la finestra rispetto al pannello sottostante. Ad esempio, se si rilascia il tasto del mouse sul simbolo al centro della croce, si sovrappone la finestra trascinata a quella sottostante e si crea così un pannello con più schede, per passare da una finestra all’altra si usano le relative linguette.

C e C++ um 48 di 299

Una volta personalizzato l’ambiente di sviluppo, c’è la possibilità di conservare e riapplicare tutte le preferenze, grazie alle funzionalità di Strumenti/Importa/Esporta impostazioni… che permette anche di effettuare il reset di tutte le impostazioni. Questo consente di utilizzare impostazioni diverse a seconda del progetto su cui si sta lavorando. C’è il supporto a chi ha più di un monitor, è possibile estrarre dal layout anche le finestre di codice e spostarle tra i diversi schermi. La possibilità di visualizzare contemporaneamente più finestre di codice, designer, permette una visione d’insieme senza precedenti. Per creare un nuovo progetto, fare clic su File/Nuovo/Progetto… (CTRL+MAIUSC+N). È visualizzata la finestra di dialogo seguente, è possibile scegliere anche un progetto da un elenco di modelli online.

Multi targeting Nella parte superiore della finestra è possibile scegliere il .NET Framework che si vuole utilizzare, versioni 2.0, 3.0, 3.5, 4.0, 4.5; in base alla versione scelta, si troveranno nella finestra di dialogo solamente i progetti compatibili

C e C++ um 49 di 299

Esplora soluzioni Fare clic su Visualizza/Esplora soluzioni (CTRL+ALT+L), presenta l’organizzazione gerarchica dei componenti del progetto con nome, finestre, codice e moduli.

È possibile utilizzare nella soluzione delle cartelle che non siano progetti ma possano servire per includere risorse o documentazione, fare clic sul nome della soluzione con il pulsante destro del mouse e dal menu contestuale selezionare Aggiungi/Nuovacartella. I file contenuti in queste cartelle non saranno compilati. A capo automatico Fare clic su Modifica/Avanzate/A capo automatico. Tutte le righe di codice che superano la lunghezza dell’editor sono automaticamente mandate a capo, per evitare la necessità di scorrere lateralmente la finestra dell’editor. Segnalibri Fare clic su Modifica/Segnalibri/Attiva/Disattiva segnalibro (CTRL+K+T). Numeri di riga Fare clic su Strumenti/Opzioni…/Editor di testo/C#/Editor/Numeri di riga. I numeri di riga sono aggiunti al codice. Editor Le varie parti del codice possono essere compresse ed espanse facendo clic rispettivamente sul simbolo (-) e (+) che è automaticamente visualizzato a destra delle dichiarazioni di un metodo, di un insieme di righe di commento.

È possibile effettuare lo zoom del codice tenendo premuto il tasto CTRL e usando la rotellina del mouse, utile se si è in presenza di un metodo molto lungo, si può ridurre il livello di zoom

C e C++ um 50 di 299

temporaneamente per tenere sotto occhio una parte di codice più ampia.

IntelliSense Permette d’inserire del codice li dove è prevedibile che sia inserito. Semplifica il completamento automatico d’istruzioni di codice evitando di digitare parole intere, si attiva non appena s’inizia a digitare nell’editor, altrimenti digitare CTRL+SPAZIO. Argomenti dalla linea di comando Fare clic su Progetto/Proprietà….

Compilazione Il risultato è contenuto nella cartella BIN, posta sotto il progetto. Può essere eseguita in due modi. Compila (F6).

C e C++ um 51 di 299

Eseguendo l’applicazione Debug/Avvia senza eseguire debug (CTRL+F5), anche con il debugger Debug/Avvia debug (F5).

Cartella superiore Se non si conosce il percorso del progetto, basta fare clic con il tasto destro sul nome del codice e selezionare Apri cartella superiore per vedere la cartella con esplora risorse.

Configurazione Quando si crea una nuova soluzione, ci sono già pronte due configurazioni. Debug: indicata solo per lo sviluppo perché non è ottimizzata per la produzione. Release: indicata per compilare e gestire la soluzione per la distribuzione.

C e C++ um 52 di 299

DEBUG Maggiori sono le dimensioni delle applicazioni e le caratteristiche da implementare, maggiori sono le possibilità d’incorrere in errori, detti, in gergo, bug dal verbo debug (to) che significa mettere a punto, in pratica è un processo per riconoscere e correggere errori. Dal progetto alla realizzazione possono essere variate sia le condizioni generali sia le specifiche di base dell’applicazione; il cambiamento di queste ultime è una fonte inesauribile di errori, in altri casi gli errori sembrano presentarsi in modo casuale. Per scovare questi errori, sarebbe molto comodo possedere uno strumento che permetta di scorrere il sorgente riga per riga, controllando, se possibile in una finestra attigua, il valore assunto dalle variabili da tenere sotto controllo. In via generale la fase di debugging si articola nei seguenti quattro passi. 1. Verifica dell’esistenza di un errore, i casi macroscopici si hanno quando la macchina si

“pianta”, altre volte l’applicazione gira correttamente fino a quando non ha a che fare con un numero, o carattere, critico al quale è associato l’errore.

2. Ricerca della posizione dell’errore, questo è più difficile quanto più lunga è l’applicazione, allora conviene sezionarla e individuare quale parte contiene l’errore, la programmazione modulare si sposa perfettamente con questa metodologia di lavoro perché permette di testare singolarmente i vari moduli.

3. Ricerca della causa dell’errore. 4. Correzione dell’errore. Fatal Immediata interruzione. Error Impediscono la generazione dei file OBJ e EXE ma l’esecuzione è completata. Syntax error/Compile-time errors Sono errori di sintassi che gli strumenti di sviluppo possono rintracciare, per esempio l’onda rossa è l’indicatore di errore di sintassi. Si verificano quando un’istruzione non è scritta nel modo corretto e sono segnalati prima che l’applicazione vada in run-time perché sono rilevati in compile-time. Cursore in edit sulla riga dell’errore, nella finestra Elenco errori riga c’è il messaggio relativo.

Warning Condizioni sospette, effetti non voluti genera in ogni caso i file OBJ e EXE.

C e C++ um 53 di 299

Run-time errors Errori di semantica. Errori logici Fa ciò che gli avete detto di fare, anziché ciò che volevate che facesse. Dijkstra Non si può sostenere che un’applicazione è buona solo perché ha superato dei test. Un test può essere. Selettivo: non garantisce la validità perché i dati d’input sono di natura soggettiva. Esaustivo: impossibile assegnare tutti i valori ai dati d’input perché il tempo di verifica

tenderebbe ad esplodere. Quando un’applicazione comincia ad essere rattoppata al punto, di perdere la sua struttura è più semplice riscriverla. I debugger sono programmi che caricano a loro volta le applicazioni da sottoporre a verifiche. Visual Studio include un debugger, fare clic su Debug/