#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

void getpid_example() {
	// utilizziamo la system call getpid()

	// pid_t getpid(void);

	pid_t my_process_pid;


	my_process_pid = getpid(); // invoco la funzione "involucro" della glibc

	printf("my_process_pid = %d\n", my_process_pid);

	sleep(60);

	printf("bye!\n");
}

// questa è una variabile globale
int var;

// in un altro file sorgente del progetto scriverò:
//extern int var;

// le variabili globali di tipo vettore sono inizializzati automaticamente a 0
char vettore_globale[1024]; // il vettore è inizializzato a valori tutti 0

char vettore_globale_b[1024] = { 100,1,2,3,4,5,6,7,8,9,10, 'A', '$' };


// scriviamo una funzione che prende come parametro una variabile di tipo int;
// questa funzione incrementa la variabile del valore 42
// la funzione conta il numero di volte che viene invocata

int counter; // inizializzata automaticamente a 0

#define SPECIAL_CONSTANT 42

void increment_42(int * parameter) {
	*parameter = *parameter + SPECIAL_CONSTANT;

	counter++;
}


// scriviamo una funzione che prende come parametri due variabili di tipo int
// la funzione scambia i valori delle due variabili

void swap(int *a, int *b) {
	int temp;

	temp = *a;

	*a = *b;

	*b = temp;
}

void my_function(int p) {

}



int main() {

	char ch;
	char destination_ch;

	char * ptr; // ptr è un puntatore a variabili di tipo char

	ch = 'A'; // 1 byte

	printf("ch = %c\n", ch);

	ptr = &ch; // ptr punta alla variabile ch


	// equivalente a: destination_ch = ch;
	destination_ch = *ptr; // utilizzo l'indirizzo contenuto in ptr...
	// per leggere il valore (di tipo char) contenuto all'indirizzo

	printf("destination_ch = %c\n", destination_ch);

	*ptr = 'Z'; // ch = 'Z';

	printf("ch = %c\n", ch);

	printf("sizeof(char)   = %d byte\n", sizeof(char));
	printf("sizeof(char *) = %d byte\n", sizeof(char *));

	printf("indirizzo di ch: %lx\n", &ch);


	char vettore[10]; // NON è implicitamente inizializzato; quindi assume valori casuali

	printf("sizeof(vettore) = %d byte\n", sizeof(vettore));

	vettore[0] = 'A';
	vettore[1] = 'B';
	vettore[2] = 'C';
	vettore[3] = 'D';

	// ...

	vettore[9] = 'Z';

	//vettore[103040] = '1'; // ATTENZIONE!!!

	ch = vettore[0];

	// che valore avrà ch?
	printf("ch = %c\n", ch);

	int pos;
	pos = 2;

	ch = vettore[pos];
	// che valore avrà ch?
	printf("ch = %c\n", ch);

	// come si inizializza un vettore (o array)?

	// qui il vettore viene inizializzato completamente
	char vettore2[20] = { 'p', 'r', 'o', 'v', 'a', 0 };

	printf(vettore2); // sto passando a printf l'indirizzo del vettore2

	printf("\nhello world!\n"); // sto passando a printf l'indirizzo della stringa "..."

	// quale è il valore di vettore2[15] ?
	printf("vettore2[15] = %d\n", vettore2[15]);

	///////
	ptr = &vettore_globale_b;

	ptr = &vettore_globale_b[0];

	printf("*ptr = %d\n", *ptr);
	printf("vettore_globale_b[0] = %d\n", vettore_globale_b[0]);

	printf("\n");


	ptr = &vettore_globale_b;

	// dimensione totale in bytes occupato dal vettore
	// numero di elementi del vettore
	// dimensione in bytes di ogni elemento del vettore

	// dimensione totale in bytes occupato dal vettore =
	// 		numero di elementi del vettore * dimensione in bytes di ogni elemento del vettore

	// scorro tutti gli elementi del vettore,
	// mi serve il 'numero di elementi del vettore'
	for (int i = 0; i < sizeof(vettore_globale_b) / sizeof(char); i++) {

		//*ptr = *ptr + 1;

		printf("vettore_globale_b[%d] = %d\n", i, vettore_globale_b[i]);

		printf("*ptr = %d\n", *ptr);

		ptr++; // incremento il puntatore
		// ovvero incremento l'indirizzo conservato dentro ptr
	}

	///

	int a;

	a = 100;

	increment_42(&a);

	printf("a = %d\n", a);

	printf("counter = %d\n", counter);

	int * iptr;

	iptr = NULL;


	if (iptr == NULL) {
		printf("attenzione!!! il puntatore non è definito!\n");
		// ....
	}


	printf("bye!\n");

	return 0;
}