L'array decade *sempre* nel puntatore al primo elemento, *meno* che in tre casi specifici: quando e' argomento di sizeof, quando e' argomento di & (operatore address-of) e quando e' un literal string di inizializzazione di un vettore. 3) char *p = "andrea"; a p viene assegnato un indirizzo di memoria, tant'e' vero che non e' neanche detto tu possa modificare il contenuto della memoria puntata da p. Invece, nel caso di: char a[] = "andrea"; stai assegnando 7 elementi (compreso il NUL finale) uno a uno al vettore. Nel primo caso, il vettore "andrea" decade nel puntatore al suo primo elemento, nel secondo caso invece diventa {'a','n','d','r','e','a','\0'} e l'assegnazione viene compiuta, quindi, elemento per elemento. -------------------------------------------------------------------------------------------------- Stampa: %[tipo][ampiezza].[precisione] %c Carattere %s Stringa %d Intero con segno in base 10. %u Precede un tipo: indica unsigned - Se usato da solo indica unsigned int %o Intero senza segno in base 8 (ottale). %x Un intero senza segno in base 16 (esadecimale). %e Un numero a virgola mobile, in notazione scientifica. %f Un numero a virgola mobile, in notazione decimale fissa. %g Un numero a virgola mobile, secondo la notazione di `%e' o `%f'. %h Precede un tipo: indica short - Se usato da solo indica short int %l Precede un tipo: indica long - Se usato da loso indica long int La notazione %[qwerty] significa di LEGGERE COME STRINGA fin quando non si incontra un carattere diverso da quelli contenuti nella lista. La notazione %[^qwerty] al contrario, legge tutti i caratteri fino a che non si incontra uno di quelli contenuti nella lista, che rimane disponibile per un'altra lettura. Il carattere "^" usato per primo ha senso come negazione. L'operatore "*" che subito dopo al simbolo "%" indica che dobbiamo ignorare il dato che andremo a leggere. -------------------------------------------------------------------------------------------------- Un array a più dimensioni può essere visto come un array di array ... -------------------------------------------------------------------------------------------------- Sintassi: gli "lvalues" sono le entita' associate ad un indirizzo in memoria. I nomi degli arrays sono lvalues, ma con una particolarita': non sono modificabili. -------------------------------------------------------------------------------------------------- Parametri passati al main: argc vale almeno 1, perché il primo elemento (in posizione 0) è il nome del programma ---> mi semplifica la logica dell'utilizzo L'ultimo elemento è NULL -------------------------------------------------------------------------------------------------- Campo: struct StrutturaCampo { unsigned char bA :1, bB :1, bC :1, stato :4; }; -------------------------------------------------------------------------------------------------- Per ripulire il buffer della tastiera posso usare: scanf("%*[^\n]%*c"); In alternativa posso usare: while ( getchar() != '\n' ); -------------------------------------------------------------------------------------------------- La funzione fflush() è definita dallo standard solo per gli stream di output, mentre non è definita per gli stream di input (es. fflush(stdin)). Il termine "undefined" per lo standard ha un significato ben preciso e lascia libertà agli implementatori del linguaggio di offrire un comportamento valido da parte di questa funzione, nel caso si ponga come argomento il flusso standard di input. Questo significa che alcune implementazioni possono assolvere al compito che ci si prefigge ed altre no. -------------------------------------------------------------------------------------------------- Posso definire degli alias di variabili nel seguente modo: int variabile; int& copia = variabile; la scrittura è equivalente a int variabile; int &copia = variabile; Attenzione: Scrivere "int& a, b" signifiga ottenere "int &a" e "int b" (b è un int normalissimo)! Quindi tanto vale scrivere "int &a, b", decisamente più comprensibile. -------------------------------------------------------------------------------------------------- #define SWAP(tipo, a, b) do { tipo temp_=(a); (a)=(b); (b)=temp_; } while(0) -------------------------------------------------------------------------------------------------- Per scrivere su LPT1: FILE *fp = fopen( "LPT1", "w" ); //Utilizzare in alternativa PRN char c; putc(c, fp); -------------------------------------------------------------------------------------------------- Per allocare dinamicamente un vettore di strutture: #include #include typedef struct {int x; ...;} dati ; int Funzione( dati **v ) { *v = malloc(5 * sizeof(dati)); (*v)[0].x = 15; (*v)[1].x = -2; } main() { dati *p; Funzione(&p); printf("%d\n", p[1].x); } -------------------------------------------------------------------------------------------------- Testo colorato (solo in modalità DOS e utilizzando la libreria conio.h del DJGPP e del Borland C++ poiché la libreria conio.h non è portabile): textcolor( 4 ); textbackground( 15 ); cputs( "Hello coloured world !!!\n" ); -------------------------------------------------------------------------------------------------- Printf Printf() e spazi prima della stringa >se io scrivo printf("%20s", "prova"); >mi mette una spazio di 20 blank davanti alla parola "prova" >il problema che io dovrei aumentare lo spazio in modo crescente >utilizzando un ciclo di printf; sprintf( formatstr, "%ss", width ) ; printf( formatstr, "prova" ) ; -------------------------------------------------------------------------------------------------- /* rwbits.c 03/09/2001 h 23.55 Andrea Laforgia */ #include #include #include typedef unsigned char BIT; typedef unsigned char BYTE; BIT get_bit( BYTE byte, int pos ) { return ( byte >> pos ) & 1 ; } void put_bit( BYTE *pbyte, BIT bit ) { *pbyte = ( *pbyte << 1 ) | bit ; } int main() { BIT bit ; BYTE r_byte, w_byte; int c, i ; puts( "scrivi il tuo nome e batti "\ "\"Invio\" (CTRL+Z per terminare)" ) ; while ((c = getchar()) != EOF) { if ( isprint( c ) ) { w_byte = 0; r_byte = (BYTE)c; for (i = CHAR_BIT - 1; i >= 0; i--) { bit = get_bit( r_byte, i ) ; put_bit( &w_byte, bit ) ; } printf( "(%c)\n", w_byte ) ; } } return 0; } -------------------------------------------------------------------------------------------------- int mynum = (int) ((double)mymax * rand() / RAND_MAX); -------------------------------------------------------------------------------------------------- printf("\e[1;34m Prova di colore \e[00m \n"); -------------------------------------------------------------------------------------------------- Il preprocessore, in C, puo' assolvere a tre compiti specifici: - inclusione di file - definzione di macro e sostituzione - compilazione condizionale -------------------------------------------------------------------------------------------------- Se c'e' del codice che non dev'essere compilato, ma non voglio cancellarlo l'unico modo sicuro di procedere e': #if 0 ... #endif Se commentassi solo potrei incorrere nei problemi dei nested comment. -------------------------------------------------------------------------------------------------- In C, per sizeof, non sono necessarie se l'argomento NON e' un tipo -------------------------------------------------------------------------------------------------- Prima di invertire il senso dello stream bisogna fare un fflush. Quindi ti posizioni, leggi, chiami fflush, ti riposizioni e scrivi. -------------------------------------------------------------------------------------------------- Accedere alle variabili locali delle funzioni e' undefined behaviour perche' la memoria e' gia' stata liberata. Sarebbe legale accedere ad una variabile locale static, visto che viene allocata una volta e permane fino alla fine del programma. -------------------------------------------------------------------------------------------------- fflush(NULL) esegue un flush di tutti gli stream aperti in *scrittura*. -------------------------------------------------------------------------------------------------- int pinco(...) e` undefined (deve esserci almeno un argomento). La forma: int foo(); e` la cosidetta not prototype-format parameter type declarators e differisce da un normale prototipo in quando non permette al compilatore di fare alcun controllo sul numero e sul tipo di parametri passati. Nel C99 questa feature e` considerata obsoleta ma e` mantenuta per compatibilita`. int foo() non equivale a int foo(void) (quest'ultimo e` un prototipo). -------------------------------------------------------------------------------------------------- La modalita` di apertura di un file e` una stringa composta da una combinazione di: r -> apre in sola lettura, se il file non esiste fallisce. w -> apre in sola scrittura, se il file non esiste lo crea, se esiste lo tronca. r+ -> come r ma permette anche la scrittura w+ -> come w ma permetta anche la lettura a -> apre in scrittura e posiziona il puntatore alla fine del file (append) a+ -> come a ma permetta anche la lettura b -> modalita` binaria t -> modalita` testo [1] [1] "t" non esiste nel C99 dove un file, se non diversamente specificato viene aperto in modalita` testo. -------------------------------------------------------------------------------------------------- void swap(struct dipendente *s, int a, int b) { struct dipendente tmp; memcpy(&tmp, &s[a], sizeof(struct dipendente); memcpy(&s[a], &s[b], sizeof(struct dipendente); memcpy(&s[b], &tmp, sizeof(struct dipendente); } -------------------------------------------------------------------------------------------------- #include #include int main(void) { char buffer[80]; fgets(buffer,80,stdin); buffer[strlen(buffer)-1]='\0'; printf(buffer); return 0; } -------------------------------------------------------------------------------------------------- In pratica quando chiami fflush il contenuto del buffer _interno_ associato allo stream viene passato al sistema operativo. fflush assicura che, dal punto di vista della libreria, il buffer e` consistente con il contenuto del file. L'OS puo` a sua volta attuare le politiche di buffering nella maniera piu` oppurtuna, senza che la stdlib ne sia a conoscenza. In particolare fflush *non* agisce a questo livello. La gestione dell'I/O del sistema operativo non rientra nelle tematiche coperte dalla libreria standard, la quale si limita a chiamare la primitiva di sistema per la scrittura in caso di utilizzo di fflush() su un buffer in uscita. A sua volta, questa primitiva puo`, o meno, scrivere effettivamente il buffer su disco, oppure memorizzarlo in un ulteriore buffer, al quale, ripeto, la libreria standard non ha accesso. Quello di cui tu parli, invece, puo` essere richiesto direttamente al sistema in taluni casi, come, per esempio, accade nei sistemi POSIX-compliant, con la primitiva sync(). --------------------------------------------------------------------------------------------------