1. תרגול 8 תחומי הכרה פונקציות
נכתב ע"י כרמי גרושקו. כל הזכויות שמורות © 2010 הטכניון, מכון טכנולוגי לישראל

2. ולמה משתנים גלובליים וסטטים הם דבר מסוכן
תחומי הכרה
ולמה משתנים גלובליים וסטטים הם דבר מסוכן

3. תזכורת (תחומי הכרה) משתנים "לוקליים אוטומטיים" (רגילים).
int main() {
int a, i;
for( i=0; i<a; i++ )
int m = (l+r)/2;
printf( "%d %d", m, a ); }
return 0;
משתנים "לוקליים אוטומטיים" (רגילים).
קיימים+נגישים בבלוק שבו הוכרזו, ובבלוקים מוכלים.
לא מאותחלים במשתמע; יכילו זבל ללא אתחול מפורש.
פרמטרים של פונקציות (בתוך הפונקציות) הם משתנים לוקליים אוטו' לכל צורך פרקטי
משתנים גלובליים
קיימים+נגישים בכל מקום (החל מהכרזתם)
מאותחלים במשתמע להיות 0.
האתחול חייב להיעשות לערך קבוע וידוע מראש (כמו במקרה של גודל מערך)
int g;
void f() {
printf( "%d", g ); }
int main()
scanf( "%d", &g );
f();
return 0;
הכוונה ב-"קיימים" - שומרים את ערכם הקודם.

4. תזכורת (תחומי הכרה) משתנים "לוקליים סטטים".
נגישים בבלוק שבו הוכרזו, ובבלוקים מוכלים.
קיימים לכל אורך ריצת התכנית.
מאותחלים במשתמע להיות 0.
האתחול חייב להיעשות לערך קבוע וידוע מראש (כמו במקרה של גודל מערך)
void f() {
static int a = 1;
printf( "%d ", a++ ); }
int main()
f();
return 0;
הכוונה ב-"קיימים" - שומרים את ערכם הקודם.

