הנדסה אזרחית & הנדסה מבנית
שימוש ב-Compet Pointers דרישות קריאה ב C
Table of Contents
נקודות תפקוד ב C הן תכונה מתוחכמת אך מעשית מאוד המעצימה מפתחים ליישם מנגנוני חיוג - פונקציות עברו כטיעונים לפונקציות אחרות, אשר הופעלו מאוחר יותר, בדרך כלל בתגובה לאירועים או תנאים.טכניקה זו היא יסוד בתכנות מונחת אירועים, עיצוב ספריה ופיתוח API, המציע גמישות וקוד Reuse. מאמר זה חוקר נקודות תפקוד לעומק, מבסיסים לדפוסקים מתקדמים, עם מיקוד על יישום שיחות.
הבנת נקודות תפקוד ב-C
מצביע פונקציה הוא משתנה המאחסן את כתובת הזיכרון של פונקציה.בניגוד למצביעים רגילים שמצביעים על נתונים, מצביעי הפונקציה מצביעים על קוד הניתן להפעלה.הבהרת מצביע פונקציה דורשת לציין את סוג החזרה של הפונקציה ואת סוגי הפרמטר.
int (*funcPtr)(int, int);[ה] ב[[המאה ה-20]], [[1924]]]], [[1924]]]]]], [[1924]]]]]], [[1924]]]]]], [[1924]]]]]]]]]], [[1924]]]]]]]]]]]]]], [[1924]]]]]]]]]]]], [[1924]]]]]]]]]]]], [[1924]]]]]]]]]]]]]]
int add(int a, int b) { return a + b; }
funcPtr = add; // or &add
ייעודו של הסמן הוא פשוט באותה מידה:
int result = funcPtr(5, 3); // calls add(5, 3)
נקודות תפקוד מאופיינות: החתימה של הסמן חייבת להתאים את חתימת התפקיד שהוקצה בדיוק.
שימוש במקרים נפוצים עבור פונקציות Pointers
- (ב) ,0) ,Callback functionsFLT:1 ,המוקד העיקרי של מאמר זה.
- (ב) ,0) מכונות חוק ,(FLT:1 ), טבלאות של מצביעי תפקידים מיישמות מעברים.
- (ב) ⁇ (ב) ⁇ (ב) ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
- (ב) ,0) ,4 , ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
- (ב) טבלאות של פאספטפט"א (FLT:0) , טבלאות של סיגנל 1 - נוסחאות של מנגנוני תפקוד עבור מערכות תפריט או מתורגמן פיקוד.
יישום שיחות עם פונקציות
Callback הוא פונקציה שכתובתה מועברת לתפקיד אחר, ומאפשרת לתפקוד המקבל לקרוא ל-Callback בזמן המתאים.זה מקלקל את המתקשר מפרטי היישום, קידום עיצוב מודולרי.כאן הוא דוגמה קלאסית:
#include <stdio.h>
void executeOperation(int a, int b, int (*operation)(int, int)) {
int result = operation(a, b);
printf("Result: %d\n", result);
}
int add(int x, int y) { return x + y; }
int multiply(int x, int y) { return x * y; }
int main() {
executeOperation(5, 3, add);
executeOperation(5, 3, multiply);
return 0;
}
כאן, (FLT:11) מקבל ציון פונקציה של הפונקציה נקודה FLT:12 ו, והוא עושה את זה עם (FLT:13 ו FLT:14) דפוס זה משמש נרחב ממשק משתמש גרפי (GUI) מסגרות, I / O, ו טיפול אירוע ברמה מערכתית.
Callback עם User Context
לעתים קרובות, שיחות צריך נתונים נוספים מעבר לפרמטרים הקבועים.טכניקה נפוצה היא להעביר את נקודת ההקשר של ה-FLT:15 ל-Callback:
typedef void (*Callback)(int event, void* context);
void registerCallback(Callback cb, void* ctx) {
// store cb and ctx internally
// later, invoke:
cb(EVENT_TIMER, ctx);
}
void myEventHandler(int event, void* data) {
int* value = (int*)data;
printf("Event %d, value %d\n", event, *value);
}
int main() {
int myData = 42;
registerCallback(myEventHandler, &myData);
return 0;
}
דפוס זה משמש בספריות כמו GLib (GTK+), שם שיחות נושאות נתונים של משתמשים באמצעות ההרחבה (FLT:17).
סוג של קלרנס והחזקה
הצהרות מצביעות תפקודיות יכולות להפוך ללא נאמנות, במיוחד עם חתימה מורכבת.שימוש ב-FLT 18 משפר את יכולת הקריאה והפשטות:
typedef int (*Operation)(int, int);
void execute(Operation op, int a, int b) {
if (op) {
printf("Result: %d\n", op(a, b));
}
}
עכשיו (FLT:20) הוא שם מסוג נקי, זה מועיל במיוחד כאשר פונקציות מרובות callback משמשים בסיסים קוד גדול יותר.
מלכודות נפוצות ועיסוקים טובים
- (ב) עיין לפני ייעודו של ה': "תמיד תאמתו את נושא הפונקציה אינו FLT:21 לפני שתקראו לו.זה מונע תאונות מנקודות בלתי מאוישות או מובנות באופן שגוי.
- (ב) ,0) , זלזול בתיקון: (ב) ,העברת תפקיד עם חתימה לא ראויה מובילה להתנהגות בלתי מוגדרת.
- (ב) ב-[[1924]], [[1924]], [[1924]]]], [[1924]], [[1924]]]], [[1924]]]], [[1924]]]]]], [[1924]]]]]], [[1924]]]]]], [[1924]]]]]]
- (ב) ,0) ,9 ויקרא ויקרא (ב) , אם עיין בכתובות, הוא מהפך ל[[המאה ה-20]], ו[[1924]], [[1924]], [[1924]], [[1924]]]], [[1924]]]]
- (ב) [ב]הזמן של נקודות ההקשר: [ה]: [ההקשר], ה[[המאה ה-1]], הוא חייב להישאר בתוקף למשך כל הזמן שבו ניתן להפעיל את ה-Callback באופן סטטי או המפואר כאשר מתאים.
תבניות מתקדמות: אריות של פוינטרים פונקציונליים
ניתן לאחסן את נקודות הפונקציות במערךים כדי ליצור טבלאות משלוח, המאפשרות מכונות מדינה נקיות או מטפלים פיקודיים.לדוגמה, מחשבון התומך בביצועים מרובים:
typedef int (*Operation)(int, int);
int add(int x, int y) { return x + y; }
int sub(int x, int y) { return x - y; }
int mul(int x, int y) { return x * y; }
int divide(int x, int y) { return y ? x / y : 0; }
Operation operations[] = { add, sub, mul, divide };
const char* opNames[] = {"add", "sub", "mul", "div"};
int main() {
int a = 10, b = 2;
for (int i = 0; i < 4; ++i) {
printf("%s: %d\n", opNames[i], operations[i](a, b));
}
return 0;
}
ה[[1924]]]], [[1924]]]]
השוואה עם שפות אחרות
שפות כמו C++ להשתמש בעמדות הפונקציה אבל גם להציע פטריות, כבשים, ו-FLT:27 עבור גמישות רבה יותר.עם זאת, C נשאר הבסיס, וההבנה של נושאי הפונקציה חיונית לעבודה עם מערכות הפעלה API (למשל, POSIX מטפלות אותות, FLT:28), מערכות משובצות וקוד מורשת.
שיקולים
לעקיקת נקודות תפקודית יש מינימום overhead - באופן חד-משמעי אחד נקודה קצה ניתוק וקריאה עקיף. מודרני CPUs להתמודד עם סניפים עקפים ביעילות באמצעות חיזוי סניף, אבל שימוש מופרז בלולאות הדוקות עלול לגרום להאטה קלה. ברוב התרחישים, קריאה ושמירה על יכולת הרבה יותר עולה על כל עלות ביצועים.פרופיל אם לא ברור.
דוגמאות אמיתיות ל-Callbacks ב-C
- (ב) ,0) , ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
- (ב) ,0) ,9.10.10.10.10.10.10.10.10.10.10.10.10.10.10.10.10.10.10.10.10.10.10.
- (ב) ,0) לולאות בספריות בעלות רמה נמוכה (FLT:1 ), libev, libuv וספריות אירועים דומות משתמשים בקריאות עבור I/O, משככי-הזמן וסימנים.
- (ב) [17] , ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
- (FLT:0GUI ToolkitsFLT:1) - Gtk+ ו- EFL (Enlightenment Foundation Libraries) משתמשים בקריאות רבות לטיפול באירועי ולדדג'ט.
מסקנה
נקודות פונקציונליות הן אבן הפינה של תכנות C, המאפשר מנגנוני חיוג המספקים גמישות, מודולריות, וקוד שימוש חוזר. על ידי הבנת ההכרזה שלהם, שימוש עם סוג של הגנה, ודפוסים מתקדמים כמו שולחנות משלוח, אתה יכול לעצב מערכות חזקות ושמירה על שיטות הטובות ביותר: לבדוק עבור FLT:35, להבטיח תאימות חתימה, לנהל תקופות חיים, ומתקשר בבירור עם מיומנויות אלה, אתה יכול לקרוא לרתום את היכולות המלאות שלך פרויקטים Cbacks.
לקריאה נוספת, מתייחס לתיעוד הסטנדרטי של צומת:0 (C) ב- PointersFLT:1, ולחקור כיצד משתמשים בעמדות הפונקציה ב-FLT:2 The GNU C ידני WaveFLT 3: A לצלול עמוק לתוך תכנות מונחה אירוע עם שיחות ניתן למצוא במאמר ויקיפדיה על לולאות FLT5: