תכנות בשפת סי8תרגול

נתונה הכרזת המשתנים הבאה בשפתC: int a, b, c[4];

?אילו אילו מבין השורות הבאות נכונות תחבירית ויעברו קומפילציה שורות ייצרו שגיאות, ואילו אזהרות?

1. *(c+3) = 8;

2. a = *(c+ *b);

3. *(c++) = 12;

4. c = b;

5. b = c;

1תרגיל

, המשך1תרגיל 6. a = (*c)++;

7. *(b+1) = (*c)++;

8. a = *b – *c;

9. *c = *(b++)

10. *(b++) = *(&a)

תזכורת:int a, b, c[4];

פונקצייתmain של תוכנית C:מתחילה בשורות הבאות void main() {

int arr[20], *ptr, num;ptr = arr;

אילו מבין השורות הבאות נכונות תחבירית ויעברו אילו שורות ייצרו שגיאות, ואילו אזהרות? קומפילציה?

1. arr++;

2. arr = #

3. ptr;

2תרגיל

4. ptr = #

5. *ptr = 8;

6. *num = 8;

7. arr + 2 = 8;

8. &num = 8;

9. &num = &arr[5];

10. num = *ptr;

, המשך2תרגיל תזכורת:

void main() {int arr[20], *ptr, num;ptr = arr;

מה תחזירwhat בהפעלות הבאות:

what(“aaabbbcc”,”abc”)what(“aaabbbcc”, “abcd”)

מה יעודה של הפונקציהwhat?

3תרגיל #include <stdio.h>int what(char *st1, char *st2){

char *p = st1;if(*st2 || *st1){

if(*st1 == '\0') return 0;

while(*st1 && *st2 && *st1==*st2 ) st1++;

if(st1==p) return 0;

return what(st1, st2+1);} else

return 1;}

מערכים באורך זהה, ובעלי איבר אחרון שהוא 2עבור -?1what, איזה ערך תחזיר 1

4תרגיל

int what1(int *arr1, int *arr2){

int tmp;

if(*arr1==-1) return 0;

tmp = what1(arr2 + 1, arr1 + 1);

return *arr1 – tmp}

מערכים באורך זהה, 2עבור , 1-ובעלי איבר אחרון שהוא

, איזה ערך 1וארגומנט נוסף ?what2תחזיר

ב4תרגיל '

int what2(int *arr1, int *arr2, int i){ int tmp;if(*arr1==-1)

return 0;if(i) {

tmp = what2(arr1 + 1, arr2 + 1, 1-i);

return *arr1 – tmp;} else {

tmp = what2(arr1 + 1, arr2 + 1, 1-i);

return *arr2 –tmp;}

}

:צריך לממש את הפונקציה הבאה char* strstr(char *st1, char *st2)

מחרוזות כארגומנטים.2הפונקציה מקבלת אםst2 -מוכלת ב st1 הפונקציה תחזיר מצביע לתו של ,

st1.שממנו מתחילה המחרוזת המוכלת אםst2 -איננה מוכלת ב st1 אזי הפונקציה תחזיר ,NULL.

–שימו לבdog -מוכלת ב maddogs ולא מוכלת ,adoog.ב-

- הכלת מחרוזות5תרגיל

//returns 1 iff st1 begins with st2 int inner_str(char *st1, char *st2) {

int i;

for (i=0; st2[i] != ‘\0’; i++) {if (st1[i] != st2[i])

return 0;}return 1;

}

– פתרון איטרטיבי5תרגיל char* strstr(char *st1, char *st2) {

int i = 0, st1_len, st2_len;

st1_len = strlen(st1);st2_len = strlen(st2);

while (st1_len – i >= st2_len) {if (inner_str(& (st1[i]),

st2)return &(st1[i]);

i++;}

return NULL; }

//returns 1 iff st1 begins with st2 int inner_str(char *st1, char *st2) {

if (st2[0] == ‘\0’)return 1;

if (st1[0] != st2[0])return 0;

return inner_str(&(st1[1]), &(st2[1]));

}

– פתרון רקורסיבי5תרגיל char* strstr(char *st1, char *st2)

{int i = 0;

if ( strlen(st1) < strlen(st2) )return NULL;

if (inner_str(st1, st2))return st1;

return strstr(&(st1[1]), st2); }

?מה נכון עבור התוכנית.התוכנית לא מדפיסהRun time error. 0 1 2 3 4 5 6 7 8 9מדפיסה

מדפיסה אינסוף אפסים 0מדפיסה. מדפיסה ערכים לא

ידועים..אף תשובה לא נכונה

6תרגיל #include <stdio.h>#include <stdlib.h>#define MAX 10

void main() { int *ptr, *arr]MAX[; int i, j; for (i=MAX-1 ; i>=0; i--) { arr[i] = (int*) malloc (i * sizeof(int));

if (arr[i]) for (j = 0; j < i; j++)

* ( * (arr+i) + j) = j * i; ptr = * (arr + MAX – 1); while ( *ptr) printf ( “%d “, *ptr--);}

צריך לממש פונקציה void transpose(int** arr, int n) arr מערך דינאמי דו-מימדי בגודל – n X n מייצג מטריצה) .

ריבועית)n.גודל המימד הריבועי של המטריצה –

הפונקציה תשנה את המערך הדו-מימדי ע"י ביצוע פעולתtranspose.עליו

אם לפני הקריאה לפונקציהarr[i][j] = x – ו arr[j][i] = y אזי אחרי ,.arr[j][i] = x ו – arr[i][j] = yסיום ריצת הפונקציה

שימו לב – השינוי הואin-place .

7תרגיל

- פתרון7תרגיל void tranpose (int** arr, int n) {

int i, j, tmp;for (i=0; i < n; i++)

for (j=i+1; j < n; j++) {tmp = arr[i][j];arr[i][j] = arr[j][i];arr[j][i] = tmp;

}}

צריך לממש פונקציה int** transpose2(int** arr, int n) arr מערך דינאמי דו-מימדי בגודל – n X n מייצג מטריצה) .

ריבועית)n.גודל המימד הריבועי של המטריצה –

מערך דו-מימדי חדש, שערכי אבריו יהיו תייצרהפונקציה אברי המערך הדו-מימדי המקורי לאחר ביצוע פעולת

transpose.

ב7תרגיל '

ב' - פתרון7תרגיל int** tranpose2 (int** arr, int n) {

int i, j, tmp_arr;

if (! tmp_arr = malloc(sizeof(int*) * n)) return NULL;

for (i = 0; i < n; i++) {if (! tmp_arr[i] = malloc(sizeof(int) * n)) {

for (j = 0; j < i; j++)free(tmp_arr[j]);

free(tmp_arr);return NULL;

}for (j = 0; j < n; j++)

tmp_arr[i][j] = arr[i][j];}

transpose(tmp_arr, n);return tmp_arr;

}

היינו יכולים בשלב הזה לבצע את ה-Transpose בעצמנו, אבל העקרון

המודולרי היה עובד גם עבור פעולות מסובכות יותר, כאלה שלא בהכרח היינו יודעים/רוצים לממש בעצמנו.