Computer Programming Summer 2016 תרגול 12
מהו קובץ? תשובה: אוסף של תווים )במקרה שלנו( ששמור על דיסק כלשהו. מוטיבציה: עד עכשיו )ללא קבצים( ברגע שנסגור את התוכנית, כל המידע שהיה לנו בזיכרון נעלם, ובפעם הבאה שמריצים את התוכנית- מתחיל מחדש. למשל: מה היה קורה אם היינו כותבים תוכנית ספר טלפונים אישי ללא שימוש בקבצים? הכל ע"מ להתייחס לקבצים, אנו נעבוד עם משתנים מטיפוס מצביע לקובץ )* )FILE המוגדר ב- stdio.h. כמו כן, פונקציות לביצוע פעולות על קבצים )נקראות )File manipulation functions מוגדרות ב- stdio.h. הספרייה שבהן נשתמש קובץ מסתיים בתו המיוחד EOF וערכו 1-. פתיחה וסגירה של קובץ: לפני שמתחילים להשתמש בקובץ יש "לפתוח" אותו ולהגדיר באיזה אופן נשתמש בו. פתיחה תבוצע באמצעות הפקודה הבאה: FILE* fopen( char*, char* ); מצב פתיחת הקובץ שם הקובץ ומיקומו fp=fopen("c:\\filename.txt","r") דוגמא: שם הקובץ ומיקומו: שם תיקני במערכת הפעלה. o אם הקובץ לא נמצא במיקום בו אני מריץ את התוכנית יש להוסיף מיקומו בדיסק. o מצב פתיחת הקובץ: פתיחת הקובץ לקריאה: "r" o אם הכול תקין יחזיר את הכתובת של הקובץ )מצביע מסוג.(FILE* במקרה של תקלה בפתיחת הקובץ )שם לא תקין, אין הרשאה לקובץ, אין הרשאה לכונן ועוד( הפונקציה תחזיר.NULL "w" פתיחת הקובץ לכתיבה: o אם הקובץ לא קיים יוצרת את הקובץ והנתיב ומחזירה את הכתובת של הקובץ )מצביע מסוג.(FILE*
o "a" אם הקובץ קיים כל מה שהיה בו נמחק ומתחילים לכתוב מחדש, מחזירה את הכתובת של הקובץ )מצביע מסוג.(FILE* במקרה של תקלה בפתיחת הקובץ )אין הרשאה לקובץ, אין הרשאה לכונן ועוד( הפונקציה תחזיר.NULL פתיחת הקובץ לצורך הוספה )לקובץ קיים(: אם הקובץ קיים מוסיפים לקובץ בסופו. מחזירה את הכתובת של הקובץ כאשר סמן הכתיבה בסופו )מצביע מסוג.(FILE* אם הקובץ לא קיים יוצרת את הקובץ והנתיב ומחזירה את הכתובת של הקובץ )מצביע מסוג.(FILE* במקרה של תקלה בפתיחת הקובץ )אין הרשאה לקובץ, אין הרשאה לכונן ועוד( הפונקציה תחזיר.NULL int fclose( FILE* ); בתום השימוש יש "לסגור" את הקובץ. מצביע לקובץ fclose(fp); דוגמא: אם סגר את הקובץ והכול תקין מחזיר 0. אם לא הצליח לסגור את הקובץ מחזיר.EOF כאשר מבצעים פעולות קריאה או כתיבה על קובץ, המערכת שומרת את המקום בו התבצעה הפעולה האחרונה, על מנת לבצע את הפעולה הבאה במקום הבא. o למשל: כתבנו 20 תווים לקובץ חדש, התו הבא שנכתוב לקובץ יכנס אוטומטית למקום ה- 21. o ניתן "ללכת אחורה" בקובץ, אך בקורס זה לא נלמד כיצד עושים זאת, לכן אם נרצה לעשות זאת, נסגור את הקובץ ונפתח אותו מחדש לקריאה )ואז נתחיל מתחילתו ונוכל להתקדם עד לאן שנרצה( או נשתמש בפקודה.rewind void rewind(file*); חזרה לתחילת הקובץ: מחזיר את הסמן קריאה \ כתיבה לתחילת הקובץ.
int fscanf(file *fp,char *fmt,address list...); פונקציות לקריאה מקובץ: o fp מצביע לקובץ )פתוח לקריאה(. - fmt הינה מחרוזת המגדירה כיצד על fscanf לקרוא את הקלט. address list הכתובות של המשתנים שבתוכם fscanf יציב את הקלט. הפונקציה מחזירה את מספר הכתובות שאליהן הכניסה ערכים. פועל ע"פ חוקי.scanf מחזיר )1-( EOF בסוף הקובץ. int fgetc(file *fp); o קורא תו אחד מהקובץ שמוצבע ע"י fp בסוף הקובץ יחזיר.EOF מחזיר int אך משתמשים רק ב byte הראשון שלו. char* fgets(char *str,int n,file* fp); o קורא מחרוזת מהקובץ שמוצבע ע"י fp ומעביר את המחרוזת ל.str קורא מחרוזת בגודל 1-n או עד ה 'n\' הראשון )קורא גם אותו(. שם '0\' בסוף המחרוזת. אם הקריאה הצליחה מחזיר את str אחרת במצב של שגיאה מחזיר.NULL int fprintf(file *fp,char *fmt,expressions list...); פונקציות כתיבה לקובץ: o - fp מצביע לקובץ )פתוח לכתיבה(..fprintf מחרוזת התבנית לפלט עבור ה - fmt expressions list שמות המשתנים שערכיהם יהיו הפלט עבור מחרוזת התבנית שהוגדרה.
int fputc(int ch, FILE *fp); o כותבת את התו ch לתוך הקובץ המוצבע ע"י fp )הפתוח לכתיבה(. אם הפונקציה הצליחה לכתוב את התו היא מחזירה את התו שנכתב, אחרת מחזירה.EOF char fputs(char *str,file *fp); o כותבת את המחזרות המוצבעת ע"י str לתוך הקובץ המוצבע ע"י fp )הפתוח לכתיבה(. אם הפונקציה הצליחה היא מחזירה מספר לא שלילי, אחרת מחזירה.EOF פונקציות לניהול קבצים: int remove(char *filename); o מחיקת קובץ: הפונקציה מוחקת את הקובץ ששמו מוצבע ע"י.fileName הקובץ חייב שלא להיות פתוח. אם הפונקציה הצליחה אז היא מחזירה 0. אם הקובץ לא קיים או ארעה שגיאה אז הפונקציה תחזיר 1-. int rename(char *oldname, char *newname); o שינוי שם של קובץ: הפונקציה משנה את השם של הקובץ מ oldname ל.newName חייבים לסגור את הקובץ לפני שמבצעים את הפעולה. לא ניתן לשנות לקובץ
את שמו כאשר הוא פתוח. הפונקציה מחזירה 0 אם הצליחה או 1- אם קרתה שגיאה.
מחרוזות המרה )דוגמאות לפורמטים בשימוש בפונקציות :)fscanf, fprintf %5d בקלט יקלוט עד 5 ספרות. בפלט יוסיף רווחים משמאל כדי להשלים ל 5 תווים. %-5d בפלט בלבד - יוסיף רווחים מימין כדי להשלים ל 5 תווים. %10.2f בפלט בלבד - יעגל את הספרות מימין לנק' עד כדי 2 ספרות. %[$!=?] %[a-za-z] יקלוט עד אשר יתקל באחד מהתווים השונים מהתווים בסוגריים. %[^$!=?] יקלוט עד אשר יתקל באחד מהתווים השווים לתווים בסוגריים. %*c יתעלם מהchar בזמן הקלט )בהתאמה ניתן גם לבצע עם שאר הטיפוסים(.
תרגילים תרגיל 1 יצירת קובץ, כתיבה לקובץ, קריאה מקובץ רשום טבלת מעקב עבור התכנית הבאה: void main() { FILE *fp; char str[100]; int res,num; fp=fopen("testfile.txt","w"); if (!fp) exit(1); fprintf(fp,"test"); fclose(fp); fp=fopen("testfile.txt","a"); fprintf(fp," file"); fclose(fp); fp=fopen("testfile.txt","w"); fprintf(fp,"linea 10 ten\n"); fprintf(fp,"lineb 20 twenty\n"); fprintf(fp,"linec 30 thirty\n"); fclose(fp); fp=fopen("testfile.txt","r"); res=fscanf(fp,"%s%d",str,&num); // line #1
// str=linea num=10 res=2 res=fscanf(fp,"%d%s",&num,str); // 2 // res=0 res=fscanf(fp,"%2s%*1s",str); // 3 // str=te res=1 res=fscanf(fp,"%*c"); // 4 // res=0 res=fscanf(fp,"%8s%1d",str,&num); // 5 // str=lineb num=2 res=2 res=fscanf(fp,"%[^\n]%*c",str); // 6 // str=0 twenty res=1 res=fscanf(fp,"%8[^$]%*c",str); // 7 // str=linec 30 res=1 res=fscanf(fp,"%*[^\n]%*c"); // 8 // res=0 res=fscanf(fp,"%d",&num); // 9 // res=-1=eof fclose(fp);
תרגיל 2 מה עושה התכנית הבאה? void main() { FILE *fp; char ch,st[4]; if (!(fp=fopen("testfile.txt","r"))) exit(1); while (fscanf(fp,"%c",&ch)!=eof) printf("%c",ch); rewind(fp); while (fgets(st,4,fp)!=null) printf("%s",st); fclose(fp); rename("testfile.txt","testfile2.txt"); remove("testfile2.txt");
א 0 ם הם שונים או 1- אם הייתה שגיאה בפתיחת קובץ. תרגיל 3 כתוב פונקציה אשר מקבלת שני שמות של קבצים ומחזירה 1 אם הקבצים זהים, #include <stdio.h> #include <string.h> int diff(char* fname1,char* fname2) { FILE *f1, *f2; char c1,c2; תשובה: f1= fopen(fname1,"r"); f2= fopen(fname2,"r"); if(!f1!f2) return -1; do{ c1readok = fscanf(f1,"%c",&c1); c2readok = fscanf(f2,"%c",&c2); while (c1readok==1 && c2readok==1 && c1==c2); fclose (f1); fclose (f2); return (c1readok==eof && c2readok==eof); void main () { int ans; ans=diff("1.txt","2.txt"); if (ans==-1) printf("error openning files\n"); ניקח תו מכל קובץ, כל עוד אף אחד מהקבצים לא נגמר )כלומר fscanf הצליחה לקרוא תו מכל קובץ(, ושני התווים שלקחנו זהים. אם הגענו לסוף הקובץ בשני הקבצים הקבצים זהים ונחזיר 1. בכל מקרה אחר נחזיר 0.
else if (ans==1) printf("identical files\n"); else printf("different files\n ");
תרגיל 4 נתון קובץ נתוני כל הסטודנטים שלומדים בשנה א' בספיר, בו עבור כל סטודנט מופיעה שורה המכילה: ת.ז, שם פרטי ושם משפחה )עם רווח יחיד ביניהם, באורך של לכל היותר 100 תווים בסה"כ(. בנוסף נתון קובץ ציונים בקורס "תכנות ב- C " אשר בו, עבור כל סטודנט שעשה את הקורס מאז ומעולם, מופיעה שורה המכילה את הת.ז שלו, וציוניו במבחן וב- 6 העבודות. העבודות מהוות 30% מהציון הסופי והמבחן מהווה 70% )מופיע בשורה האחרונה(. מהציון הסופי. שני הקבצים הנתונים ממוינים לפי ת.ז, מהקטן )מופיע בשורה הראשונה( לגדול כתוב פונקציה שתקבל את שמות שני הקבצים הנ"ל, ותדפיס לקובץ פלט שיקרא out.txt את שמותיהם והציון הסופי של כל הסטודנטים משנה א' שעשו את הקורס. אין לעבור על קובץ יותר מפעם אחת, ואין להכניס למבנה נתונים כלשהו )כגון מערך או רשימה מקושרת(. כמו כן, על הפלט להיות ממוין לפי מס' ת.ז. לדוגמא: shana-aleph.txt c.txt out.txt 1234 Moshe Cohen 1345 Dina Levi 2345 Eli Israeli 4567 Avi Tal... 1234 99 50 70 1235 50 33 80 2345 80 80 80 4567 90 95 100 5215 24 44 54... Moshe Cohen 71.35 Eli Israeli 80.00 Avi Tal 97.75 לא שייך לשנה א' לא עשתה את הקורס
תשובה: #include <stdio.h> #include <string.h> אלגוריתם: 1. קרא שורה שלמה משני הקבצים )c ו- shana-aleph ( 2. אם ה- id שנקראה מ- c id == שנקראה מ- shana-aleph : חשב ציון סופי, כתוב שם וציון סופי לקובץ הפלט. קרא שורה שלמה משני הקבצים. חזור ל- 2. 3. אחרת, אם ה- id שנקראה מ- c id < שנקראה מ- shana-aleph : קרא שורה שלמה מקובץ c. חזור ל- 2. 4. אחרת )אם ה- id שנקראה מ- c id > שנקראה מ- shana-aleph (: קרא שורה שלמה מקובץ.shana-aleph חזור ל- 2. 5. בצע כל עוד שני הקבצים לא הסתיימו. void calcfinalgrades(char* filenamesa, char* filenamec); void main() { calcfinalgrades("shana-aleph.txt","c.txt"); void calcfinalgrades(char* filenamesa, char* filenamec) { // sa = shana-aleph FILE *fsa,*fc,*fout; int idsa,idc,,testc,avodotc[6],oksa,okc; char namesa[100]; float avg;
fsa = fopen(filenamesa,"r"); fc = fopen(filenamec,"r"); fout = fopen("out.txt","w"); if(!fsa!fc!fout) { printf("error opening file. Exiting."); return; // reading first line from both files oksa = fscanf(fsa,"%d %[^\n]%*c",&idsa,namesa); okc = fscanf(fc,"%d %d",&idc,&testc); for (i=0;i<6;i++) okc = fscanf(fc,"%d",&avodotc[i]); fscanf(fc,"%*c"); // while both files did not reach the end while(oksa!=eof && okc!=eof) { // if IDs are equal if (idsa==idc) { // calc & print average avg=0; for (i=0;i<6;i++) avg+=avodotc[i]; avg=(avg/6)*0.3 + testc*0.7; fprintf(fout,"%s %.2f\n",nameSA,avg); // progress in both files oksa = fscanf(fsa,"%d %[^\n]%*c",&idsa,namesa); okc = fscanf(fc,"%d %d",&idc,&testc); for (i=0;i<6;i++) okc = fscanf(fc,"%d",&avodotc[i]); fscanf(fc,"%*c"); continue;
// if first id is smaller than the second if (idsa<idc) { // progress in the first file oksa = fscanf(fsa,"%d %[^\n]%*c",&idsa,namesa); continue; // if second id is smaller than the first if (idsa>idc) { // progress in the second file okc = fscanf(fc,"%d %d",&idc,&testc); for (i=0;i<6;i++) okc = fscanf(fc,"%d",&avodotc[i]); fscanf(fc,"%*c"); continue; // while fclose(fsa); fclose(fc); fclose(fout);
:ipc082b שאלה 5 להעברת מחסנים של מפעל ייצור גדול הוזמנו 10 משאיות. על מנת לבטח את תהליך ההעברה, חושבה עלות הביטוח ביחס לעלות הפריטים במשאית. כל פריט שייך לאחת מ- 3 קטגוריות - 0, 1 או - 2 כשלכל אחת תעריף ביטוח אחר: בקטגוריה 0 התעריף הוא 2% מערך הפריט, בקטגוריה 1 התעריף הוא 7% מערך הפריט, ובקטגוריה 2 התעריף הוא 15% מערך הפריט. לכל משאית נרשם קובץ ובו רשומים הפריטים שהועמסו עליה. כל קובץ מכיל שורה לכל פריט שנמצא במשאית לפי הפירוט הבא: 5 ספרות 4 ספרות 25 תווים מק"ט כמות הערה למוביל הקובץ ממוין לפי מק"ט בסדר עולה. ייתכנו מספר שורות לכל פריט )בין הקבצים, לא בתוך קובץ אחד(. כמו כן קיים קובץ שהוא קטלוג הפריטים ובו שורה לכל פריט לפי הפרוט הבא: 5 ספרות תו אחד ( '1','2' '0', ) 6 ספרות מק"ט קטגוריה מחיר הפריט הקובץ ממוין לפי מק"ט בסדר עולה. לפני הנסיעה ביקש מנהל המפעל להפיק קובץ לכל קטגוריה ובו ירשמו הפריטים המובלים מאותה קטגוריה. כל קובץ יכיל שורה לכל פריט לפי הפירוט הבא: 5 ספרות 5 ספרות 6 ספרות 5 ספרות ועוד 2 ספרות דיוק )XXXXX.XX( מק"ט כמות מחיר עלות הביטוח
הקובץ ימויין לפי מק"ט בסדר עולה. הנתונים בכל שורה יופרדו בפסיק. פריט שלא קיים באף משאית לא יופיע באף קטגוריה. כתוב פונקציה: void insure (FILE* fvan[10], FILE *fitem, char* name[3]) שמקבלת מערך fvan של מצביעים לקבצים שנרשמו למשאיות, fitem מצביע לקובץ הפריטים, ו- name מערך של שלוש מחרוזות שהן שמות קבצי הסיכום שהפונקציה יוצרת לקטגוריה 2. 1, 0, במערך fvan האיבר הראשון מתייחס למשאית מס' 1 האיבר השני למשאית מס' 2 וכך הלאה. הגבלה: אין לקרוא קובץ יותר מפעם אחת. אין להעתיק קובץ למבנה נתונים אחר )מערך, רשימה משורשרת, קובץ עזר, עץ...(
אלגוריתם: לקרוא שורה שלמה מכל קבצי המשאיות, לתוך מערך part[] ומערך.quant[] 1. למצוא במערך part[] את מספר החלק הקטן ביותר.)minPart( 2. לקרוא שורות בקובץ הקטלוג עד שמגיעים לשורה שמכילה את פרטי החלק שמספרו.minPart 3. לסכום את כל הכמויות של minpart מכל קבצי המשאיות שבהם הוא מופיע. 4. לחשב עלות כוללת )כמות כללית כפול עלות ליחידה( ולחשב עלות ביטוח )עלות כוללת כפול תעריף ביטוח(. 5. להדפיס את הנתונים הדרושים לקובץ הקטגוריה הרלוונטי. 6. לקרוא שורה נוספת מכל קבצי המשאיות שהכילו את החלק.minPart 7. לחזור ל- 2, ולבצע שוב עד שמסתיימים כל קבצי המשאיות. 8. void insure (FILE* fvan[10],file *f_item, char* name[3]) { FILE *res3[3]; int part1[10],quant1[10],part2,cat2,price2,totalquant3; int i,flag1[10],flag2,minpart,minidx; float insurance[3]={0.02,0.07,0.15; // create 3 output files for (i=0;i<3;i++) { res3[i]=fopen(name[i],"w"); if (!res3[i]) exit(1); // read first lines from all files for (i=0;i<10;i++) (1) flag1[i]=fscanf(fvan[i],"%5d%4d%*[^\n]%*c",&part1[i],&quant1[i]); (2) flag2=fscanf(f_item,"%5d%1d%6d%*c",&part2,&cat2,&price2); // loop until all van files are finished while (1) { // find minimal part id & its van index minidx=-1; for (i=0;i<10;i++)
if (flag1[i]!=eof && (minidx==-1 part1[i]<minpart)) { minpart=part1[i]; minidx=i; // if nothing was found - all files are done, then quit if (minidx==-1) break; // find the part in the items catalog file while (minpart!=part2) (2) // loop all vans, and if a van contains the part, sum its quantity totalquant3=0; for (i=0;i<10;i++) if (part1[i]==minpart) totalquant3+=quant1[i]; // print to the relevant output file fprintf(res3[cat2],"%5d%5d%6d%8.2f\n",minpart, totalquant3, price2*totalquant3, insurance[cat2]*price2*totalquant3); // read a new line from all vans files that did contain the part for (i=0;i<10;i++) if (part1[i]==minpart) (1) for (i=0;i<3;i++) fclose(res[i]);