Seconda parte del Cheat Sheet per il C (prima parte qui).
printf(“%p”, ptr); doppi puntatori int **p; i puntatori locali contengono un valore random se non inizializzati, quelli globali sono messi a NULL.
int f(int x, char c) {
...
}
...
int (*f_ptr)(int x, char c)
f_ptr = f;
f2(2.3, f_ptr); // == f2(2.3, f);
...
int f2(double d, int (*f_ptr_X)(int x, char c))
{
...
}
void *malloc(size_t byte) (restituisce un puntatore a void, ovvero un puntatore ad un tipo qualsiasi, serve un cast. size_t ~ unsigned short int)
void free(p)
int argc = numero parametri (>=1), char *argv[] = array di stringhe con i parametri passati da linea di comando, il primo è sempre il nome del programma.
In C++ tutte le funzioni devono avere il prototipo, in C non è obbligatorio. in C si usa char f(void) per funzioni senza parametri, in C++ va bene anche char f()
- funzioni con elenco di parametri con lunghezza variabile
se una funzione ha almeno un parametro, ma non si sa bene quanti è possibile dichiararla come int f(char par1, ...) (esempio printf)
#include <stdarg.h>
TYPE func(TYPE arg1,TYPE arg2, ...)
{
va_list ap;
TYPE x;
va_start(ap,arg2);
x = va_arg(ap,TYPE);
/* and so on */
va_end(ap);
}
i parametri opzionali possono essere solo double e int (o unsigned int), un parametro float è convertito in double, e un char o uno short int è convertito in int
non c’è un metodo standard per capire se sono arrivato all’ultimo parametro, quindi devo “inventare” una mia convenzione, tipo printf che vuole tanti parametri quanti sono i %X del primo parametro (la stringa)
- dichiarazione di funzioni vecchio stampo
prima le funzioni si dichiaravano come:
tipo nome_funz(par1, par2, par3)
tipo1 par1;
tipo2 par2;
tipo3 par3;
{
...
}
struct nome {
tipo nome1: lunghezza;
tipo nome2: lunghezza;
...
}
es:
struct struttura_bit {
unsigned bit1: 1;
unsigned bit2: 1;
...
}
struttura_bit_instance.bit1 = 0; // imposto il bit a 0
le unioni sono come le strutture, ma tutti gli elementi condividono la stessa area di memoria:
union type_x {
int word; // ad es: 16 bit (2 byte)
char low_byte; // il byte basso della coppia
}
enum tipo_enum {
a, b, c, d, e, f
};
tipo_enum istanza;
istanza = a;
if(istanza == b)
- Specificatori di formato per I/O formattato
%d == %i
%e (notazione scientifica con ‘e’), %E (notazione scientifica con ‘E’)
%g/%G (usa il più corto tra %e/%E e %f)
%o (ottale)
%u (unsigned int)
%x/%X (esadecimale, lettere minuscole/maiuscole)
%p puntatore
%n puntatore a interi in cui viene scritto il numero di caratteri scritti su output
%10f (almeno 10 caratteri, se ne servono meno mette spazi bianchi, allineamento a destra)
%'c'10f (almeno 10 caratteri, se ne servono meno mette tanti ‘c’ quanti ne servono (‘c’ = un carattere, gli apici non servono realmente))
%-10f (allineamento a sinistra)
%10.4f (almeno 10 caratteri, con 4 decimali, se meno mette tanti 0)
%4.8s (stringa min 4, max 8 caratteri
%ld (long int)
%Lf (long double, L maiuscola)
%#f (stampa le cifre decimali anche se non ci sono)
%#x (stampa 0x davanti al numero esadecimale)
%*.*f (la dimensione minima e la precisione decimale sono specificati da due parametri della printf, es: printf("%*.*f", 10, 4, 123.45678);)
%[XYZ] (per scanf, riferito ad un array, dice a scanf di leggere solo i caratteri presenti tra [], in questo caso X,Y,Z, quando l’utente inserisce un altro carattere, si passa alla variabile successiva)
%*c (per scanf, leggo un carattere ma non lo memorizzo da nessuna parte, funziona con un qualsiasi %*, d, f, g, e, u,…)