5. תרגיל 1א (בוחן, אביב תש"ע) כמה כוכביות ? int main() { f1(10); f1(20);
#define N 20
int arr[N] = {0, 19, 2, 21, 4, 23, 6, 25, 8, 27,
9, 10, 11, 12, 13, 14, 15, 16, 17, 18};
int i = 0;
void g(void) {
i += 2; }
כמה כוכביות ?
void f1(int n) {
int i = 0;
for ( ; (i < n) && (i < N); i++)
if (arr[i]%2)
printf("*");
g(); }
התשובה היא 15
int main() {
f1(10);
f1(20);
return 0; }

6. תרגיל 1ב (בוחן, אביב תש"ע) כמה כוכביות ? int main() { f2(10); f2(20);
#define N 20
int arr[N] = {0, 19, 2, 21, 4, 23, 6, 25, 8, 27,
9, 10, 11, 12, 13, 14, 15, 16, 17, 18};
int i = 0;
void g(void) {
i += 2; }
כמה כוכביות ?
void f2(int n) {
static int i = 0;
for ( ; (i < n) && (i < N); i++)
if (arr[i]%2)
printf("*");
g(); }
התשובה היא 10
int main() {
f2(10);
f2(20);
return 0; }

7. תרגיל 1ג (בוחן, אביב תש"ע) כמה כוכביות ? int main() { f3(10); f3(20);
#define N 20
int arr[N] = {0, 19, 2, 21, 4, 23, 6, 25, 8, 27,
9, 10, 11, 12, 13, 14, 15, 16, 17, 18};
int i = 0;
void g(void) {
i += 2; }
כמה כוכביות ?
void f3(int n) {
for ( ; (i < n)&&(i < N); i++)
int i = 0;
if (arr[i]%2)
printf("*");
g(); }
התשובה היא 0
int main() {
f3(10);
f3(20);
return 0; }

8. תרגיל 1ד (בוחן, אביב תש"ע) כמה כוכביות ? void f4(int n) {
#define N 20
int arr[N] = {0, 19, 2, 21, 4, 23, 6, 25, 8, 27,
9, 10, 11, 12, 13, 14, 15, 16, 17, 18};
int i = 0;
void g(void) {
i += 2; }
כמה כוכביות ?
void f4(int n) {
for ( ; (i < n)&&(i < N); i++)
if (arr[i]%2)
printf("*");
g(); }
התשובה היא 5
int main() {
f4(10);
f4(20);
return 0; }

9. תרגיל 2 מה התכנית הבאה תדפיס ? void f(int x) { x = 4; } int main()
f(x);
printf( "%d", x );
return 0;
התשובה היא 9

10. תרגיל 3 מה התכנית הבאה תדפיס ? void f(int x) { x = 4; } int main()
f(x[0]);
printf( "%d", x[0] );
return 0;
התשובה היא 9 - x[0] הוא משתנה רגיל; זה לא משנה שהוא חלק ממערך.

11. תרגיל 4 מה התכנית הבאה תדפיס ? void f(int x[]) { x[0] = 4; }
int main()
int x[10] = {9};
f(x);
printf( "%d", x[0] );
return 0;
התשובה היא 4

12. תרגיל 5 (מועד א', חורף תשס"ט)
מהו הפלט של התכנית הבאה?
int g(int * x) {
*x-=8;
return 7; }
int f(int x)
g(&x);
printf("%d",x);
return 5;
int main() {
int x=9;
f(x);
printf("%d",x);
return 0; }
הפלט הוא 19

13. פונקציות
תרגילים

14. תרגיל 6 – משולש שווה-שוקיים
כתבו תכנית המדפיסה משולש כמו בתמונה. [שווה-שוקיים[
void rep_print(char c, int count) {
while( count-- > 0 )
printf( "%c", c ); }
int main()
int i;
for( i=1; i<=SIZE; i+=2 )
rep_print( ' ', (SIZE-i)/2 );
rep_print( '*', i );
printf( "\n" );
return 0;

15. תרגיל 7 (מועד א', אביב תש"ע, )
בהינתן מערך a עם n איברים המיוצג באופן הבא: אזי העברת האיבר האחרון לראשית תקרא "הזזה ציקלית באחד":
למשל:
a[0]
a[1]
a[2]
a[3] ……
a[n-2]
a[n-1]
a[n-1]
a[0]
a[1]
a[2] ……
a[n-3]
a[n-2] 2 5 8
-43
-43 2 5 8

16. תרגיל 7א (מועד א', אביב תש"ע, 234112)
כתבו פונקציה המקבלת
שני מערכים a ו-b,
את אורכם n,
ומשתנה k,
מחזירה 1 אם המערך b מתקבל לאחר k "הזזות ציקליות באחד" של המערך a ו-0 אחרת.
int is_cyclic( int a[], int b[], int n, int k ) {
int i;
for( i=0; i<n; i++ )
if( a[i] != b[(i+k)%n] )
return 0;
return 1; }
עד עכשיו, היינו משתמשים ב- #define N <?>.
מעכשיו, יש לנו פרמטר.

17. תרגיל 7ב (מועד א', אביב תש"ע, 234112)
כתבו פונקציה המקבלת
שני מערכים a ו-b,
את אורכם n,
מחזירה את מספר "ההזזות הציקליות באחד" שעל a לעבור כדי להפוך ל-b, אם ניתן; אחרת, -1.
int cyclic_number( int a[], int b[], int n ) {
int i;
for( i=0; i<n; i++ )
if( is_cyclic( a, b, n, i )
return i;
return -1; }

18. תרגיל 8א
כתבו פונקציה המקבלת unsigned int ומחזירה את ההיפוך שלו: =>
unsigned int reverse( unsigned int n ) {
unsigned int res = 0;
while( n )
res = res*10 + n%10;
n /= 10; }
return res;

19. תרגיל 8ב
כתבו פונקציה המקבלת unsigned int ומכריעה אם הוא פלינדרום (מספר "סימטרי" , וכו'.)
int is_palindrome( unsigned int n ) {
return reverse(n) == n; }

20. תרגיל 9
כתבו פונקציה המקבלת מערך (ואת אורכו) ומחזירה את האינדקס שבו נמצא האיבר המקסימלי (במקרה של תיקו, החזירו אחד מהם).
unsigned get_max_idx( int a[], int length ) {
unsigned max_idx = 0, i;
for( i=1; i<length; i++ )
if( a[i] > a[max_idx] )
max_idx = i;
return max_idx; }

21. תרגיל 10
כתבו פונקציה המקבלת שני מערכים (ואת אורכיהם) וקובעת אם אחד מהם הוא תת מערך של השני (מותר שוויון).
אם הראשון תת-מערך של השני, החזירו 1.
אם השני תת-מערך של הראשון, החזירו 2.
אם שני התנאים הקודמים נכונים (במקרה של שוויון), החזירו 3.
אם אף אחד מהתנאים לא נכון, החזירו -1. 43 1 -4 17 2 54 1 -4 17

22. למה לא מעבירים את אורכי שני המערכים ?
תרגיל 10
ראשית נכתוב פונקציה שבהנתן שני מערכים, קובעת אם הם זהים:
int is_equal_arrays( int a[], int b[], int n ) {
int i;
for( i=0; i<n; i++ )
if( a[i] != b[i] )
return 0;
return 1; }
למה לא מעבירים את אורכי שני המערכים ?

23. תרגיל 10 (המשך) נכתוב פונקציה הבודקת אם המערך a הוא תת-מערך של b.
int is_sub_array( int a[], int b[], int na, int nb ) {
if( na < nb )
int i;
for( i=0; i<=nb-na; i++ )
if( is_equal_arrays( a, b+i, na ) )
return 1;
return 0; }

24. תרגיל 10 (המשך) אם מערך אחד ארוך מהשני, בהכרח הוא לא תת-מערך שלו.
אם שני המערכים באורך זהה, רק צריך לבדוק אם הם זהים.
דמיינו איך התכנית היתה נראית ללא שימוש בפונקציות...
int is_any_subarray( int a[], int b[], int na, int nb ) {
if( na == nb )
return is_equal_arrays( a, b, na ) ? 3 : -1;
if( na < nb )
return is_sub_array( a, b, na, nb ) ? 1 : -1;
else
return is_sub_array( b, a, nb, na ) ? 2 : -1; }