Gruppo F

Sito NON registrato al ROC!

Lillone

The Lillone

Ve lo ricordate?... noi quasi lo avevamo dimenticato!... per evitare che capiti anche a voi vi riproponiamo le pagine a lui dedicate sul nostro vecchio sito!

Primo Round

Esempi pratici di come NON si programma in C.
Questa pagina ha bisogno assolutamente di una spiegazione... Prima di tutto vogliamo metter in chiaro che nessuno di noi è un programmatore... anche se un giorno magari qualcuno di noi potrebbe farlo per professione. Allora, cominciamo dall'inizio, (fin quà potrebbe sembrare una frase di Stancovich!) tempo fà abbiamo "trovato" il file sorgente di un parziale di programmazione svolto da un nostro compagno di corso sull'hdd di un computer del laboratorio... chi avrebbe resistito a darci un'occhiata!?!... , la verità è che non avremmo mai dovuto leggere quelle righe di codice! Il sorgente in questione si è rivelato più esilarante di un libro di Giobbe Covatta (io con Covatta mi piscio nei calzoni anche alla terza lettura consecutiva!). Beh, per farla breve abbiamo deciso di pubblicare il file per condividerlo con il mondo intero... sarebbe un crimine nascondere certe perle!!
---Una copia scannerizzata (pessimamente) del testo del parziale---

---Lillone.c---

/*ESERCIZIO c*/
#include 
#include 
int main()

{

/*Dichiaro ed implemento due puntatori tipo char*/
char ptr1;
char ptr2;
int *ptr3=&char punt;
char *ptr array[];
char *ptr array 1[];
int *ptr [3];
int *ptr1[3];
char array[1];
*ptr=&new ptr1;
return 0;

}




/*ESERCIZIO e*/
#include
#include
int main()

{

/*Dichiaro una funzione void*/
void=&char ptr[10][3][8][2];
void=&int ptr1[4][2][3][6];

/*Utilizzo la funzione qsort, per ordinare gli elementi dell'array*/
qsort=char array;
qsort=int array;
void qsort(void);
qsort(ARRAY, MAX, sizeof char));
qsort(ARRAY, min, sizeof int));
return 0;

}




/*ESERCIZIO MAIN()*/
#include
#include
int main()
{

*int=1;
*int=2;
*char;
*char 1;
*char 2;

/*Genero il generatore di numeri casuali*/
srand();


/*Includo il file d'intestazione myrand.h, per generare i numeri casuali*/
#include
srand();
*int array [2],*int array1[2];
*int ptr=&int array;
*int ptr1=&int array1;
*int=&char ptr;
*int=&char1;
*char=&ptr1;
*char=&ptr2;


/*Utilizzo la funzione free per liberare le aree di memoria*/
free();
*char ptr=free;
*char ptr1=free;
*char ptr3=&ptr;
*char=&ptr;
printf("\nStampa i caratteri memorizzati all' interno dell' array");


/*Riutilizzo la funzione free per liberare l'area di memoria*/
free=*char ptr3;
return 0;

}



