Programmazione in c

 Gestione file:

-Apertura

-Chiusura

-Controllo errore in fase di apertura file

-Copiatura in output di un intero file  carattere per carattere

-funzione fprintf():
fprintf(fp, "lorem ipsum"); //permette di scrivere su un file
-funzione fscanf():

-funzione fputsc():
fputc('a',fp); //permette di scrivere un singolo carattere in un file
-funzione fputs():
fputs("hello c programming",fp);
-funzione fgetc():
//La funzione fgetc() restituisce un singolo carattere dal file.
char c;
while((c=fgetc(fp))!=EOF){
printf("%c",c);
}
-funzione fgets():
// La funzione fgets() legge una riga di caratteri da file
char text[300];
printf("%s",fgets(text,200,fp));
fclose(fp);
sintassi:
char fgets(char variabile , int numCaratteriRiga, nomeFile);
-funzione fseek():
//La funzione fseek() viene utilizzata per impostare il puntatore del file sull'offset specificato. Viene utilizzato
per scrivere dati in un file nella posizione desiderata.

int fseek(FILE, long int offset, int whence); //whence--> SEEK_SET,SEEK_CUR E

SEEK_END

SEEK_SET SEEK_SET – It moves file pointer position to the beginning of the file.

SEEK_CUR SEEK_CUR – It moves file pointer position to given location.

SEEK_END SEEK_END – It moves file pointer position to the end of file.

-funzione freopen():
//funziona come fopen ma si applica ad un file esistente
fp=freopen(fileName, "r"); //inserire il modo

-funzione fflush():
//cancella il contenuto di un file
fflush(fileName);

-funzione feof():
 restituisce falso (0) se il puntatore NON è posizionato alla fine del file
 restituisce vero (!0) se il puntatore è posizionato alla fine del file
feof(fileName); //controlla che il puntatore si alla fine del file

-funzione rewind():
rewind(fileName); //posiziona il puntatore all'inizio del file
NOTA BENE
• In generale, è errato tentare di memorizzare il contenuto di un file in un vettore

La dimensione (numero di righe o di dati) di un file non è quasi mai nota a priori

Se la dimensione è nota, tipicamente è molto grande

 Matrici:
-inizializzaione:
//esempio di inizializzazione di una matrice
int arr[4][3]={{1,2,3},{2,3,4},{3,4,5},{4,5,6}};

-come printare una matrice:

//utilizzare una coppia di cicli for
for (int i = 0; i <4 ; ++i) {
for (int j = 0; j < 3; ++j) {
printf(" %d ",arr[i][j]);
}
printf("\n");
}

 Strutture:
-definizione e inserimento dati:
//definizione della struttura
struct struct_name{
char esempioStringa[20];
char esempioStringa2[10];
int esempio3;
} nomeVariabileStruct; //nome della variabile struttura --> viene riservato lo
spazio in memoria
//NB possiamo inserire una struttura dentro un'altra struttura

int main() {
//inserimento dati all'interno della struttura (possono poi essere
sovrascritti)
strcpy(nomeVariabileStruct.esempioStringa,"Esempio");
strcpy(nomeVariabileStruct.esempioStringa,"Esempio");
nomeVariabileStruct.esempio3 = 1234;
return 0;
}

-array di strutture:
struct struct_name nomeArray[200];
  Liste:
-def nodo:
//---definizione struct nodo---
struct node{
int data; // dato effettivo di ogni singolo nodo
struct node* next; //punta al prossimo nodo
};
-inizializzazione nodi:
//---inizializzazione dei nodi---
struct node* testa;
struct node* nodo1 = NULL;
struct node* nodo2 = NULL;
};
-allocazione memoria:
//---allocazione della memoria---
nodo1 =(struct node*)malloc(sizeof(struct node)); //alloca lo spazio per
allocare la struct node
nodo2 =(struct node*)malloc(sizeof(struct node));
-assegnazione valori:
//---assegnazione dei valori---
nodo1->data = 17;
nodo2->data = 86;
nodo3->data = 53;
-collegamento nodi:
//---collego tra loro i dati---
nodo1->next = nodo2;
nodo2->next = nodo3;
nodo3->next = NULL;
-primo nodo definito come testa:
// salvo indirizzo del primo nodo come indirizzo del nodo di testa
testa = nodo1;

-printare la lista:
void printList(struct node *p){ //struct node *p --> puntatore alla testa
della nostra struttura
printf("\n");

while(p!=NULL){
printf("|%d| -> ",p->data);
p = p->next;
}
printf("NULL\n");
}
-inserire un elemento in testa:
void list_insert(struct node** testa, int new_data){ //doppio puntatore in modo
che le modifica rimangano alla chiusura della funzione
struct node* nuovo = (struct node*)malloc(sizeof(struct node)); //alloco lo
spazio in memoria per il nuovo nodo
nuovo->data = new_data;
nuovo->next = *testa;
//cambio testa della lista
*testa = nuovo;
}
-inserire un elemento in mezzo:
int insert_order(list_el **t /*testa*/, int new_val, char *new_name, char
*new_surname){

list_el *p, *q;

q = *t;

// 1. Create a new item

p=(list_el *)malloc(sizeof(list_el));
if (p==NULL)
return (-1);

// 2. Store the data

p->code = new_val;
p->name=strdup(new_name);
p->surname=strdup(new_surname);

// 3. Check for head insertion

if( (q == NULL) || (q->code > new_val))
{
/* insert head */
p->succ=*t;
*t=p;
return (0);
}

// 4. Scan the list to the desired position

while(q->succ != NULL){
if(q->succ->code > new_val){
/* insert in the middle */
//4. Update the next field of the new element
p->succ=q->succ;
//5. Update the next field of the previous element to the insertion
point
q->succ=p;
return (0);
}
q = q->succ;
}
/* insert tail */
//4. Update the next field of the new element
p->succ = NULL;
//5. Update the next field of the previous element to the insertion point
q->succ = p;
return(0);

}
return (0);
}
-scan della lista:
list_el* find (list_el *t, int val){
list_el *p;
p=t;

while (p!=NULL)
{ if (p->code==val)
return (p);
p=p->succ;
}
return (p);
}