האם Qt משתמש ב- C ++
מסגרת QT
QT Essentials מגדירים את היסוד של QT בכל הפלטפורמות. הם זמינים בכל פלטפורמות הפיתוח הנתמכות ובפלטפורמות היעד שנבדקו.
סיכום:
1. מסגרת QT היא קבוצה מקיפה של שיעורי ספרייה C ++ המפשטים את פיתוח היישומים.
2. Qt מייצר קוד קריא מאוד, ניתן לתחזוקה ושימוש חוזר עם ביצועי זמן ריצה גבוה וטביעת רגל קטנה.
3. Qt הוא פלטפורמות חוצות, ומאפשר למפתחים ליצור יישומים לפלטפורמות מרובות.
4. QT Essentials, כגון QT Core, QT GUI, QT מולטימדיה, רשת QT, QT Quick ו- QT SQL, מהווים את היסוד של QT בכל הפלטפורמות.
5. Qt מספקת גם תוספות כמו QT OpenGL, QT Wayland Compositor, חיישני QT, QT WebView, QT Safe Renderer ו- QT SCXML למשימות ספציפיות.
6. מסגרת ה- QT מתעדפת.
7. על המפתחים להיות בעלי ידע קודם ב- C ++ לפני השימוש ב- QT.
8. סדרת ההדרכה של QT מכסה נושאים כמו תזכורת C ++, מבוא ל- QT, תכונות יוצר QT, יצירת חלונות וכפתורים, היררכיית כיתת QT ועוד.
9. דפוס הצופה, האותות והחריצים, ומידע המשדר הם חלק מהתכונות המתקדמות המכוסות בסדרת ההדרכה.
שאלות:
- האם Qt משתמש ב- C++?
כן, QT כתוב בעיקר ב- C ++ ומספק קבוצה של שיעורי ספרייה C ++ לפיתוח אפליקציות. - מהם יסודות QT?
QT Essentials הם הבסיס של QT וכוללים מודולים כמו QT Core, QT GUI, QT מולטימדיה, רשת QT, QT Quick ו- QT SQL. - מהן כמה תוספות QT?
כמה תוספות QT כוללות QT OpenGL, QT Wayland Compositor, חיישני QT, QT WebView, QT Safe Renderer ו- QT SCXML. - כיצד QT מתעדף אבטחה?
קבוצת QT מתייחסת באופן פעיל לפגיעויות ודאגות אבטחה ועוקבות אחר מדיניות אבטחה המפורטת במדיניות אבטחת הפרויקט של QT. - איזה ידע נדרש לשימוש ב- Qt?
המפתחים צריכים להיות בעלי ידע ב- C ++ לפני שהם מתחילים ב- QT. - אילו נושאים מכוסים בסדרת הדרכות QT?
סדרת ההדרכה מכסה נושאים כמו תזכורת C ++, מבוא ל- QT, תכונות יוצר QT, יצירת חלונות וכפתורים, היררכיית כיתת QT ועוד. - אילו תכונות מתקדמות מכוסות בסדרת ההדרכה?
סדרת ההדרכה מכסה תכונות מתקדמות כמו דפוס הצופה, אותות וחריצים, והעברת מידע. - הוא QT חוצה פלטפורמות?
כן, QT הוא חוצה פלטפורמות ומאפשר למפתחים ליצור יישומים הפועלים בפלטפורמות מרובות. - מה המטרה של QT חיוני ותוספות QT?
QT Essential מספק את הבסיס ל- QT, ואילו תוספות QT מציעות פונקציונליות נוספת למשימות ספציפיות. - כיצד Qt מבטיח אבטחה?
Qt מנתח באופן פעיל דוחות פגיעות ונוקטת בפעולה מהירה כדי להתייחס אליהם. קבוצת QT משתתפת גם בקבוצות היגוי רלוונטיות לדאגות אבטחה. - מהם היתרונות של השימוש ב- QT?
Qt מאפשר למפתחים לכתוב קוד קריא מאוד וניתן לתחזוקה עם ביצועי זמן ריצה מעולים. זה גם מספק יכולות חוצה פלטפורמות. - מהי מסגרת QT?
מסגרת ה- QT מורכבת ממערך מקיף של שיעורי ספרייה C ++ המפשטים את פיתוח היישומים ומספקים מודולריות. - מה דפוס הצופה?
דפוס הצופה הוא דפוס עיצוב בו אובייקט, הנקרא הנושא, שומר על רשימת משקיפים התלויים בו. כאשר מצב הנושא משתנה, הוא מודיע לכל המשקיפים שלה לעדכן אוטומטית. - מהם אותות וחריצים?
אותות וחריצים הם מנגנון ב- QT לתקשורת בין אובייקטים. אותות נפלטים על ידי אובייקטים כאשר מתרחשים אירועים מסוימים, וחריצים הם פונקציות שניתן לחבר כדי לקבל ולטפל באותות. - כיצד ניתן להעביר מידע ב- QT?
ניתן להעביר מידע ב- QT באמצעות אותות וחריצים, בהם האותות נושאים את המידע והחריצים מקבלים ומעבדים אותו.
תשובות:
1. האם Qt משתמש ב- C++?
כן, Qt משתמש בעיקר ב- C ++ לפיתוחו. זה מאפשר למפתחים למנף את הכוח והגמישות של שפת C ++ ביישומי QT שלהם.
2. מהם יסודות QT?
יסודות QT הם מודולים בסיסיים ב- QT המהווים את יסוד המסגרת. אלה כוללים QT Core, QT GUI, QT מולטימדיה, רשת QT, QT Quick ו- QT SQL. הם מספקים פונקציונליות חיונית להיבטים שונים של פיתוח יישומים, כגון מחלקות לא גרפיות, רכיבי ממשק משתמש גרפי, תמיכה במולטימדיה, תכנות רשת, פיתוח יישומים הצהרתיים ושילוב מסדי נתונים באמצעות SQL.
3. מהן כמה תוספות QT?
Qt מספק תוספות שונות המציעות פונקציונליות נוספת למשימות ספציפיות. כמה דוגמאות לתוספות QT הן:
- Qt Opengl: שיעורים לתמיכה ב- OpenGL. הוצא לטובת שיעורי Qopengl במודול QT GUI.
- Qt Compositor: מסגרת לפיתוח Compositor Wayland.
- חיישני QT: שיעורים לגישה לחומרת חיישנים ומאפשרים זיהוי מחוות תנועה.
- QT WebView: מודול המאפשר הצגת תוכן אינטרנט ביישום QML באמצעות ממשקי API של פלטפורמה במקום ערימת דפדפן אינטרנט מלאה.
- QT מעבד בטוח: מספק רכיב עיבוד ממשק המשתמש לביצוע פריטים קריטיים לבטיחותיים, כגון מדדי אזהרה, במערכות בטיחות פונקציונליות.
- Qt SCXML: מציע שיעורים וכלים ליצירת מכונות מדינה מקבצי SCXML ולהטמיע אותם ביישומים.
4. כיצד QT מתעדף אבטחה?
קבוצת QT מתייחסת ברצינות לחששות אבטחה ויש לה גישה ייעודית לטיפול בפגיעויות פוטנציאליות. מכיוון ש- QT מפותח כפרויקט קוד פתוח, ניתוח דוחות הפגיעות נעשה על ידי אנשי צוות ייעודיים ותורמים חיצוניים. קבוצת QT משתתפת באופן פעיל בקבוצות היגוי רלוונטיות ומנקטת מייד בפעולה עם קבלת דוחות פגיעות. נהלים מפורטים לטיפול בדוחות פגיעות מתוארים במדיניות אבטחת פרויקט QT.
5. איזה ידע נדרש לשימוש ב- Qt?
לפני שמתחילים ב- QT, מומלץ להבנה טובה של C++. QT מנצל בכבדות את C ++ להתפתחותה, ובהבנה מוצקה של השפה תקל על העבודה עם מסגרת QT וממשקי ה- API שלה.
6. אילו נושאים מכוסים בסדרת הדרכות QT?
סדרת הדרכות QT מכסה מגוון רחב של נושאים שיעזרו למתחילים להתחיל עם פיתוח יישומי QT. חלק מהנושאים המכוסים כוללים:
- תזכורת C ++ לרענן את היסודות
- מבוא ל- QT, תכונותיו ויכולות חוצה פלטפורמות
- מדריך להתקנת ה- QT SDK
- סקירה כללית של יוצר QT ותכונותיו
- יצירת החלון הראשון והבנת תהליך ההדרכה
- הוספת אלמנטים אינטראקטיביים כמו כפתורים ליישום
- הבנת ההיררכיה של כיתת QT ומושג הורות qobject
- סיווג משנה QWIDGET ויצירת יישומונים מותאמים אישית
- קריאה נוספת של משאבים והמלצות
7. אילו תכונות מתקדמות מכוסות בסדרת ההדרכה?
בנוסף ליסודות, סדרת הדרכות QT מתעמקת בנושאים מתקדמים יותר. כמה דוגמאות לתכונות המתקדמות המכוסות הן:
- דפוס הצופה: בחינת הרעיון וכיצד ליישם אותו ביישומי QT
- אותות וחריצים: הבנת מנגנון התקשורת בין אובייקטים
- העברת מידע: כיצד להעביר מידע בין חלקים שונים של היישום באמצעות אותות וחריצים
- מאפיינים של אותות וחריצים: תכונות ויכולות נוספות של האותות והמנגנון החריצים
8. הוא QT חוצה פלטפורמות?
כן, QT היא מסגרת חוצה פלטפורמות. זה מאפשר למפתחים לכתוב את היישומים שלהם פעם אחת ולפרוס אותם בפלטפורמות מרובות, כולל Windows, MacOS, Linux, Android ו- iOS. Qt מספק הפשטות וממשקי API המטפלים בפרטים הספציפיים לפלטפורמה, מה שמקל על פיתוח יישומים העובדים בעקביות על פני מערכות הפעלה שונות.
9. מה המטרה של QT חיוני ותוספות QT?
QT Essentials מהווים את הבסיס למסגרת QT על ידי מתן פונקציונליות ליבה ושיעורים הנמצאים בשימוש נרחב בפיתוח יישומים. הם מבטיחים חווית פיתוח עקבית ואמינה על פני פלטפורמות שונות. מצד שני, תוספות QT מציעות מודולים ותכונות נוספות ספציפיות יותר למקרים או תחומים מסוימים של שימוש. הם מספקים פונקציונליות ויכולות מורחבות מעבר ליסודות.
10. כיצד Qt מבטיח אבטחה?
Qt נוקט בגישה יזומה לאבטחה על ידי ניתוח פעיל וטיפול בפגיעויות פוטנציאליות במוצריה. קבוצת QT משתתפת בקבוצות היגוי רלוונטיות ומגיבה מייד לדוחות הפגיעות. בנוסף, כפרויקט קוד פתוח, QT מזמין תורמים חיצוניים לבחון ולנתח את הקוד, ומשפר את האבטחה הכוללת של המסגרת.
11. מהם היתרונות של השימוש ב- QT?
ישנם מספר יתרונות לשימוש ב- QT לפיתוח יישומים:
- Qt מספק קבוצה מקיפה של שיעורי ספרייה C ++ המפשטים את פיתוח היישומים, מה שהופך אותו למהיר וקל יותר לבנות יישומים חזקים.
- הקוד שנכתב באמצעות QT הוא קריא מאוד, ניתן לתחזוקה וניתן לשימוש חוזר, מצמצם את מאמצי הפיתוח ומשפר את הפרודוקטיביות.
- Qt הוא חוצה פלטפורמות, ומאפשר למפתחים לכתוב יישום פעם אחת ולפרוס אותו בפלטפורמות מרובות.
- המסגרת מציעה ביצועים מעולים בזמן ריצה, ומבטיחים יישומים חלקים ומגיבים.
- ל- QT טביעת רגל קטנה, כלומר ההפעלה המתקבלת היא קומפקטית ויעילה.
12. מהי מסגרת QT?
מסגרת QT היא אוסף מקיף של שיעורי ספרייה C ++ המספקים מגוון רחב של פונקציונליות לפיתוח יישומים. הוא מציע מבנה מודולרי, ומאפשר למפתחים להשתמש רק ברכיבים שהם צריכים. Qt מספקת כלים, ממשקי API והפשטות עבור היבטים שונים של פיתוח יישומים, כולל תכנון ממשק משתמש, שילוב מסד נתונים, רשת, מולטימדיה ועוד ועוד. זה נועד לפשט את תהליך הפיתוח, לקדם שימוש חוזר בקוד ולאפשר פיתוח יישומים חוצה פלטפורמות.
13. מה דפוס הצופה?
דפוס הצופה הוא דפוס עיצוב התנהגותי המאפשר תקשורת אחת לרבים בין אובייקטים. בדפוס הצופה, ישנן שתי ישויות עיקריות: הנושא והמשקיפים. הנושא מקיים רשימה של משקיפים ומודיע להם אוטומטית כאשר מצבו משתנה. דפוס זה מקדם צימוד רופף בין אובייקטים ומאפשר מערכת אינטראקטיבית ודינאמית ביותר. ב- QT ניתן ליישם את דפוס הצופה באמצעות אותות וחריצים, שם הנושא פולט אותות והמשקיפים מחברים את החריצים שלהם לאותות כדי לקבל עדכונים.
14. מהם אותות וחריצים?
אותות וחריצים הם מנגנון המסופק על ידי QT לתקשורת בין אובייקטים. איתות הוא פונקציה של חבר מיוחד של מעמד שמקורו בקובייקט שניתן לפלט כדי לציין כי אירוע או מצב מסוים התרחש. משבצת היא פונקציית חבר שניתן לחבר לאות כדי לקבל ולטפל בה. ניתן להשתמש באותות וחריצים כדי לבסס צימוד רופף בין חפצים, ומאפשרים להם לתקשר מבלי שיוחברו זה לזה בחוזקה. זה מקדם מודולריות וגמישות בעיצוב יישומי QT.
15. כיצד ניתן להעביר מידע ב- QT?
ב- QT ניתן להעביר מידע בין חלקים שונים של יישום באמצעות אותות וחריצים. אות יכול לשאת מידע על ידי הגדרת פרמטרים, וחריץ יכול לקבל ולעבד מידע זה. כאשר נפשם אות, כל החריצים המחוברים ייקראו עם המידע המפורט. מנגנון זה מאפשר לאובייקטים לתקשר ולהחליף נתונים מבלי להתייחס ישירות זה לזה, לקדם צימוד רופף וגמישות בעיצוב היישומים.
מסגרת QT
QT Essentials מגדירים את היסוד של QT בכל הפלטפורמות. הם זמינים בכל פלטפורמות הפיתוח הנתמכות ובפלטפורמות היעד שנבדקו.
האם Qt משתמש ב- C++
Б эой сранице
Ы зé. С помדיר. Почем эо мого?
Эа сраница о бображае тех сах, кога воматеשיים си сисלוח рmе рגות р רבות ш רבות р р рוהים р рוהים которые нé. Сраница пересанет ообрוחים. До эого момента д.
Исочником запросов может сmжж вредоносfte по, подаееые моди базלוח нилm mчnзnзnчnчnчnчnчnчnчnчnчnчnчnчnчnчnчзדי ы з запросов. Еи ы иололalty ощий дדיר. O. Подробнרבה.
Проверка по сов может тelte пояяе, еи ы водите сדיר еами, или же водите запроы ченн часо.
מסגרת QT
מסגרת ה- QT מכילה קבוצה מקיפה של שיעורי ספריית C ++ אינטואיטיביים ומודולריים ביותר ומודולריים והיא טעונה בממשקי API כדי לפשט את פיתוח היישום שלך. Qt מייצר קוד קריא מאוד, ניתן לתחזוקה בקלות ושימוש חוזר עם ביצועים גבוהים בזמן ריצה וטביעת רגל קטנה-וזה חוצה פלטפורמות.
יסודות Qt
הופך את הפלטפורמה האמיתית לאפשרית
QT Essentials מגדירים את היסוד של QT בכל הפלטפורמות. הם זמינים בכל פלטפורמות הפיתוח הנתמכות ובפלטפורמות היעד שנבדקו.
Qt Core
כיתות ליבה לא גרפיות המשמשות מודולים אחרים.
Qt Gui
שיעורי בסיס לרכיבי ממשק משתמש גרפיים. כולל OpenGL.
QT מולטימדיה
שיעורים לפונקציונליות שמע, וידאו, רדיו ומצלמה.
רשת Qt
שיעורים כדי להקל על תכנות הרשת.
Qt מהיר
מסגרת הצהרתית לבניית יישומים דינמיים מאוד עם ממשקי משתמש מותאמים אישית.
Qt sql
שיעורים לשילוב מסדי נתונים באמצעות SQL.
תוספות Qt
התוספות הנכונות
למשימה הנכונה
QT Essentials מגדירים את היסוד של QT בכל הפלטפורמות. הם זמינים בכל פלטפורמות הפיתוח הנתמכות ובפלטפורמות היעד שנבדקו.
Qt opengl
שיעורי תמיכה ב- OpenGL. הוצא לטובת שיעורי Qopengl במודול QT GUI.
Qt Compositor
מספק מסגרת לפיתוח מלחין Wayland.
חיישני Qt
מספק גישה לחומרת חיישן ולזיהוי מחוות תנועה.
Qt WebView
מציג תוכן אינטרנט ביישום QML באמצעות API.
Qt מעבד בטוח
מספק רכיב עיבוד ממשק המשתמש שניתן להשתמש בו כדי להעביר פריטים קריטיים לבטיחותיים, כמו אינדיקטורים אזהרה, במערכות בטיחות פונקציונליות.
Qt scxml
מספק שיעורים וכלים ליצירת מכונות מדינה מקבצי SCXML ולהטמיע אותם ביישומים.
נוהלי מסגרת QT לטיפול בחששות אבטחה
קבוצת QT מתעדפת את התייחסות לאיומי פגיעות פוטנציאליים ודאגות אבטחה במוצריה. עם תחולתה הרחבה של פלטפורמות וממשק ה- API הרחב, מסגרת ה- QT חשופה לסיכוני סייבר בחזיתות מגוונות. יתר על כן, QT מפותח כפרויקט קוד פתוח, הדורש ניתוח דוחות פגיעות על ידי אנשי צוות ייעודיים ותורמים חיצוניים. מאז הקמתה, קבוצת QT משתתפת באופן פעיל בקבוצות ההיגוי הרלוונטיות ונוקטת פעולה מהירה על פי דוחות פגיעות. דוחות פגיעות נשלטים על ידי נהלים ספציפיים המפורטים במדיניות אבטחת הפרויקט של QT.
Qt למתחילים
אַזהָרָה : הקפד לקבל קצת ידע ב- C ++ לפני שמתחילים!
הֶעָרָה : סדרת הדרכה זו יעד בעיקר QT4. גם אם מרבית ההדרכות הללו תקפות גם עבור QT5, המקרה של QT5 נדון בחלק נפרד.
תוכן
- 1 C ++ תזכורת
- 2 מבוא ל- Qt
- 3 התקנת QT SDK
- 4 תכונות יוצר QT
- 5 החלון הראשון שלנו
- 6 כיצד נערכת תוכנית QT
- 7 כפתור יפה
- 8 היררכיה של כיתת QT
- 9 מערכת הורות
- 10 סיווג משנה QWIDGET
- 11 קריאה נוספת
- 12 דפוס הצופה
- 13 אותות וחריצים
- 14 העברת מידע
- 15 תכונות של אותות וחריצים
- 16 דוגמאות
- 16.1 בתגובה לאירוע
- 21.1 יצירת משבצות בהתאמה אישית
- 21.2 יצירת אותות
- 21.דוגמה 3
תזכורת C ++
ה חֲתִימָה של שיטה או פונקציה הם פשוט אב -הטיפוס שלה. זה מתאר לחלוטין שיטה או פונקציה. הוא מכיל את הסוג המוחזר, את שם השיטה/הפונקציה (כולל שם הכיתה) והפרמטרים, כולל סוגים.
סוּג Myobject::myfunction(( סוג 1 param1, סוג 2 *param2, const סוג 3 & ¶m3 );
חדש ב- Qt? לא יודע איך להתחיל? ואז דף הוויקי הזה מיועד לך! זהו הדרכה שלב אחר שלב המציגה את כל הספציפיות והתכונות של QT. רוצה ללמוד עוד? עיין בשיעורי GUI של C ++ עבור QT 5 ו- C ++ GUI עבור QT 6.
מבוא ל- Qt
Qt (מבוטא כ”חמוד “, לא” Cu-Tee “) הוא מסגרת חוצה פלטפורמות שמשמשת בדרך כלל כערכת כלים גרפית, אם כי היא גם מועילה מאוד ביצירת יישומי CLI. זה פועל בשלושת המערכות השולחניות העיקריות, כמו גם במבעות מערבי ניידות, כמו סימביאן, נוקיה בל, מיגו הרמטן, מיגו או BB10, ובמכשירים משובצים. יציאות לאנדרואיד (Deectrietas) ו- iOS נמצאים גם הם בפיתוח.
ל- QT אוסף מרשים של מודולים, כולל
- Qtcore, ספריית בסיס המספקת מכולות, ניהול חוטים, ניהול אירועים ועוד הרבה
- Qtgui וכן Qtwidgets, ערכת כלים של GUI לשולחן העבודה, המספקת הרבה רכיבים גרפיים לעיצוב יישומים.
- Qtnetwork, המספק קבוצה שימושית של שיעורים להתמודדות עם תקשורת רשת
- Qtwebkit, מנוע WebKit, המאפשר שימוש בדפי אינטרנט ובאפליקציות אינטרנט ביישום QT.
- QTSQL, שכבת הפשטה של SQL RDBM המוצגת במלואה ניתנת להרחבה עם נהגים משלהם, תמיכה ב- ODBC, SQLITE, MySQL ו- PostgreSQL זמינה מחוץ לקופסה
- Qtxml, תמיכה בנתח XML פשוט (SAX) ו- DOM
- Qtxmlpatterns, תמיכה ב- XSLT, XPath, XQuery ו- Schema Ex
התקנת QT SDK
כדי להתחיל לכתוב יישומי QT, עליכם להשיג ספריות QT, ואם תרצו, IDE. ניתן לבנות אותם ממקור, או יותר טוב, להורדה כ- SDK מדף ההורדה.
SDK זה כולל הרבה תכונות, כמו מהדרים צולבים לסימביאן ולנוקיה N9. תוכל לבחור לא להתקין אותם על ידי בחירת “התקנה מותאמת אישית”. הקפד לשמור על חבילות אלה
- תיעוד QMake
- תיעוד Qt
- Qt 4.8.1 (שולחן עבודה), בהנחה ש- Qt 4.8.1 היא הגרסה האחרונה.
- יוצר Qt
חבילות אלה יכולות גם להיות שימושיות
- דוגמאות Qt
- בלשן Qt
אתה יכול לבחור חבילות אחרות אם ברצונך לפתח עבור Symbian / Maemo / Meego, או עם גרסה ישנה יותר של Qt.
Nb : ב- Linux, עדיף להשתמש בחבילות שההפצה שלך מספקת. יוצר QT צריך להיות זמין כמעט בכל ההפצות, ולהתקין אותו אמור להתקין את כל התלות, כמו ספריות, מהדרים וכותרות פיתוח.
הערה: עיין בדף הפקיד עם תחילת העבודה עם QT Widgets להדרכה אלטרנטיבית.
אנו מוכנים כעת ליצור את החלון הראשון שלנו. וזה יהיה כרגיל, א שלום עולם.
תכונות יוצר QT
לפני שתכתוב את אפליקציית ה- GUI הראשונה שלנו, בואו נגלה את יוצר QT.
יוצר QT הוא עוד IDE עבור C ++, אך הוא מתאים מאוד לקידוד יישומי QT. הוא מספק דפדפן DOC ו”מעצב “, מה שמקל על יצירת חלונות, כולם עטופים בממשק משתמש מעוצב היטב. זה גם אחד ה- IDE המהירים ביותר שקיימים.
החלון הראשון שלנו
נתחיל ביצירת הפרויקט הראשון שלנו. זה יהיה פרויקט ריק, ולכן עלינו להמשיך עם: קובץ> קובץ או פרויקט חדש> פרויקטים אחרים> פרויקט QT ריק
עקוב אחר האשף, ואחרי בחירת תיקיית הפרויקט ושם, ובחר את גרסת ה- QT לשימוש, עליך לנחות בעמוד זה
זהו קובץ הפרויקט (סיומת .מִקצוֹעָן). Qt משתמש בכלי שורת פקודה המנתק את קבצי הפרויקט הללו על מנת לייצר “Makefiles”, קבצים המשמשים את המהדרים לבניית יישום. כלי זה נקרא qmake. אבל, אל לנו לטרוח יותר מדי על QMake, מכיוון שיוצר QT יעשה את העבודה בשבילנו.
בקובץ פרויקט יש קוד מינימלי שצריך תמיד לכתוב:
תבנית = App Target = name_of_the_app qt = core gui GreaterThan (qt_major_version, 4): qt += ווידג'טים
- תבנית מתאר את הסוג לבנייה. זה יכול להיות יישום, ספריה או פשוט ספריות משנה.
- יַעַד הוא שם האפליקציה או הספרייה.
- Qt משמש כדי לציין אילו ספריות (מודולי QT) משמשים בפרויקט זה. מכיוון שהאפליקציה הראשונה שלנו היא GUI קטנה, אנו נצטרך QTCORE ו- QTGUI.
בואו נוסיף כעת את נקודת הכניסה של היישום שלנו. שימוש בקובץ> קובץ או פרויקט חדש> C ++> C ++ קובץ המקור צריך לבצע את העבודה.
עקוב אחר הקוסם שוב, שם את הקובץ “עיקרי”, וסיימת. תבחין כי בקובץ הפרויקט, שורה חדשה נוספה אוטומטית על ידי QT Creator:
תבנית = App Target = name_of_the_app qt = core gui GreaterThan (qt_major_version, 4): qt += מקורות ווידג'טים += main.CPP
ניתן להוסיף קבצי כותרות ומקורות באופן ידני עם
כותרות += first_file.H Second_File.מקורות H += first_file.cpp second_file.CPP
כותרות += first_file.H Second_File.מקורות H += first_file.cpp second_file.CPP
אם אתה משתמש במכשפים של יוצר QT, זה נעשה באופן אוטומטי.
קוד המקור המינימלי של יישום QT הוא
#לִכלוֹל Int רָאשִׁי((Int Argc, לְהַשְׁחִיר ***argv) Qapplication אפליקציה ((Argc, argv); לַחֲזוֹר אפליקציה.EXEC(); >
Qapplication הוא מעמד חשוב מאוד. זה דואג לטיעוני קלט, אבל גם הרבה דברים אחרים, והכי בולטים, לולאת אירועים. לולאת האירוע היא לולאה שמחכה לקלט משתמש ביישומי GUI.
כאשר מתקשרת אפליקציה.Exec () לולאת האירועים מושקת.
בואו נרכיב את היישום הזה. על ידי לחיצה על החץ הירוק בצד שמאל למטה, יוצר QT ייקח ויבצע אותו. ומה קרה? נראה כי האפליקציה הושקה ולא מגיבה. זה למעשה נורמלי. לולאת האירועים פועלת ומחכה לאירועים, כמו לחיצות על עכבר על GUI, אך לא סיפקנו שום אירוע לעיבוד, כך שהוא יפעל ללא הגבלת זמן.
בואו נוסיף משהו שיוצג.
#לִכלוֹל #לִכלוֹל Int רָאשִׁי((Int Argc, לְהַשְׁחִיר ***argv) Qapplication אפליקציה ((Argc, argv); Qpushbutton לַחְצָן (("שלום עולם !"); לַחְצָן.הופעה(); לַחֲזוֹר אפליקציה.EXEC(); >
להרכיב את זה, ו … הנה זה ! החלון הראשון שלנו !
כיצד נערכת תוכנית QT
QT יוצר עושה את התפקיד להפקת עבורנו את מערכת הבנייה, אך יתכן שיהיה מעניין לדעת כיצד נערכים תוכניות QT.
עבור תוכניות קטנות, קל להרכיב הכל ביד, ליצור קבצי אובייקט ואז לקשר אותם. אבל לפרויקטים גדולים יותר, שורת הפקודה הופכת בקלות לקשה לכתוב. אם אתה מכיר את לינוקס, אתה יכול לדעת שכל התוכניות מורכבות באמצעות MakeFile המתאר את כל שורות הפקודה הללו לביצוע. אבל עבור כמה פרויקטים, אפילו כתיבת קובץ Makefile יכולה להיות מייגעת.
qmake היא מערכת הבנייה שמגיעה עם QT, והיא מייצרת עבורך את אותם תופעות (יש מערכות בנייה אחרות שניתן להשתמש בהן, אבל כאן אנו נותנים דוגמא עם qmake). עם תחביר פשוט, הוא מייצר את ה- MakeFile המשמש לרכבת תוכנית QT. אבל זו לא מטרתה היחידה. Qt משתמש במטא-אובייקטים כדי להרחיב פונקציונליות C ++, ו- QMake אחראי על הכנת קובץ Makefile המכיל שלב מיצוי מטא-אובייקט זה. תראה זאת בפרק אחר.
אז, אפליקציות QT נערכות בשלושה שלבים
- א .מִקצוֹעָן הקובץ כתוב כדי לתאר את הפרויקט כדי להרכיב
- נוצר MakeFile באמצעות qmake
- התוכנית בנויה באמצעות עשה (אוֹ nmake אוֹ JOM ב- Windows)
כפתור יפה
פרק זה נותן סקירה של מודולי הווידג’טים. הוא יכסה את תכונות הווידג’טים, את ערכת הירושה המשמשת בווידג’טים, וגם במערכת ההורות.
עכשיו כשיש לנו את הכפתור שלנו, ייתכן שנרצה להתאים אותו קצת.
לאובייקטים של QT יש הרבה תכונות שניתן לשנות באמצעות Getters and Setleders. ב- QT, אם נקרא תכונה פו, ל- Getter and Setter המשויכים יהיו חתימות אלה
T פו() const; בָּטֵל setfoo((const T);
למעשה, QT מרחיב את מערכת התכונות והמתנחלים הזו למשהו שנקרא תכונה. מאפיין הוא ערך מכל סוג שאפשר לגשת אליו, להיות לשנות או קבוע ויכול להודיע לשינוי. מערכת הנכס שימושית, במיוחד בחלק השלישי (QML). לעת עתה, אנו נשתמש ב”תכונה “או” מאפיין “כדי לעשות את אותו הדבר.
ל- Qpushbutton יש הרבה מאפיינים:
כך שנוכל להשתמש באלה כדי להתאים אישית את הכפתור.
בואו נשנה את הטקסט תחילה ונוסיף סבר כלים
#לִכלוֹל #לִכלוֹל Int רָאשִׁי((Int Argc, לְהַשְׁחִיר ***argv) Qapplication אפליקציה ((Argc, argv); Qpushbutton לַחְצָן; לַחְצָן.settext(("הטקסט שלי"); לַחְצָן.settooltip(("הסבר כלים"); לַחְצָן.הופעה(); לַחֲזוֹר אפליקציה.EXEC(); >
הנה התוצאה:
אנחנו יכולים גם לשנות את הגופן. ב- QT, גופן מיוצג עם כיתת QFONT. התיעוד מספק מידע רב. אנו מודאגים במיוחד כאן עם אחד הבונים של Qfont.
Qfont((const Qstring & & מִשׁפָּחָה, Int גודל = -1, Int מִשׁקָל = -1, בול נטוי = שֶׁקֶר)
על מנת לשנות את הגופן, עלינו להפעיל מחלקת QFONT ולהעביר אותו ל- QPUSHBUTTON באמצעות SETFONT . הקטע הבא ישנה את הגופן לשליח.
Qfont גוֹפָן (("שָׁלִיחַ"); לַחְצָן.SetFont((גוֹפָן);
אתה יכול לנסות פרמטרים אחרים של הבנאי של Qfont כדי לשחזר את הכפתור המיוצג בתמונה הראשונה בפרק זה.
גם הגדרת אייקון לא קשה מאוד. אייקון מיוצג עם כיתת Qicon. ותוכלו ליצור אייקון בתנאי שיש לו נתיב מוחלט (או יחסית) במערכת הקבצים. אני ממליץ לספק את הדרך המוחלטת בדוגמה זו. אך לשיקולי פריסה, אתה יכול להשתמש בנתיב היחסי, או יותר טוב, מערכת המשאבים.
QICON אייקון (("/נתיב/אל/שלי/אייקון/אייקון.png "); לַחְצָן.seticon((אייקון);
ב- Linux, וכמה מערכת הפעלה אחרת, יש דרך נוחה להגדיר אייקון מנושא אייקון. ניתן לעשות זאת באמצעות השיטה הסטטית:
QICON QICON::מהמשם (( const Qstring & &שֵׁם, const QICON & &לסגת = QICON());
לדוגמה, בתמונת המסך בתחילת פרק זה, הסמיילי מגיע מנושא אייקון החמצן KDE ונקבע על ידי:
לַחְצָן.seticon((QICON::מהמשם(("פנוי פיל"));
היררכיה של כיתת QT
Qt משתמשת באופן נרחב בירושה, במיוחד במודול הווידג’טים. הגרף הבא מציג כמה מהירושות הללו:
Qobject הוא המעמד הבסיסי ביותר ב- Qt. רוב השיעורים ב- QT יורשים מכיתה זו. Qobject מספק כמה יכולות חזקות מאוד כמו:
- שם אובייקט : אתה יכול להגדיר שם, כמחרוזת, לאובייקט ולחפש אובייקטים לפי שמות.
- מערכת הורות (מתואר בסעיף הבא)
- אותות וחריצים (מתואר בפרק הבא)
- ניהול אירועים
ווידג’טים מסוגלים להגיב לאירועים ולהשתמש במערכת ההורות ובמנגנון האותות והמגרשים. כל הווידג’טים יורשים מ- qobject. הווידג’ט הבסיסי ביותר הוא ה- QWIDGET . QWidget מכיל את מרבית המאפיינים המשמשים לתיאור חלון, או ווידג’ט, כמו מיקום וגודל, סמן עכבר, טיפים כלים וכו ‘.
הֶעָרָה : ב- QT, יישומון יכול להיות גם חלון. בסעיף הקודם הצגנו כפתור שהוא יישומון, אך הוא מופיע ישירות כחלון. אין צורך בשיעור “qwindow”.
כמעט כל האלמנטים הגרפיים יורשים מ- QWIDGET. אנו יכולים לרשום למשל:
QabStractButton, כיתת בסיס לכל סוגי הכפתורים Qpushbutton QCheckbox Qradiobutton Qframe, המציגה מסגרת Qlabel, המציגה טקסט או תמונה
ירושה זו נעשית על מנת להקל על ניהול נכסים. ניתן להשתמש במאפיינים משותפים כמו גודל וסמנים על רכיבים גרפיים אחרים, ו- QabStractButton מספק מאפיינים בסיסיים המשותפים לכל הכפתורים.
מערכת הורות
מערכת הורות היא דרך נוחה להתמודד עם אובייקטים ב- QT, במיוחד ווידג’טים. לכל אובייקט שיורש מ- qobject יכול להיות הורה וילדים. עץ ההיררכיה הזה הופך דברים רבים לנוחים:
- כאשר חפץ נהרס, כל ילדיו נהרסים גם כן. אז, מתקשר לִמְחוֹק הופך להיות אופציונלי במקרים מסוימים.
- לכל הקובייקטים יש FindChild וכן FindChildren שיטות שניתן להשתמש בהן לחיפוש ילדים של אובייקט נתון.
- ווידג’טים לילדים ב- QWidget מופיעים אוטומטית בתוך יישומון ההורה.
הקטע הבא שיוצר כפתור Qpushbutton בתוך Qpushbutton:
#לִכלוֹל #לִכלוֹל Int רָאשִׁי((Int Argc, לְהַשְׁחִיר ***argv) Qapplication אפליקציה ((Argc, argv); Qpushbutton כפתור 1 (("מִבְחָן"); Qpushbutton כפתור 2 (("אַחֵר", & &כפתור 1); כפתור 1.הופעה(); לַחֲזוֹר אפליקציה.EXEC(); >
ניתן גם לציין שכאשר היישום סגור, כפתור 1, המוקצה על הערימה, מועסק. מכיוון שלכפתור 2 יש כפתור 1 כהורה, הוא נמחק גם. אתה יכול אפילו לבדוק את זה אצל יוצר QT בקטע הניתוח, על ידי חיפוש דליפת זיכרון – לא יהיה.
ברור שאין תועלת בהכנסת כפתור לכפתור, אך בהתבסס על רעיון זה, אולי נרצה להכניס לחצנים למיכל, שאינו מציג שום דבר. מיכל זה הוא פשוט ה- QWIDGET .
הקוד הבא משמש להצגת כפתור בתוך ווידג’ט:
#לִכלוֹל #לִכלוֹל Int רָאשִׁי((Int Argc, לְהַשְׁחִיר ***argv) Qapplication אפליקציה ((Argc, argv); QWidget חַלוֹן; חַלוֹן.setFixedSize((100, 50); Qpushbutton *לַחְצָן = חָדָשׁ Qpushbutton(("שלום עולם", & &חַלוֹן); לַחְצָן->Setgeometry((10, 10, 80, 30); חַלוֹן.הופעה(); לַחֲזוֹר אפליקציה.EXEC(); >
שים לב שאנו יוצרים יישומון בגודל קבוע (הפועל כחלון) באמצעות setFixedSize. לשיטה זו יש את החתימה הבאה:
בָּטֵל QWidget::setFixedSize((Int רוֹחַב, Int גוֹבַה);
מיקמנו גם את הכפתור באמצעות Setgeometry. לשיטה זו יש את החתימה הבאה:
בָּטֵל QWidget::Setgeometry((Int איקס, Int y, Int רוֹחַב, Int גוֹבַה);
סיווג QWIDGET
עד עכשיו, הכנסנו את כל הקוד שלנו ל רָאשִׁי פוּנקצִיָה. זו לא הייתה בעיה עבור הדוגמאות הפשוטות שלנו, אבל ליישומים מורכבים יותר ויותר אנו עשויים לרצות לפצל את הקוד שלנו לשיעורים שונים. מה שנעשה לעתים קרובות הוא ליצור מחלקה המשמשת להצגת חלון, וליישם את כל הווידג’טים הכלולים בחלון זה כתכונות של מעמד זה.
בתוך יוצר QT, באפשרותך ליצור אוטומטית מחלקה חדשה עם קובץ> קובץ או פרויקט חדש> C ++> C ++ כיתה
הפוך את הכיתה לרשת מ- QWidget, ועליך לקבל קוד דומה להלן
#ifndef windows_h #הגדר חלון_ה #לִכלוֹל מעמד חַלוֹן : פּוּמְבֵּי QWidget Q_object פּוּמְבֵּי: מְפוֹרָשׁ חַלוֹן((QWidget *הוֹרֶה = 0); אותות: פּוּמְבֵּי משבצות: >; #endif // חלון_ה
#לִכלוֹל "חַלוֹן.H " חַלוֹן::חַלוֹן((QWidget *הוֹרֶה) : QWidget((הוֹרֶה) <>
אתה יכול לראות שיוצר QT מייצר אוטומטית תבנית כיתה. שימו לב שיש כמה אלמנטים חדשים בכותרת:
- ה Q_object מאקרו.
- קטגוריה חדשה של שיטות: אותות
- קטגוריה חדשה של שיטות: משבצות ציבוריות
כל האלמנטים הללו יוסברו בפרק הבא, ואף אחד מהם אינו נחוץ כעת. יישום החלון נעשה בבנאי. אנו יכולים להכריז על גודל החלון, כמו גם על הווידג’טים שהחלון הזה מכיל ומיקומם. לדוגמה, יישום החלון הקודם המכיל כפתור יכול להיעשות בדרך זו:
#לִכלוֹל #לִכלוֹל "חַלוֹן.H " Int רָאשִׁי((Int Argc, לְהַשְׁחִיר ***argv) Qapplication אפליקציה ((Argc, argv); חַלוֹן חַלוֹן; חַלוֹן.הופעה(); לַחֲזוֹר אפליקציה.EXEC(); >
#ifndef windows_h #הגדר חלון_ה #לִכלוֹל מעמד Qpushbutton; מעמד חַלוֹן : פּוּמְבֵּי QWidget פּוּמְבֵּי: מְפוֹרָשׁ חַלוֹן((QWidget *הוֹרֶה = 0); פְּרָטִי: Qpushbutton *m_button; >; #endif // חלון_ה
#לִכלוֹל "חַלוֹן.H " #לִכלוֹל חַלוֹן::חַלוֹן((QWidget *הוֹרֶה) : QWidget((הוֹרֶה) // הגדר את גודל החלון setFixedSize((100, 50); // ליצור ולמקם את הכפתור m_button = חָדָשׁ Qpushbutton(("שלום עולם", זֶה); m_button->Setgeometry((10, 10, 80, 30); >
שימו לב שאין צורך בכתיבת הרס למחיקת M_BUTTON . עם מערכת ההורות, כאשר מופע החלון יוצא מהערימה, M_Button נמחק אוטומטית.
לקריאה נוספת
סקירה טובה יותר של Qpushbutton ניתנת בדף הוויקי הזה כיצד להשתמש ב- QPushbutton
דפוס הצופה
כמעט לכל ערכות הכלים של ממשק המשתמש יש מנגנון לאיתור פעולת משתמש ולהגיב לפעולה זו. חלקם משתמשים התקשרות חוזרת, אחרים משתמשים מאזינים, אבל בעיקרון, כולם נוצרו בהשראת דפוס הצופה.
דפוס הצופה משמש כאשר ניתן לצפייה אובייקט רוצה להודיע לאחרים מַשׁקִיף חפצים לגבי שינוי מדינה. להלן כמה דוגמאות קונקרטיות:
- משתמש לחץ על כפתור, ויש להציג תפריט.
- דף אינטרנט בדיוק סיים לטעון, ותהליך צריך לחלץ מידע כלשהו מהדף הטעון הזה.
- משתמש מגלגל דרך רשימת פריטים (בחנות אפליקציות למשל), והגיע לסוף, כך שיש לטעון פריטים נוספים.
דפוס הצופה משמש בכל מקום ביישומי GUI, ולעתים קרובות מוביל לקוד של לוח דוד כלשהו. Qt נוצר עם הרעיון להסיר את קוד לוח הדוד הזה ולספק תחביר נקי נחמד. מנגנון האות והמשבצות מאפשר זאת.
אותות וחריצים
במקום שיש להם חפצים וצופים ניתנים לצפייה, ולרשום אותם, QT מספק שני מושגים ברמה גבוהה: אותות וכן משבצות.
- א אוֹת היא הודעה שאובייקט יכול לשלוח, בדרך כלל כדי לדווח על שינוי סטטוס.
- א חָרִיץ היא פונקציה שמקבלת ומגיבה לאות.
להלן כמה דוגמאות לאותות וחריצים משיעור Qpushbutton הידוע שלנו.
כפי שאתה יכול לראות, שמותיהם די מפורשים. אותות אלה נשלחים כאשר המשתמש לוחץ (לוחץ, ואז משחרר), לוחץ או משחרר את הכפתור.
להלן כמה משבצות, משיעורים שונים.
- Qapplication :: צא
- Qwidget :: setEnabled
- Qpushbutton :: settext
על מנת להגיב לאות, משבצת חייבת להיות מְחוּבָּר לאות. Qt מספק את השיטה qobject ::לְחַבֵּר. זה משמש בדרך זו, עם שני המקרו אוֹת וכן חָרִיץ .
Fooobjecta *פואה = חָדָשׁ Fooobjecta(); Fooobjectb *פובוב = חָדָשׁ Fooobjectb(); Qobject::לְחַבֵּר((פואה, אוֹת ((נמרץ()), פובוב, חָרִיץ ((בז()));
דוגמה זו מניחה של- FooObjecta יש אות מחוספס, ול- FooObjectB יש חריץ Baz.
אתה צריך לכתוב את חתימת האות והחריץ בתוך שני המקרו אוֹת וכן חָרִיץ. אם אתה רוצה מידע נוסף על מה שעושים מאקרו אלה, אנא קרא את החלק האחרון בפרק זה.
הֶעָרָה בעיקר. אמנם הרעיון של אות כשיטה הוא יוצא דופן, חריץ הוא למעשה שיטה אמיתית, ויכול להיקרא כרגיל בשיטות אחרות, או תוך כדי תגובה לאות.
העברת מידע
מנגנון האותות והמשבצות מועיל להגיב ללחיצות כפתורים, אך הוא יכול לעשות הרבה יותר מזה. לדוגמה, ניתן להשתמש בו גם כדי לתקשר מידע. בואו נגיד בזמן שמנגינת שיר, יש צורך בסרגל התקדמות כדי להראות כמה זמן נשאר לפני השיר נגמר. לשחקן מדיה עשוי להיות שיעור המשמש לבדיקת התקדמות התקשורת. מופע של כיתה זו עשוי לשלוח מעת לעת א תִקתוּק איתות, עם ערך ההתקדמות. ניתן לחבר אות זה ל- QProgressBar, שניתן להשתמש בו כדי להציג את ההתקדמות.
המעמד ההיפותטי המשמש לבדיקת ההתקדמות עשוי להיות בעל איתות שיש לו חתימה זו:
בָּטֵל MediaProgressManager::תִקתוּק((Int מילי -שניות);
ואנחנו יודעים מהתיעוד, כי ל- QprogressBar יש משבצת זו:
בָּטֵל QProgressBar::הגדר ערך((Int ערך);
אתה יכול לראות שלאות האות ולחריץ יש סוג זהה של פרמטרים, במיוחד הסוג. אם אתה מחבר אות לחריץ שאינו חולק את אותו סוג של פרמטרים, כאשר החיבור מסתיים (בזמן ריצה) תקבל אזהרה כמו:
Qobject::לְחַבֵּר: שאינו עולה בקנה אחד שׁוֹלֵחַ/ /מַקְלֵט טיעונים
הסיבה לכך היא שהאות מעביר את המידע לחריץ באמצעות הפרמטרים. הפרמטר הראשון של האות מועבר לראשון של החריץ, וזהה לשני, שלישי וכן הלאה.
הקוד לחיבור ייראה כך:
MediaProgressManager *מנהל = חָדָשׁ MediaProgressManager(); QProgressBar *התקדמות = חָדָשׁ QProgressBar((חַלוֹן); Qobject::לְחַבֵּר((מנהל, אוֹת ((תִקתוּק((Int)), התקדמות, חָרִיץ ((הגדר ערך((Int)));
אתה יכול לראות שאתה צריך לספק חתימה בתוך אוֹת וכן חָרִיץ מאקרו, המספק את סוג הערכים המועברים דרך האותות. אתה יכול גם לספק את שם המשתנה אם אתה רוצה. (זה למעשה אפילו טוב יותר).
תכונות של אותות וחריצים
- ניתן לחבר אות למספר משבצות
- ניתן לחבר אותות רבים לחריץ
- ניתן לחבר אות לאות: הוא ממסר אות. האות השני נשלח אם האות הראשון נשלח.
דוגמאות
מגיב לאירוע
זכור את אפליקציית הכפתורים שלנו? בואו ננסה לעשות משהו עם האפליקציה הזו, כמו להיות מסוגל לסגור אותה על ידי לחיצה על הכפתור. אנו כבר יודעים ש- Qpushbutton מספק את לחץ אוֹת. עלינו גם לדעת ש- Qapplication מספק את לְהַפְסִיק חריץ, שסוגר את היישום.
על מנת ללחוץ על כפתור סגור את האפליקציה, עלינו לחבר את האות לחץ נפלט על ידי הכפתור אל לְהַפְסִיק משבצת של מופע Qapplication זה. אנו יכולים לשנות את הקוד מהקטע הקודם כדי לעשות זאת, אך לפני שנעשה זאת, אולי תוהה כיצד לקבל גישה למופע Qapplication בזמן שאתה בכיתה אחרת. למעשה, זה די פשוט, מכיוון שקיימת פונקציה סטטית ב- Qapplication, עם החתימה הבאה, שמשמשת כדי להשיג אותה:
Qapplication * Qapplication::למשל()
זה מוביל לשינוי הבא של הקוד הקודם שלנו:
#לִכלוֹל "חַלוֹן.H " #לִכלוֹל #לִכלוֹל חַלוֹן::חַלוֹן((QWidget *הוֹרֶה) : QWidget((הוֹרֶה) // הגדר את גודל החלון setFixedSize((100, 50); // ליצור ולמקם את הכפתור m_button = חָדָשׁ Qpushbutton(("שלום עולם", זֶה); m_button->Setgeometry((10, 10, 80, 30); // חדש: צור את החיבור לְחַבֵּר((m_button, אוֹת ((לחץ()), Qapplication::למשל(), חָרִיץ ((לְהַפְסִיק())); >
כאשר לוחצים על כפתור החלון, היישום יפסיק.
העברת מידע עם אותות וחריצים
להלן דוגמה פשוטה יותר להעברת מידע. זה מציג רק סרגל התקדמות ומחוון (שנוצר על ידי Qslider) בתוך חלון, ובעוד שהמחוון מועבר, הערך של סרגל ההתקדמות מסונכרן עם חיבור פשוט מאוד.
האותות והחריצים המעניינים הם:
בָּטֵל Qslider::valuechanged((Int ערך); בָּטֵל QProgressBar::הגדר ערך((Int ערך);
Qslider פולט אוטומטית את האות valueChanged עם הערך החדש שהועבר כפרמטר בעת שינוי הערך, ושיטת שיטת הערך של QProgressBar, כפי שראינו, כדי לקבוע את ערך סרגל ההתקדמות.
זה מוביל לקוד הבא:
#לִכלוֹל #לִכלוֹל #לִכלוֹל Int רָאשִׁי((Int Argc, לְהַשְׁחִיר ***argv) Qapplication אפליקציה ((Argc, argv); // צור חלון מיכל QWidget חַלוֹן; חַלוֹן.setFixedSize((200, 80); // צור סרגל התקדמות // עם הטווח בין 0 ל 100, וערך התחלה של 0 QProgressBar *ProgressBar = חָדָשׁ QProgressBar((& &חַלוֹן); ProgressBar->setrange((0, 100); ProgressBar->הגדר ערך((0); ProgressBar->Setgeometry((10, 10, 180, 30); // צור מחוון אופקי // עם הטווח בין 0 ל 100, וערך התחלה של 0 Qslider *מחוון = חָדָשׁ Qslider((& &חַלוֹן); מחוון->Setorientation((Qt::אופקי); מחוון->setrange((0, 100); מחוון->הגדר ערך((0); מחוון->Setgeometry((10, 40, 180, 30); חַלוֹן.הופעה(); // חיבור // חיבור זה קבע את ערך סרגל ההתקדמות // בזמן שערך המחוון משתנה Qobject::לְחַבֵּר((מחוון, אוֹת ((valuechanged((Int)), ProgressBar, חָרִיץ ((הגדר ערך((Int))); לַחֲזוֹר אפליקציה.EXEC(); >
היבט טכני
ניתן לדלג על קטע זה לעת עתה אם אתה רוצה רק לתכנת עם QT. רק דע שאתה צריך לשים אוֹת וכן חָרִיץ סביב האותות והחריצים תוך כדי קריאה להתחבר . אם אתה רוצה לדעת איך QT עובד, עדיף לקרוא את זה.
אובייקט המטא
Qt מספק א מטא-אובייקט מערכת. מטא-אובייקט (פשוטו כמשמעו “על האובייקט”) הוא דרך להשיג כמה פרדיגמות תכנות שבדרך כלל בלתי אפשרי להשיג עם C ++ טהור כמו:
- הִסתַכְּלוּת פְּנִימִית : יכולת לבחון סוג בזמן ריצה
- שיחות פונקציה אסינכרוניות
כדי להשתמש ביכולות מטא-אובייקט כאלה ביישום, ניתן לתת משנה את Qobject ולסמן אותו כך שהמהדר Meta-Object (MOC) יוכל לפרש ולתרגם אותו.
קוד המיוצר על ידי MOC כולל אותות וחתימות משבצות, שיטות המשמשות לאחזר מטה-מידע מאותן כיתות מסומנות, טיפול במאפיינים. ניתן לגשת לכל המידע הזה בשיטה הבאה:
const QMetaObject * Qobject::metaobject () const
כיתת QMetaObject מכילה את כל השיטות העוסקות במטא-אובייקטים.
מקרואים חשובים
המאקרו החשוב ביותר הוא Q_object. לא ניתן לפרש את חיבורי חריץ האות והתחביר שלהם על ידי מהדר C ++ רגיל. ה- MOC מסופק כדי לתרגם את התחביר QT כמו “Connect”, “אותות”, “חריצים” וכו ‘לתחביר C ++ רגיל. זה נעשה על ידי ציון ה- Q_object מאקרו בכותרת המכילה הגדרות מחלקה המשתמשות בתחביר כזה.
מעמד Mywidget : פּוּמְבֵּי QWidget Q_object פּוּמְבֵּי: Mywidget((QWidget *הוֹרֶה = 0); >
אחרים מאקרו של סמן עבור MOC הם
- אותות
- ציבורי / מוגן / פרטי משבצות
המסמנים את השיטות השונות שצריך להרחיב.
אוֹת וכן חָרִיץ הם גם שני מאקרו חשובים מאוד ושימושיים. כאשר נפשם אות, מערכת המטה-אובייקטים משמשת להשוואה בין חתימת האות, כדי לבדוק את החיבור ולמצוא החריץ באמצעות חתימתו. מקרואים אלה משמשים למעשה להמיר חתימת השיטה המסופקת למחרוזת התואמת את זה המאוחסן במטא-אובייקט.
יצירת אותות וחריצים מותאמים אישית
פרק זה מכסה את החלק השני של האותות והחריצים: יישום אותות וחריצים מותאמים אישית.
יצירת חריצים וסימנים מותאמים אישית היא ממש פשוטה. משבצות הן כמו שיטות רגילות, אך עם קישוטים קטנים מסביב, בעוד שאותות זקוקים ליישום מועט ללא כל יישום.
יצירת אותות וחריצים מותאמים אישית היא מאוד פשוטה. זה מתואר על ידי רשימת הבדיקה הבאה:
- לְהוֹסִיף Q_object מאקרו
- לְהוֹסִיף אותות קטע וכתוב אבות -טיפוס של אותות
- לְהוֹסִיף משבצות ציבוריות אוֹ חריצים מוגנים אוֹ משבצות פרטיות קטעים וכתוב אבות -טיפוס של חריצים
- ליישם משבצות כשיטות רגילות
- לקבוע קשרים
יצירת משבצות בהתאמה אישית
על מנת ליישם משבצת, ראשית עלינו לגרום לכיתה להיות מסוגלת לשלוח איתותים ולהיות משבצות (ראה הפרק הקודם). זה נעשה על ידי הגדרת ה- Q_object מקרו בהצהרת הכיתה (לעתים קרובות בכותרת).
לאחר מכן, יש להכריז על משבצת בסעיף המתאים, וליישם כשיטה רגילה.
לבסוף, משבצות מחוברות לאותות.
יצירת אותות
לגבי משבצות, ראשית עלינו להוסיף את Q_object מאקרו.
יש להכריז על אותות ב אותות קטע, ואין צורך ביישום.
הם נפלטים באמצעות לִפְלוֹט מילת מפתח:
לִפְלוֹט MySignal();
שים לב שכדי לשלוח איתותים שיש להם פרמטרים, עליכם להעביר אותם לפליטת האות:
לִפְלוֹט MySignal((פרמטר ראשון, SecondParameter ..);
דוגמא
יצירת משבצות בהתאמה אישית
נתחיל עם החלון שלנו עם הכפתור:
#ifndef windows_h #הגדר חלון_ה #לִכלוֹל מעמד Qpushbutton; מעמד חַלוֹן : פּוּמְבֵּי QWidget פּוּמְבֵּי: מְפוֹרָשׁ חַלוֹן((QWidget *הוֹרֶה = 0); פְּרָטִי: Qpushbutton *m_button; >; #endif // חלון_ה
#לִכלוֹל "חַלוֹן.H " #לִכלוֹל חַלוֹן::חַלוֹן((QWidget *הוֹרֶה) : QWidget((הוֹרֶה) // הגדר את גודל החלון setFixedSize((100, 50); // ליצור ולמקם את הכפתור m_button = חָדָשׁ Qpushbutton(("שלום עולם", זֶה); m_button->Setgeometry((10, 10, 80, 30); >
ייתכן שנרצה להסיר את החיבור הקודם שלנו שגורם ליישום להפסיק תוך כדי לחיצה על הכפתור. עכשיו, אנו רוצים את זה, כאשר לוחצים על הכפתור, הטקסט משתנה. ליתר דיוק, אנו רוצים שהכפתור יכול להיות בָּדוּק, וזה, כאשר הוא נבדק, הוא מציג “נבדק”, וכשלא מסומן, הוא משחזר את “שלום עולם”.
Qpushbutton אינו מיישם משבצת כה ספציפית, ולכן עלינו ליישם אותו בעצמנו. כאמור, עלינו להוסיף את Q_object מאקרו.
מעמד חַלוֹן : פּוּמְבֵּי QWidget Q_object פּוּמְבֵּי: מְפוֹרָשׁ חַלוֹן((QWidget *הוֹרֶה = 0); פְּרָטִי: Qpushbutton *m_button; >;
אנו מוסיפים גם את המשבצת המותאמת אישית שלנו. מכיוון שאנו מנסים להגיב מהכפתור שנבדק, ומכיוון שהאות המתאים הוא
בָּטֵל Qpushbutton::לחץ((בול בָּדוּק)
אנו עשויים ליישם משבצת שיש לה חתימה זו:
בָּטֵל חַלוֹן::SlotButtonClicked((בול בָּדוּק);
רוב הזמן, לפי כנס, אנו מיישמים משבצות פרטיות ומוגנות על ידי קידומת אותם באמצעות “חריץ”. כאן, איננו מעוניינים לחשוף משבצת זו כפונקציה ציבורית, אנו יכולים להפוך אותו לפרטי. הכותרת החדשה היא אז
#ifndef windows_h #הגדר חלון_ה #לִכלוֹל מעמד Qpushbutton; מעמד חַלוֹן : פּוּמְבֵּי QWidget Q_object פּוּמְבֵּי: מְפוֹרָשׁ חַלוֹן((QWidget *הוֹרֶה = 0); פְּרָטִי משבצות: בָּטֵל SlotButtonClicked((בול בָּדוּק); פְּרָטִי: Qpushbutton *m_button; >; #endif // חלון_ה
יישום משבצת זו הוא
בָּטֵל חַלוֹן::SlotButtonClicked((בול בָּדוּק) אם ((בָּדוּק) m_button->settext(("בָּדוּק"); > אַחֵר m_button->settext(("שלום עולם"); > >
עלינו להפוך את הכפתור לניתוח, ולקבוע את החיבור, עלינו להוסיף קוד זה בבנאי:
m_button->SetCheckable((נָכוֹן); לְחַבֵּר((m_button, אוֹת ((לחץ((בול)), זֶה, חָרִיץ ((SlotButtonClicked((בול)));
הקוד שהתקבל הוא אז:
#לִכלוֹל "חַלוֹן.H " #לִכלוֹל חַלוֹן::חַלוֹן((QWidget *הוֹרֶה) : QWidget((הוֹרֶה) // הגדר את גודל החלון setFixedSize((100, 50); // ליצור ולמקם את הכפתור m_button = חָדָשׁ Qpushbutton(("שלום עולם", זֶה); m_button->Setgeometry((10, 10, 80, 30); m_button->SetCheckable((נָכוֹן); לְחַבֵּר((m_button, אוֹת ((לחץ((בול)), זֶה, חָרִיץ ((SlotButtonClicked((בול))); > בָּטֵל חַלוֹן::SlotButtonClicked((בול בָּדוּק) אם ((בָּדוּק) m_button->settext(("בָּדוּק"); > אַחֵר m_button->settext(("שלום עולם"); > >
פולט אותות מותאמים אישית
בהתבסס על הדוגמה הקודמת, אנו רוצים לסגור את היישום אם לוחצים על הכפתור (מסומנים או לא מסומנים) 10 פעמים. ראשית עלינו ליישם דלפק שיספור את מספר הקליקים. שינויים אלה מיישמים אותו:
מעמד חַלוֹן : פּוּמְבֵּי QWidget Q_object פּוּמְבֵּי: מְפוֹרָשׁ חַלוֹן((QWidget *הוֹרֶה = 0); פְּרָטִי משבצות: בָּטֵל SlotButtonClicked((בול בָּדוּק); פְּרָטִי: Int m_counter; Qpushbutton *m_button; >;
חַלוֹן::חַלוֹן((QWidget *הוֹרֶה) : QWidget((הוֹרֶה) // הגדר את גודל החלון setFixedSize((100, 50); // ליצור ולמקם את הכפתור m_button = חָדָשׁ Qpushbutton(("שלום עולם", זֶה); m_button->Setgeometry((10, 10, 80, 30); m_button->SetCheckable((נָכוֹן); m_counter = 0; לְחַבֵּר((m_button, אוֹת ((לחץ((בול)), זֶה, חָרִיץ ((SlotButtonClicked((בול))); > בָּטֵל חַלוֹן::SlotButtonClicked((בול בָּדוּק) אם ((בָּדוּק) m_button->settext(("בָּדוּק"); > אַחֵר m_button->settext(("שלום עולם"); > m_counter ++; >
כעת, עלינו ליצור אות מותאם אישית המשמש להודיע לרכיבים אחרים, שהדלפק הגיע ל -10. על מנת להכריז על אות, עלינו להוסיף א
אותותקטע בכותרת. אנו עשויים להכריז גם על אות עם החתימה הבאה:
בָּטֵל חַלוֹן::מנוגד()
לאחר מכן מוכרז על כיתת הכותרת כביכול:
מעמד חַלוֹן : פּוּמְבֵּי QWidget Q_object פּוּמְבֵּי: מְפוֹרָשׁ חַלוֹן((QWidget *הוֹרֶה = 0); אותות: בָּטֵל מנוגד(); פְּרָטִי משבצות: בָּטֵל SlotButtonClicked((בול בָּדוּק); פְּרָטִי: Int m_counter; Qpushbutton *m_button; >;
גם אם האות מוכרז כשיטה, אין צורך ליישם אותו. המהדר המטא-אובייקט משמש כדי לעשות זאת.
עכשיו עלינו לפלוט את האות כאשר הדלפק מגיע ל -10. זה פשוט נעשה בחריץ:
בָּטֵל חַלוֹן::SlotButtonClicked((בול בָּדוּק) אם ((בָּדוּק) m_button->settext(("בָּדוּק"); > אַחֵר m_button->settext(("שלום עולם"); > m_counter ++; אם ((m_counter == 10) לִפְלוֹט מנוגד(); > >
עלינו לכתוב את מילת המפתח לִפְלוֹט כדי לשלוח את האות.
חיבור האות החדש שנוצר לחריץ הפסק נעשה כרגיל:
לְחַבֵּר((זֶה, אוֹת ((מנוגד()), Qapplication::למשל(), חָרִיץ ((לְהַפְסִיק()));
הקוד הסופי הוא:
#ifndef windows_h #הגדר חלון_ה #לִכלוֹל מעמד Qpushbutton; מעמד חַלוֹן : פּוּמְבֵּי QWidget Q_object פּוּמְבֵּי: מְפוֹרָשׁ חַלוֹן((QWidget *הוֹרֶה = 0); אותות: בָּטֵל מנוגד(); פְּרָטִי משבצות: בָּטֵל SlotButtonClicked((בול בָּדוּק); פְּרָטִי: Int m_counter; Qpushbutton *m_button; >; #endif // חלון_ה
#לִכלוֹל "חַלוֹן.H " #לִכלוֹל #לִכלוֹל חַלוֹן::חַלוֹן((QWidget *הוֹרֶה) : QWidget((הוֹרֶה) // הגדר את גודל החלון setFixedSize((100, 50); // ליצור ולמקם את הכפתור m_button = חָדָשׁ Qpushbutton(("שלום עולם", זֶה); m_button->Setgeometry((10, 10, 80, 30); m_button->SetCheckable((נָכוֹן); m_counter = 0; לְחַבֵּר((m_button, אוֹת ((לחץ((בול)), זֶה, חָרִיץ ((SlotButtonClicked((בול))); לְחַבֵּר((זֶה, אוֹת ((מנוגד()), Qapplication::למשל(), חָרִיץ ((לְהַפְסִיק())); > בָּטֵל חַלוֹן::SlotButtonClicked((בול בָּדוּק) אם ((בָּדוּק) m_button->settext(("בָּדוּק"); > אַחֵר m_button->settext(("שלום עולם"); > m_counter ++; אם ((m_counter == 10) לִפְלוֹט מנוגד(); > >
ותוכלו לנסות ולבדוק את זה לאחר לחיצה על הכפתור עשר פעמים, היישום יפסיק.
פתרון תקלות
בזמן ההרכבה של התוכנית שלך, במיוחד כשאתה מוסיף את ה- Macro Q_Object, יתכן שיש לך שגיאת אוסף זו.
רָאשִׁי.CPP:(.טֶקסט._Zn6windowd2ev[_Zn6windowd5ev]+0x3): לא מוגדר התייחסות ל `vtable ל חַלוֹן'
הסיבה. אתה צריך RERUN QMAKE, על ידי ביצוע בנייה> הפעל qmake.
ווידג’טים
לחצן רדיו הוא רכיב GUI רגיל. לעתים קרובות הוא משמש לבחירה ייחודית מרשימה. ב- QT, ה- Qradiobutton משמש ליצירת כפתורי רדיו.
בזכות מורשת נחמדה, Qradiobutton מתנהג ממש כמו Qpushbutton. כל המאפיינים של ה- Qpushbutton זהים גם הם ב- Qradiobutton, וניתן לעשות שימוש חוזר בכל מה שנלמד בפרק השני.
כברירת מחדל, qradiobuttons אינם מקובצים, ולכן ניתן לבדוק רבים מהם במקביל. על מנת שתהיה התנהגות “בלעדית” של כפתורי רדיו רבים, עלינו להשתמש ב- QButTongroup . ניתן להשתמש בכיתה זו כך: אנו מקצים קבוצת כפתורים חדשה ומחברים אותה לאובייקט ההורה. שים לב שאובייקט ההורה עשוי להיות ה- MainWindow, או “זה”:
Qbuttongroup *קבוצת התחת = חָדָשׁ Qbuttongroup((לְהִתְנַגֵד); // הוסף לחצנים בקבוצת הכפתורים קבוצת התחת->Addbutton((כפתור 1); קבוצת התחת->Addbutton((כפתור 2); קבוצת התחת->Addbutton((כפתור 3); .
מה שאנחנו רוצים זה ליצור בוחר תפריט. בחלון יש להציג רשימת צלחות טעימות עם כפתורי רדיו, ויש להציג כפתור לחיצה המשמש לבחירת הצלחת שנבחרה.
ברור ששום דבר לא יקרה (עכשיו) כאשר לוחצים על הכפתורים.
אותות וחריצים
הנה דוגמא לגבי אותות וחריצים. אנחנו הולכים לכתוב יישום עם שני כפתורים. על הכפתור הראשון להציג מידע על Qt.
אנו מספקים לך את הקוד הבא להשלמת:
#לִכלוֹל #לִכלוֹל Int רָאשִׁי((Int Argc, לְהַשְׁחִיר ***argv) Qapplication אפליקציה ((Argc, argv); QWidget חַלוֹן; חַלוֹן.setFixedSize((100, 80); Qpushbutton *ButtonInfo = חָדָשׁ Qpushbutton(("מידע", & &חַלוֹן); ButtonInfo->Setgeometry((10, 10, 80, 30); Qpushbutton *כפתור = חָדָשׁ Qpushbutton(("לְהַפְסִיק", & &חַלוֹן); כפתור->Setgeometry((10, 40, 80, 30); חַלוֹן.הופעה(); // הוסף את הקוד שלך כאן לַחֲזוֹר אפליקציה.EXEC(); >
על מנת להציג את המידע על QT, עליך להשתמש בשיטה הבאה
בָּטֵל Qapplication::אודות QT();
אתה יכול גם להוסיף סמלים על הכפתורים, או לשנות את גודלם. ברור שכפתור “הפסק” צריך להיות חשוב יותר, אז למה לא להגדיל אותו?
אבל אנחנו באמת ממליצים לך לנסות להבין את זה בעצמך כיצד לפתור את התרגילים האלה.
Qt למתחילים – מציאת מידע בתיעוד
תיעוד QT הוא פיסת מידע בעלת ערך רב. זה המקום למצוא הכל קשור ל- Qt. אבל, תיעוד QT אינו הדרכה כיצד להשתמש ב- QT. זהו אוסף של כל המידע הקשור לשיעורים, כמו גם כמה דוגמאות. מטרת פרק זה היא להכיר לך את התיעוד כבסיס לתכנות עם QT.
היכן למצוא את התיעוד
מקור התיעוד הטוב ביותר הוא באינטרנט, ברשת מפתחים זו:
הוא מספק את המסמך המלא, כמו גם כמה מסמכים, שמשתמשים יכולים להוסיף. מסמכים אלה נותנים דוגמאות נוספות ומדגישות כמה נקודות מסובכות. לתיעוד המקוון יש גם מנוע חיפוש חזק למדי והוא מכיל גם את כל התיעוד לכל הגרסאות של QT.
בעוד שהגרסה המקוונת דורשת חיבור לאינטרנט, המסמכים עדיין זמינים. אם ה- QTSDK הותקן כראוי, התיעוד התואם את הגרסה הנוכחית של QT היה צריך להתקין, ואת עֶזרָה קטע Qtcreator לא אמור להיות ריק. אתה יכול גם להשתמש עוזר Qt, זהו דפדפן DOC עצמאי.
קטעים חשובים בתיעוד
אם אתה מפעיל את מציג התיעוד הלא מקוון, אצל יוצר QT או עוזר QT, תמצא בסיכום שיש תיעוד לרכיבים שונים של ה- QT SDK.
- QT עוזר תיעוד
- תיעוד מעצבי QT
- תיעוד בלשני QT
- תיעוד QMake
- תיעוד התייחסות QT
המרכיב החשוב ביותר הוא כמובן תיעוד ההתייחסות ל- QT.
תיעוד QT מספק הצגה נחמדה של רכיבים רבים, וגם את התיעוד לכל השיעורים ב- QT. רשימה זו מופיעה בדף כל השיעורים. דף מעניין נוסף הוא הדף שמפרט את כל המודולים. דף זה מספק מידע על הרכיבים השונים ב- QT.
במדריך זה נשתמש בעיקר במודולים אלה
פונקציית החיפוש חשובה למדי. אם אתה מכיר את הכיתה לשימוש, ורוצה למצוא את התיעוד, אתה יכול להקליד את שם הכיתה בשדה החיפוש (מקוון), או במסנן באינדקס (לא מקוון). אתה יכול גם לחפש שיטות וסופיות בשדות אלה.
עיין בתיעוד של כיתה
תיעוד שיעורים מאורגן תמיד באותה דרך:
- שם ותיאור קצר של הכיתה
- יְרוּשָׁה
- ספירות
- נכסים
- שיטות ציבוריות
- משבצות ציבוריות
- אותות
- שיטות מוגנות
בואו ניקח את כיתת Qtextedit כדוגמה.
האם ל- Qt יש ממשק C?
מצאתי תשובות סותרות באינטרנט – יש אומרים שזה כן, יש אומרים שזה לא. גם לא הצלחתי למצוא פרטים בתיעוד QT הרשמי. גם ל- Qt יש כריכות C או לא?
שאל 13 בנובמבר 2009 בשעה 10:53
6,041 11 11 תגי זהב 48 48 תגי כסף 50 50 תגי ברונזה
7 תשובות 7
תשובה קצרה: לא.
אם אתה זקוק לערכת כלים של GUI מקיפה עבור C, אתה יכול להשתמש ב- GTK+.
כדי להשתמש ב- Qt, אתה צריך יש מהדר C ++. אבל זה לא אומר שלא ניתן לכתוב את “היגיון היישומים” שלך ב- C, להרכיב עם מהדר C ולקשור בזהירות לחלק C ++ (ה- GUI עם QT). היגיון יישום זה יכול להיות גנרי, ניתן לקישור להפעלה אחרת (Pure-C, C/C ++ מעורב וכו ‘.) הכל תלוי במה שאתה צריך.
Qt נהדר עבור C ++, וזו סיבה טובה להחליט להשתמש ב- C ++ לפרויקט מסוים, גם אם אתה עדיין רוצה לשמור על חלקים ב- C.