/*ESERCIZIO a*/
#include
#include
int main()
{

int=a;
*int=int ptr;


/*Utilizzo la funzione malloc(), per allocare nuova memoria*/
malloc(int array [int];


/*Inizializzo gli elementi degli array,con valri numerici casuali*/
int array=[8198][[9124][8453][9665][9846][130423];
return 0;

}

Qui sopra il file è riportato fedelmente in tutta la sua agghiacciante "bellezza"! Visto che, come già detto, nessuno di noi è un vero programmatore abbaimo deciso di rendere pubblico anche l'autorevole "parere" di uno frà i massimi, e indiscussi, esperti di C... il compilatore Gnu gcc.
---gcc -Wall -o lillone.bin lillone.c---

lillone.c: In function `main':
lillone.c:11: parse error before "char"
lillone.c:12: syntax error before "array"
lillone.c:13: syntax error before "array"
lillone.c:15: conflicting types for `ptr1'
lillone.c:9: previous declaration of `ptr1'
lillone.c:17: `new' undeclared (first use in this function)
lillone.c:17: (Each undeclared identifier is reported only once
lillone.c:17: for each function it appears in.)
lillone.c:17: parse error before "ptr1"
lillone.c:15: warning: unused variable `ptr1'
lillone.c:10: warning: unused variable `ptr2'
lillone.c:11: warning: unused variable `ptr3'
lillone.c:16: warning: unused variable `array'
lillone.c: At top level:
lillone.c:30: redefinition of `main'
lillone.c:6: `main' previously defined here
lillone.c: In function `main':
lillone.c:33: parse error before '=' token
lillone.c:37: parse error before "char"
lillone.c:38: parse error before "int"
lillone.c:39: conflicting types for `qsort'
/usr/include/stdlib.h:736: previous declaration of `qsort'
lillone.c:39: warning: extern declaration of `qsort' doesn't match global one
lillone.c:40: `ARRAY' undeclared (first use in this function)
lillone.c:40: `MAX' undeclared (first use in this function)
lillone.c:40: parse error before "char"
lillone.c:41: `min' undeclared (first use in this function)
lillone.c:41: parse error before "int"
lillone.c: At top level:
lillone.c:53: redefinition of `main'
lillone.c:30: `main' previously defined here
lillone.c: In function `main':
lillone.c:55: parse error before "int"
lillone.c:62: too few arguments to function `srand'
lillone.c:66:19: myrand.h: No such file or directory
lillone.c:67: too few arguments to function `srand'
lillone.c:68: parse error before "int"
lillone.c:78: too few arguments to function `free'
lillone.c:79: parse error before "char"
lillone.c:87: parse error before "char"
lillone.c: At top level:
lillone.c:98: redefinition of `main'
lillone.c:53: `main' previously defined here
lillone.c: In function `main':
lillone.c:100: parse error before '=' token
lillone.c:105: parse error before "int"
lillone.c:109: parse error before '[' token
lillone.c:109: warning: unused variable `array'

Ed infine, ecco la correzione fatta dal nostro professore del corso di programmazione. Ovviamente il proff non sà che noi l'abbiamo vista... e tantomeno pubblicata!... ma se Lillone dissemina file e correzioni relative per tutto il laboratorio non è colpa nostra! N.B.: il voto finale è la media di questo insieme di cazzate e della parte di teoria in cui non sappiamo cosa abbia combinato (fortunatamente).

/*ESERCIZIO c*/ 
 #include  
 #include  
 int main() 


{ 


/*Dichiaro ed implemento due puntatori tipo char*/ 
 char ptr1; 
 char ptr2; 
 // (XX) inizializzazione errata 
 int *ptr3=&char punt; 
 // (XX) non è il modo corretto di dichiarare un puntatore 
 char *ptr array[]; 
 char *ptr array 1[]; 
 int *ptr [3]; 
 int *ptr1[3]; 
 char array[1]; 
 *ptr=&new ptr1; 
 return 0; 


} 




 /*ESERCIZIO e*/ 
 #include 
 #include 
 int main() 


{ 


/*Dichiaro una funzione void*/ 
 // (X) qual è il significato di questa espressione ? 
 void=&char ptr[10][3][8][2]; 
 void=&int ptr1[4][2][3][6]; 


/*Utilizzo la funzione qsort, per ordinare gli elementi dell'array*/ 
 // cosa intendi dire con queste due istruzioni 
 qsort=char array; 
 qsort=int array; 
 void qsort(void); 
 qsort(ARRAY, MAX, sizeof char)); 
 qsort(ARRAY, min, sizeof int)); 
 return 0; 


} 




 /*ESERCIZIO MAIN()*/ 
 #include 
 #include 
 int main() 
 { 
 // a cosa servono queste istruzioni ? 
 *int=1; 
 *int=2; 
 *char; 
 *char 1; 
 *char 2; 


/*Genero il generatore di numeri casuali*/ 
 srand(); 



 /*Includo il file d'intestazione myrand.h, per generare i numeri casuali*/ 
 #include 
 srand(); 
 *int array [2],*int array1[2]; 
 *int ptr=&int array; 
 *int ptr1=&int array1; 
 // (XX) inizializzazione errata 
 *int=&char ptr; 
 *int=&char1; 
 *char=&ptr1; 
 *char=&ptr2; 



 /*Utilizzo la funzione free per liberare le aree di memoria*/ 
 free(); 
 // (XX) il simbolo '*' va dopo il tipo; free() è una funzione, non una variabile 
 *char ptr=free; 
 *char ptr1=free; 
 *char ptr3=&ptr; 
 *char=&ptr; 
 printf("\nStampa i caratteri memorizzati all' interno dell' array"); 



 /*Riutilizzo la funzione free per liberare l'area di memoria*/ 
 free=*char ptr3; 
 return 0; 


} 



/*ESERCIZIO a*/ 
 #include 
 #include 
 int main() 
 { 


int=a; 
 *int=int ptr; 



 /*Utilizzo la funzione malloc(), per allocare nuova memoria*/ 
 malloc(int array [int]; 
 // (XX) non è questo il modo di allocare memoria con malloc() 


/*Inizializzo gli elementi degli array,con valri numerici casuali*/ 
 int array=[8198][[9124][8453][9665][9846][130423]; 
 return 0; 
 // (X) i numeri dovevano essere prodotti dal calcolatore in modo casuale 


}

P.S. Ovviamente il nostro compagno non si chiama Lillone!... abbiamo deciso di modificare almeno il nome del file!... insomma... ci capite no!?! Comunque questo genio esiste realmente... sull'esistenza del suo cervello stiamo ancora indagando!

Secondo Round

Esempi pratici di come NON si programma in C.

06/12/2004: Lillone intrepido e sicuro di sè affronta un'altro parziale di programmazione. Subito dopo il test alla domanda "Allora come è andata?", subdolamente postagli da un membro del Gruppo F, risponde "... insomma" esibendo un sorriso idiota. Ovviamente lascia una copia del sorgente (forse sorgente è eccessivo come termine...) nella directory principale del programma DEV-C++ (esattamente come l'ultima volta).

07/12/2004: Ore 16 circa: Due membri del Gruppo F, con abile e losca mossa, trovano e copiano il file.

07/12/2004: Ore 22:47: la prima versione di questa pagina viene pubblicata!

11/12/2004: Viene pubblicato il testo di quello che scopriamo non essere un parziale ma un appello ufficiale!

--- Testo dell'appello ufficiale di Dicembre --- --- lillone2.c ---

struct temp{int*estrazione;
            int jolly;
            char *montepremi;}
typedef struct temp s_lotto;




/*esercizio (1)*/




#include 
#include 
#include 
int main()
{


s_lotto *make(int dim);
s_lotto *make(int dim) malloc(*s_lotto) sizeof (int dim)
s_lotto*make(int dim)=estrazione &int .5;  
(char *montepremi) malloc sizeof (char *)
char*montepremi=ptr char *.7;
}




/*esercizio (3)*/
int main()
{


s_lotto*try(void)
{
s_lotto malloc sizeof (s_lotto);
s_lotto estrazione=rand(48,57);
}
int jolly=0;
char *montepremi="tentativo";
strcpy("tentativo")(char *montepremi);
"tentativo".char *montepremi;
scanf(%s " &tentativo");
printf("\nVisualizza la stringa copiata");
scanf("%s &montepremi"); 
return 0;
}  
  


/*esercizio (main)()*/
int main()
{


int var;
printf("\nChiedi all' utente di inserire un numero molto grande (>2000)");
scanf("%d");
printf("\nRestituisci il valore intero");
scanf("%d");
getchar=3000;
int var=3000;
/*funzione make()*/
int var=&make;
return (make);
totip=make;
scanf("d"&totip &int var)=set();  
/*funzione try()*/
try();
try=*s_lotto; 
/*funzione ricerca()*/
*s_lotto,totip=&ricerca;  
}

Non ci dilunghiamo oltre e diamo la 'parola' al compilatore...
--- gcc -Wall -o lillone2.bin lillone2.c ---

lillone2.c:4: two or more data types in declaration of `s_lotto'
lillone2.c: In function `main':
lillone2.c:22: warning: static declaration for `make' follows non-static
lillone2.c: In function `make':
lillone2.c:22: parse error before "malloc"
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:39: parameter `estrazione' is initialized
lillone2.c:39: too many arguments to function `rand'
lillone2.c:40: parse error before '}' token
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:42: parameter `montepremi' is initialized
lillone2.c:43: parse error before "strcpy"
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:64: parameter `var' is initialized
lillone2.c:66: parameter `var' is initialized
lillone2.c:66: redeclaration of `var'
lillone2.c:64: `var' previously declared here
lillone2.c:67: parse error before "return"
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately
lillone2.c:22: parm types given both in parmlist and separately

Noi non abbiamo parole... e voi? gruppof@interfree.it Riuscirà Lillone a stupirci ancora?... la risposa prossimamente su queste pagine!

Per voi ecco i files!

Lillone.c --- Lillone2.c

Menu:

ITALIA Campione del Mondo a Germania 2006

Lillone

The Lillone

Primo Round

Secondo Round

Per voi ecco i files!