Record File

Standard
Source Code in C


1:Record File

 2: /* main.c
 3:  This program contains several calls to function PrintWhere to find
 4:  various records of interest from several files
 5: */
 6: 
 7: #include <stdio.h>
 8: #include <stdlib.h>
 9: #include <string.h>
 10: 
 11: #define TRUE   1
 12: #define FALSE  0
 13:  
 14: #define INTEGER 'i'
 15: #define FLOAT   'f'
 16: #define STRING  'c'
 17:  
 18: #define LESS    '<'
 19: #define EQUAL   '='
 20: #define GREATER '>'
 21:  
 22: 
 23:  
 24: int GetRec(
 25:   FILE *fileDesc,    /* αναγνωριστικό αρχείου */
 26:   int recNum,        /* αύξον αριθμός της προς ανάγνωση εγγραφής */
 27:   int recSize,        /* μήκος εγγραφής σε bytes */
 28:   void *bufPtr        /* δείκτης στο σημείο της μνήμης που αποθηκεύεται μία εγγραφή */
 29: );
 30: 
 31: void PrintField(
 32:   char fieldType,    /* τύπος πεδίου: 'i', 'f', ή 'c' */
 33:   int fieldOffset,    /* απόσταση πεδίου από την αρχή της εγγραφής σε bytes */
 34:   void *bufPtr        /* δείκτης στο σημείο της μνήμης που αποθηκεύεται μία εγγραφή */
 35: );
 36: 
 37: int TestRec(
 38:   char fieldType,    /* τύπος πεδίου: 'i', 'f', ή 'c' */
 39:   int fieldOffset,    /* απόσταση πεδίου από την αρχή της εγγραφής σε bytes */
 40:   char compareOp,    /* τύπος σύγκρισης: '<', '=', ή '>' */
 41:   void *valPtr,        /* δείκτης στην σταθερά σύγκρισης */
 42:   void *bufPtr        /* δείκτης στο σημείο της μνήμης που αποθηκεύεται μία εγγραφή */
 43: );
 44: 
 45: int PrintWhere(
 46:   char *fileName,    /* όνομα αρχείου */
 47:   int recSize,        /* μέγεθος εγγραφών αρχείου */
 48:   char fieldType1,    /* τύπος 1ου πεδίου: 'i', 'f', ή 'c' */
 49:   int fieldOffset1,    /* απόσταση 1ου πεδίου από την αρχή της εγγραφής σε bytes */
 50:   char fieldType2,    /* τύπος 2ου πεδίου: 'i', 'f', ή 'c' */
 51:   int fieldOffset2,    /* απόσταση 2ου πεδίου από την αρχή της εγγραφής σε bytes */
 52:   char fieldType3,    /* τύπος 3ου πεδίου: 'i', 'f', ή 'c' */
 53:   int fieldOffset3,    /* απόσταση 3ου πεδίου από την αρχή της εγγραφής σε bytes */
 54:   char compareOp,    /* τύπος σύγκρισης: '<', '=', ή '>' */
 55:   void *valPtr        /* δείκτης στην σταθερά σύγκρισης */
 56: );
 57:  
 58: 
 59:  
 60: 
 61:  
 62: int main(int argc, char** argv)
 63: {
 64: float minGpa = 7.5;
 65: int entyear = 1993;
 66: int age = 20;
 67: char *dept = "FYSIKO";
 68: 
 69: /********************************************************************************
 70:  * This query calls PrintWhere to find in file "student2" *
 71:  * the names and grades of students with grade greater than 7.5 *
 72:  ********************************************************************************/
 73:  
 74: switch(PrintWhere("student2.dat",64,STRING,8,FLOAT,60,FLOAT,60,
 75:                   GREATER,(void *) &minGpa))
 76:      {
 77:      case 0:  printf("\nSuccessful Termination on 1st Query\n");
 78:               break;
 79:      case -1: printf("\n1st Query Execution Failure \n");
 80:               break;
 81:      default: printf("\nSevere error in PrintWhere call for 1st Query\n");
 82:               exit(1);
 83:      }
 84: 
 85: /********************************************************************************
 86:  * This query calls PrintWhere to find in file "student1" *
 87:  * the names and grades of students with grade greater than 7.5 *
 88:  ********************************************************************************/
 89:  
 90: switch(PrintWhere("student1.dat",68,STRING,24,FLOAT,16,FLOAT,16,
 91:                    GREATER,(void *) &minGpa))
 92:      {
 93:      case 0:  printf("\nSuccessful Termination on 2nd Query\n");
 94:               break;
 95:      case -1: printf("\n2nd Query Execution Failure \n");
 96:               break;
 97:      default: printf("\nSevere error in PrintWhere call for 2nd Query\n");
 98:               exit(1);
 99:      }
 100: 
 101: /********************************************************************************
 102:  * This query calls PrintWhere to find in file "student3" *
 103:  * the names and grades of students with grade greater than 7.5 *
 104:  ********************************************************************************/
 105:  
 106: switch(PrintWhere("student3.dat",100,STRING,36,FLOAT,80,FLOAT,80,
 107:                    GREATER,(void *) &minGpa))
 108:      {
 109:      case 0:  printf("\nSuccessful Termination on 3rd Query\n");
 110:               break;
 111:      case -1: printf("\n3rd Query Execution Failure \n");
 112:               break;
 113:      default: printf("\nSevere error in PrintWhere call for 3rd Query\n");
 114:               exit(1);
 115:      }
 116: 
 117: /********************************************************************************
 118:  * This query calls PrintWhere to find in file "student1" *
 119:  * the names and ages of students who entered in 1998 *
 120:  ********************************************************************************/
 121:  
 122: switch(PrintWhere("student1.dat",68,STRING,24,INTEGER,20,INTEGER,0,
 123:                    EQUAL,(void *) &entyear))
 124:      {
 125:      case 0:  printf("\nSuccessful Termination on 4th Query\n");
 126:               break;
 127:      case -1: printf("\n4th Query Execution Failure \n");
 128:               break;
 129:      default: printf("\nSevere error in PrintWhere call for 4th Query\n");
 130:               exit(1);
 131:      }
 132: 
 133: /********************************************************************************
 134:  * This query calls PrintWhere to find in file "student1" *
 135:  * the department name and id number of students who are 20 years old *
 136:  ********************************************************************************/
 137:  
 138: switch(PrintWhere("student1.dat",68,STRING,4,INTEGER,64,INTEGER,20,
 139:                    EQUAL,(void *) &age))
 140:      {
 141:      case 0:  printf("\nSuccessful Termination on 5th Query\n");
 142:               break;
 143:      case -1: printf("\n5th Query Execution Failure \n");
 144:               break;
 145:      default: printf("\nSevere error in PrintWhere call for 5th Query\n");
 146:               exit(1);
 147:      }
 148: 
 149: /********************************************************************************
 150:  * This query calls PrintWhere to find in file "student1" *
 151:  * the id number and name of students who are in FYSIKO *
 152:  ********************************************************************************/
 153:  
 154: switch(PrintWhere("student1.dat",68,INTEGER,64,STRING,24,STRING,4,
 155:                    EQUAL,(void *) dept))
 156:      {
 157:      case 0:  printf("\nSuccessful Termination on 6th Query\n");
 158:               break;
 159:      case -1: printf("\n6th Query Execution Failure \n");
 160:               break;
 161:      default: printf("\nSevere error in PrintWhere call for 6th Query\n");
 162:               exit(1);
 163:      }
 164:    return 0;
 165: }
 166: 
 167: /********************************************************************************************/
 168: 
 169: /********************************************************************************************
 170:  * H ρουτίνα PrintWhere τυπώνει τις τιμές δύο πεδίων (καθορισμένων από τις παραμέτρους *
 171:  * με ονόματα που καταλήγουν σε 1 και 2,αντίστοιχα) για όλες τις εγγραφές των οποίων η *
 172:  * τιμή σε ένα τρίτο πεδίο (καθορισμένου από τις παραμέτρους με ονόματα που καταλήγουν *
 173:  * σε 3) ικανοποιεί μια απλή συνθήκη. Η PrintWhere ανοίγει το καθορισμένο αρχείο για * 
 174:  * διάβασμα, διαβάζει μία μία τις εγγραφες, για κάθε εγγραφή ελέγχει κατάλληλα την τιμή *
 175:  * του πεδίου 3 και τυπώνει τα πεδία 1 και 2 αν ο έλεγχος αποβεί θετικός και κλείνει το *
 176:  * αρχείο.Σε περίπτωση αποτυχίας επιστρέφει την τιμή -1,υποδεικνύοντας ότι υπήρξε πρόβλημα *
 177:  * ενώ αν τερματίσει επιτυχώς, επιστρέφει την τιμή 0. *
 178:  ********************************************************************************************/
 179: int PrintWhere(char *fileName,int recSize,char fieldType1,int fieldOffset1,char fieldType2,int fieldOffset2,char fieldType3,int fieldOffset3,char compareOp,void *valPtr)
 180: {
 181:     FILE *file;         /*Αναγνωριστικό αρχείου.*/
 182:     void *recordbuf; /*Δείκτης στο σημείο της μνήμης που αποθηκεύεται μία εγγραφή.*/
 183:     int getvalue;    /*Ακέραια μεταβλητή για την αποθήκευση της τιμής που επιστρέφει η συνάρτηση GetRec()*/
 184:     int recNum=0;    /*Θέτουμε αρχική τιμή 0 στον αριθμό των εγγραφών.*/
 185:  
 186:     recordbuf=malloc(recSize); /*Δεσμεύουμε μνήμη όσο το μέγεθος της εγγραφής για τον δείκτη *recordbuf.*/
 187:     
 188:     if( (file = fopen( fileName, "rb" )) == NULL ) /*Ανοίγουμε το δυαδικό αρχείο για διάβασμα και εξετάζουμε την*/
 189:     {                                              /*τιμή που επιστρέφει η συνάρτηση fopen για τυχόν λάθη στην διαδικασία.*/
 190:         printf( "The file %s was not opened\n",fileName );    /*Σε περίπτωση λάθους κατά το άνοιγμα του αρχείου η συνάρτηση*/
 191:         return -1;                                            /*επιστρέφει την τιμή -1.*/                                            
 192:     }
 193:     else
 194:     {
 195:         while(!feof(file))   /*Μέχρι να φτάσουμε στο τέλος του αρχείου*/
 196:         {
 197:             getvalue=GetRec(file,recNum,recSize,recordbuf);  /*Διαβάζουμε μία-μία τις εγγραφές από το αρχείο.*/
 198: 
 199:             if(getvalue==0) /*Αν η εγγραφή διαβαστεί με επιτυχία*/
 200:             {
 201:                 if(TestRec(fieldType3,fieldOffset3,compareOp,valPtr,recordbuf)==TRUE) /*Ελέγχουμε για την εγγραφή*/
 202:                 {                                                                /*την τιμή του πεδίου 3 και αν ο έλεγχος*/
 203:                     printf("--------------------------------------------------\n");/*αποβεί θετικός*/
 204:                     PrintField(fieldType1,fieldOffset1,recordbuf); /*Τυπώνουμε το πεδίο 1 της εγγραφής*/
 205:                     PrintField(fieldType2,fieldOffset2,recordbuf); /*Τυπώνουμε το πεδίο 2 της εγγραφής*/
 206:                     printf("\n");
 207:                 }
 208:             }
 209:             if(getvalue==-1) /*Αν αποτύχει το διάβασμα της εγγραφής*/
 210:             {
 211:                 printf("--------------------------------------------------\n");
 212:                 printf("Attempt to Read After the End-Of-File!\n");
 213:                 if( fclose( file) )                            /*Κλείνουμε το αρχείο με έλεγχο για την επιτυχία κλεισίματος.*/
 214:                     printf( "The file %s was not closed\n",fileName );
 215:                 return -1;        /*Σε περίπτωση αποτυχίας στο κλείσιμο του αρχείου η συνάρτηση επιστρέφει την τιμή -1.*/
 216:             }
 217:             if(getvalue==-2)/*Eάν διάβασε ημιτελή εγγραφή στο τέλος του αρχείου.*/
 218:             {
 219:                 printf("--------------------------------------------------\n");
 220:                 printf("***Half-Record Found in the End-Of-File!***\n");
 221:                 if( fclose( file) )                            /*Κλείνουμε το αρχείο με έλεγχο για την επιτυχία κλεισίματος.*/
 222:                     printf( "The file %s was not closed\n",fileName );
 223:                 return -1;        /*Σε περίπτωση αποτυχίας στο κλείσιμο του αρχείου η συνάρτηση επιστρέφει την τιμή -1.*/
 224:             }
 225:             recNum++; /*Αυξάνουμε κάθε φορά τον αριθμό των εγγραφών κατά 1.*/
 226:         }
 227:     }
 228:     if( fclose( file) )    /*Κλείνουμε το αρχείο με έλεγχο για την επιτυχία κλεισίματος.*/
 229:     {
 230:         printf( "The file %s was not closed\n",fileName );
 231:         return -1;    /*Σε περίπτωση αποτυχίας στο κλείσιμο του αρχείου η συνάρτηση επιστρέφει την τιμή -1.*/
 232:     }
 233:     printf("**************************************************\n");
 234:     free(recordbuf);   /*Αποδεσμεύουμε μνήμη για τον δείκτη *recordbuf.*/
 235:     recordbuf=NULL;
 236:     return 0; /*Αν η συνάρτηση τερματίσει επιτυχώς, επιστρέφει την τιμή 0.*/
 237: }
 238: 
 239:  
 240: /********************************************************************************************
 241:  * Η ρουτίνα GetRec διαβάζει μία συγκεκριμένη εγγραφή από το αρχείο. Αναλυτικά υπολογίζει *
 242:  * την απόσταση από την αρχή του αρχείου της εγγραφής που αναζητούμε, τοποθετεί τον δρομέα *
 243:  * (cursor) του αρχείου στο σωστό σημείο και διαβάζει την εγγραφή εκεί όπου δείχνει ο *
 244:  * bufPtr.Ελέγχει εάν ο αριθμός των χαρακτήρων που διάβασε συμφωνεί με το μήκος της *
 245:  * εγγραφής και επιστρέφει την τιμή 0 εάν τερματίσει επιτυχώς, την τιμή -1 εάν επιχείρησε *
 246:  * να διαβάσει πέραν του τέλους του αρχείου και την τιμή -2 αν βρήκε ημιτελή εγγραφή στο *
 247:  * τέλος του αρχείου. *
 248:  ********************************************************************************************/
 249: int GetRec(FILE *fileDesc,int recNum,int recSize,void *bufPtr)
 250: {
 251:     int apostasi, /*Ακέραια μεταβλητή για την απόσταση της εγγραφής από την αρχή του αρχείου*/
 252:         result,      /*Ακέραια μεταβλητή για την αποθήκευση της επιστρεφόμενης τιμής της συνάρτησης fseek.*/
 253:         numread; /*Ακέραια μεταβλητή για την αποθήκευση της επιστρεφόμενης τιμής της συνάρτησης fread.*/
 254: 
 255:     apostasi=recNum*recSize; /*Υπολογίζουμε την απόσταση της εγγραφής πολλαπλασιάζοντας τον αριθμό της εγγραφής */
 256:                              /*με το μεγεθός της.*/
 257:     result = fseek(fileDesc,apostasi, SEEK_SET); /*Τοποθετούμε τον δρομέα(cursor) του αρχείου στο σωστό σημείο.*/
 258:     if( result ) /*Έλεγχος για την σωστή μετακίνηση και τοποθέτηση του δρομέα του αρχείου.*/
 259:     {
 260:         perror( "Fseek Failed!" );
 261:         return -1; /*Σε περίπτωση αποτυχίας στην μετακίνηση του δρομέα η συνάρτηση επιστρέφει την τιμή -1.*/
 262:     }
 263:     else
 264:     {
 265:         if(!feof(fileDesc)) /*Έλεγχος για το εάν βρισκόμαστε στο τέλος του αρχείου.*/
 266:         {
 267:             numread = fread(bufPtr,1,recSize, fileDesc ); /*Διαβάζουμε 1 εγγραφή με μέγεθος recSize και την αποθηκεύουμε*/
 268:             if( ferror( fileDesc ) )                     /*στον bufPtr.*/
 269:             {
 270:                 perror( "Read Error!" ); /*Έλεγχος για την επιτυχία του διαβάσματος.*/
 271:                 return -1;                /*Σε περίπτωση αποτυχίας η συνάρτηση επιστρέφει την τιμή -1.*/
 272:             }
 273:         }
 274:         else /*Εαν η συνάρτηση επιχειρήσει να διαβάσει πέραν του τέλους του αρχείου επιστρέφει την τιμή -1.*/
 275:         {
 276:             return -1;
 277:         }
 278:         if(numread==recSize)/*Έλεγχος για το εάν η συνάρτηση διάβασε πραγματικά τόσα bytes όσα το μέγεθος της εγγραφής(recSize).*/
 279:         {
 280:             return 0; /*Σε περίπτωση επιτυχίας η συνάρτηση επιστρέφει την τιμή 0.*/
 281:         }
 282:         else if(numread!=recSize && numread!=0)
 283:         {
 284:             return -2; /*Αλλιώς εάν διάβασε ημιτελή εγγραφή στο τέλος του αρχείου επιστρέφει την τιμή -2.*/
 285:         }
 286:     }
 287:     return -1; /*Σε οποιαδήποτε άλλη περίπτωση η συνάρτηση επιστρέφει την τιμή -1.*/
 288: }
 289:  
 290: 
 291: /******************************************************************************************
 292:  * Η ρουτίνα TestRec ελέγχει εάν μια εγγραφή ικανοποιεί μία απλή συνθήκη της μορφής *
 293:  * "πεδίο<τιμή","πεδίο=τιμή","πεδίο>τιμή". Αν ναι τότε η TestRec επιστρέφει TRUE ,ειδ΄ *
 294:  * αλλοιώς επιστρέφει FALSE.Η τιμή του καθορισμένου από την fieldOffset πεδίου χρησιμο- *
 295:  * ποιείται στα αριστερά της σύγκρισης, ενώ η καθορισμένη σταθερά χρησιμοποιείται στα *
 296:  * δεξιά της σύγκρισης. *
 297:  ******************************************************************************************/
 298: int TestRec(char fieldType,int fieldOffset,char compareOp,void *valPtr,void *bufPtr)
 299: {
 300:     char *strptr,*strptr2; /*Δείκτες τύπου χαρακτήρα για την αποθήκευση του δείκτη *bufPtr και *valPtr αντίστοιχα*/
 301:     int *intptr,*intptr2; /*Δείκτες τύπου ακεραίου για την αποθήκευση της ακέραιας τιμής που δείχνουν οι δείκτες *strptr και *strptr2 αντιστοιχα */
 302:     float *floatptr,*floatptr2; /*Δείκτες τύπου πραγματικού αριθμού για την αποθήκευση της πραγματικής αριθμητικής τιμής που δείχνουν οι δείκτες *strptr και *strptr2 αντιστοιχα.*/
 303:  
 304:     strptr=(char *)bufPtr; /*Μετατροπή του δείκτη *bufPtr στον δείκτη χαρακτήρων *strptr.*/
 305:     strptr2=(char *)valPtr; /*Μετατροπή του δείκτη *valPtr στον δείκτη χαρακτήρων *strptr2.*/
 306: 
 307:     strptr=strptr+fieldOffset; /*Μετατόπιση του δείκτη στο σημείο που βρίσκεται το πεδίο.*/
 308: 
 309:     switch(fieldType) /*Εξετάζουμε τον τύπο του πεδίου.*/
 310:     {
 311:     case INTEGER: /*Εαν είναι ακέραιος αριθμός.*/
 312: 
 313:         intptr=(int *)strptr; /*Μετατροπή του δείκτη *strptr σε δείκτη τύπου ακεραίων αριθμών(*intptr).*/
 314:         intptr2=(int *)strptr2; /*Μετατροπή του δείκτη *strptr2 σε δείκτη τύπου ακεραίων αριθμών(*intptr2).*/
 315:  
 316:         switch(compareOp) /*Εξετάζουμε τον τύπο σύγκρισης.*/
 317:         {
 318:         case LESS: /*Εάν '<'.*/
 319:             if(*intptr<*intptr2) /*Αν "πεδίο<τιμή" η συνάρτηση επιστρέφει TRUE αλλιώς FALSE.*/
 320:             {
 321:                 return TRUE;
 322:             }
 323:             else
 324:                 return FALSE;
 325:         case EQUAL: /*Εάν '='.*/
 326:             if(*intptr==*intptr2) /*Αν "πεδίο=τιμή" η συνάρτηση επιστρέφει TRUE αλλιώς FALSE.*/
 327:             {
 328:                 return TRUE;
 329:             }
 330:             else
 331:                 return FALSE;
 332:         case GREATER: /*Εάν '>'.*/
 333:             if(*intptr>*intptr2) /*Αν "πεδίο>τιμή" η συνάρτηση επιστρέφει TRUE αλλιώς FALSE.*/
 334:             {
 335:                 return TRUE;
 336:             }
 337:             else
 338:                 return FALSE;
 339:         default:  /*Σε οποιαδήποτε άλλη περίπτωση η συνάρτηση επιστρέφει την τιμή -1 και τυπώνει το λάθος στην οθόνη.*/
 340:             perror("Compare Symbol Error!");
 341:             return -1;
 342:         }
 343:         
 344:     case FLOAT: /*Εαν είναι πραγματικός αριθμός.*/
 345:  
 346:         floatptr=(float *)strptr; /*Μετατροπή του δείκτη *strptr σε δείκτη τύπου πραγματικών αριθμών(*floatptr).*/
 347:         floatptr2=(float *)strptr2; /*Μετατροπή του δείκτη *strptr2 σε δείκτη τύπου πραγματικών αριθμών(*floatptr2).*/
 348: 
 349:         switch(compareOp) /*Εξετάζουμε τον τύπο σύγκρισης.*/
 350:         {
 351:         case LESS: /*Εάν '<'.*/
 352:             if(*floatptr<*floatptr2) /*Αν "πεδίο<τιμή" η συνάρτηση επιστρέφει TRUE αλλιώς FALSE.*/
 353:             {
 354:                 return TRUE;
 355:             }
 356:             else
 357:                 return FALSE;
 358:         case EQUAL: /*Εάν '='.*/
 359:             if(*floatptr==*floatptr2) /*Αν "πεδίο=τιμή" η συνάρτηση επιστρέφει TRUE αλλιώς FALSE.*/
 360:             {
 361:                 return TRUE;
 362:             }
 363:             else
 364:                 return FALSE;
 365:         case GREATER: /*Εάν '>'.*/
 366:             if(*floatptr>*floatptr2) /*Αν "πεδίο>τιμή" η συνάρτηση επιστρέφει TRUE αλλιώς FALSE.*/
 367:             {
 368:                 return TRUE;
 369:             }
 370:             else
 371:                 return FALSE;
 372:         default:   /*Σε οποιαδήποτε άλλη περίπτωση η συνάρτηση επιστρέφει την τιμή -1 και τυπώνει το λάθος στην οθόνη.*/
 373:             perror("Compare Symbol Error!");
 374:             return -1;
 375:         }
 376: 
 377:     case STRING: /*Εαν είναι συμβολοσειρά.*/
 378:         switch(compareOp) /*Εξετάζουμε τον τύπο σύγκρισης.*/
 379:         {
 380:         case LESS: /*Εάν '<'.*/
 381:             if(strcmp(strptr,valPtr)<0) /*Αν "πεδίο<τιμή" η συνάρτηση επιστρέφει TRUE αλλιώς FALSE.*/
 382:             {
 383:                 return TRUE;
 384:             }
 385:             else
 386:                 return FALSE;
 387:         case EQUAL: /*Εάν '='.*/
 388:             if(strcmp(strptr,valPtr)==0) /*Αν "πεδίο=τιμή" η συνάρτηση επιστρέφει TRUE αλλιώς FALSE.*/
 389:             {
 390:                 return TRUE;
 391:             }
 392:             else
 393:                 return FALSE;
 394:         case GREATER: /*Εάν '>'.*/
 395:             if(strcmp(strptr,valPtr)>0) /*Αν "πεδίο>τιμή" η συνάρτηση επιστρέφει TRUE αλλιώς FALSE.*/
 396:             {
 397:                 return TRUE;
 398:             }
 399:             else
 400:                 return FALSE;
 401:         default:  /*Σε οποιαδήποτε άλλη περίπτωση η συνάρτηση επιστρέφει την τιμή -1 και τυπώνει το λάθος στην οθόνη.*/
 402:             perror("Compare Symbol Error!");
 403:             return -1;
 404:         }
 405:         
 406:     default:  /*Σε οποιαδήποτε άλλη περίπτωση η συνάρτηση επιστρέφει την τιμή -1 και τυπώνει το λάθος στην οθόνη.*/
 407:         perror("Field Type Error!");
 408:         return -1;
 409:     }
 410:     perror("TestRec Error!");
 411:     return -1;    /*Σε οποιαδήποτε άλλη περίπτωση η συνάρτηση επιστρέφει την τιμή -1 και τυπώνει το λάθος στην οθόνη.*/
 412: }
 413:  
 414: 
 415: /***********************************************************************************
 416:  * Η ρουτίνα PrintField τυπώνει την τιμή ενός συγκεκριμένου πεδίου μιας εγγραφής. *
 417:  * Η PrintField απλά τυπώνει τα περιεχόμενα του καθορισμένου πεδίου. *
 418:  ***********************************************************************************/
 419: void PrintField(char fieldType,int fieldOffset,    void *bufPtr)
 420: {
 421:     char *strptr; /*Δείκτης τύπου χαρακτήρα για την αποθήκευση του δείκτη *bufPtr.*/
 422:     int *intptr; /*Δείκτης τύπου ακεραίου για την αποθήκευση της ακέραιας τιμής που δείχνει ο δείκτης *strptr.*/
 423:     float *floatptr; /*Δείκτης τύπου πραγματικού αριθμού για την αποθήκευση της πραγματικής αριθμητικής τιμής που δείχνει ο δείκτης *strptr.*/
 424: 
 425:     strptr=(char *)bufPtr; /*Μετατροπή του δείκτη *bufPtr στον δείκτη χαρακτήρων *strptr.*/
 426:     strptr=strptr+fieldOffset; /*Μετατόπιση του δείκτη στο σημείο που βρίσκεται το πεδίο.*/
 427:  
 428:     switch(fieldType)  /*Εξετάζουμε τον τύπο του πεδίου.*/
 429:     {
 430:     case INTEGER: /*Εαν είναι ακέραιος αριθμός.*/
 431:         {
 432:             intptr=(int *)strptr; /*Μετατροπή του δείκτη *strptr σε δείκτη τύπου ακεραίων αριθμών(*intptr).*/
 433:             printf("\t%d\t",*intptr); /*Τυπώνουμε στην οθόνη την ακέραια αριθμητική τιμή που δείχνει ο δείκτης *intptr.*/
 434:         }
 435:         break;
 436:     case FLOAT: /*Εαν είναι πραγματικός αριθμός.*/
 437:         {
 438:             floatptr=(float *)strptr; /*Μετατροπή του δείκτη strptr σε δείκτη τύπου πραγματικών αριθμών(floatptr).*/
 439:             printf("\t%.3f\t",*floatptr);  /*Τυπώνουμε στην οθόνη την αριθμητική τιμή που δείχνει ο δείκτης *floatptr.*/
 440:         }
 441:         break;
 442:     case STRING: /*Εαν είναι συμβολοσειρά.*/
 443:         {
 444:             printf("\t%s \t",strptr); /*Τυπώνουμε στην οθόνη την συμβολοσειρά που δείχνει ο δείκτης *strptr.*/
 445:         }
 446:         break;
 447:     default:
 448:         perror("FieldType Error!"); /*Σε οποιαδήποτε άλλη περίπτωση η συνάρτηση τυπώνει το λάθος στην οθόνη.*/
 449:         break;
 450:     }
 451: }

 

yeezy boost 350 ua yeezytrainer yeezy boost 350 ua yeezytrainer yeezytrainer yeezy boost 350 ua yeezy boost 350 ua yeezy shoes yeezy shoes yeezy boost online

yeezy 350 boost for sale yeezy boost online yeezy shoes yeezy 350 boost for sale yeezy boost online yeezy shoes yeezy 350 boost for sale yeezy boost online yeezy shoes yeezy 350 boost for sale yeezy boost online yeezy shoes