การติดตั้งและกำหนดค่า Qt Creator ทำไมฉันถึงรัก Qt และพวกคุณทุกคนควรจะชอบมันเช่นกัน การเขียนโปรแกรม Qt สำหรับผู้เริ่มต้น

ตัวอย่างง่ายๆ ของการประกอบด้วยมือ

เพื่อความเข้าใจที่ดีขึ้นเกี่ยวกับ Qt จะต้องสร้างตัวอย่างง่ายๆ ด้วยตนเองในคอนโซลเป็นอย่างน้อย เทคนิคการประกอบจะเหมือนกันสำหรับโครงการทุกขนาด และสิ่งสำคัญคือต้องทำความเข้าใจวิธีการประกอบ

ลองดูตัวอย่างง่ายๆ ของแอปพลิเคชัน GUI ที่เปิดหน้าต่างว่างบนหน้าจอ เลือกไดเร็กทอรีบนดิสก์ที่เราจะสร้างไฟล์ main.cppโดยมีเนื้อหาดังต่อไปนี้ เพิ่มการกำหนดหมายเลขบรรทัดให้กับตัวอย่างเพื่อทำให้ความคิดเห็นเพิ่มเติมเกี่ยวกับตัวอย่างง่ายขึ้น ควรเข้าใจว่าไม่ควรรวมการกำหนดหมายเลขบรรทัดในไฟล์การทำงาน เนื่องจากไม่ได้เป็นส่วนหนึ่งของไวยากรณ์นิพจน์ C++ ที่ถูกต้อง

01. #รวม 02. #รวม 03. 04. int main(int argc, char *argv) 05. ( 06. แอป QApplication(argc, argv); 07. QWidget wgt; 08. wgt.setWindowTitle(tr("Hello world")); 09. 10 11. กลับ app.exec();

บรรทัด 01 และ 02 รวมไฟล์ส่วนหัว QApplicationและ QWidgetซึ่งมีการประกาศคลาสเหนือสิ่งอื่นใด QApplicationและ QWidget- ในตัวอย่างของเรา เราสร้างอินสแตนซ์ของคลาสเหล่านี้

เป็นที่น่าสังเกตว่าประเพณีการตั้งชื่อไฟล์ส่วนหัวที่ใช้ใน Qt นั้นสะดวก ตั้งแต่เวอร์ชัน 4 ของ Qt หากคุณต้องการคลาสที่ชื่อ Qxxxมีแนวโน้มว่าคำจำกัดความจะอยู่ในไฟล์ส่วนหัว Qxxx.

ในตัวอย่างนี้ ชั้นเรียน QApplicationเราสนใจในฐานะผู้จัดงานวงจรการรวบรวมข้อความที่จะมาถึงหน้าต่างแอปพลิเคชัน GUI ของเรา ดูบรรทัดที่ 11 (การเริ่มวนรอบข้อความหน้าต่าง) ระดับ QApplicationนำมาใช้ในลักษณะของซิงเกิลตัน สำหรับผู้ที่ไม่คุ้นเคยกับคำนี้จากทฤษฎีการออกแบบรูปแบบ (หรือรูปแบบจากภาษาอังกฤษ) รูปแบบ) มาอธิบายกันหน่อย สาระสำคัญของซิงเกิลตันก็คือการนำคลาสไปใช้จะป้องกันความเป็นไปได้ในการสร้างอินสแตนซ์ของคลาสที่กำหนดมากกว่าหนึ่งอินสแตนซ์ คุณลักษณะนี้มีความสำคัญสำหรับเราเนื่องจากแสดงถึงความเป็นไปได้ในการกำหนดตัวแปรส่วนกลางภายในไลบรารี Qt ด้วยตัวชี้ไปยังอินสแตนซ์เดียวของคลาสที่กำหนด ดูคำอธิบายสัญลักษณ์ คิวแอปในวิธีใช้ Qt

ไลบรารี Qt ใช้คำศัพท์เฉพาะของวิดเจ็ต วิดเจ็ต- อุปกรณ์) เป็นองค์ประกอบของอินเทอร์เฟซ GUI ชุดคุณสมบัติทั่วไปขั้นต่ำขององค์ประกอบดังกล่าวจะแสดงโดยคลาส QWidget.

บรรทัด 06 และ 07 สร้างวัตถุคลาสแอปพลิเคชันและวิดเจ็ต ในทั้งสองกรณี ออบเจ็กต์จะถูกสร้างขึ้นแบบคงที่ อายุการใช้งานของออบเจ็กต์ดังกล่าวถูกจำกัดโดยบล็อกคำสั่ง (...) ที่สร้างขึ้น ทันทีที่การเรียกใช้โค้ดโปรแกรมถึงวงเล็บปิด วัตถุทั้งสองนี้จะถูกทำลายโดยอัตโนมัติ ดังนั้นในตัวอย่างนี้ เราจะไม่คิดถึงวิธีทำลายวัตถุ Qt และจะพิจารณาปัญหานี้ในภายหลัง

เมื่อสร้างวัตถุ QApplicationตัวสร้างพารามิเตอร์ถูกใช้ซึ่งอาร์กิวเมนต์การเรียกใช้แอปพลิเคชันจะถูกส่งผ่าน (คัดลอกจากอาร์กิวเมนต์ของฟังก์ชัน main()) ภายในคลาสอ็อบเจ็กต์ อาร์กิวเมนต์เหล่านี้จะถูกแยกวิเคราะห์ คลาสแอปพลิเคชันรองรับพารามิเตอร์การเรียกทำงานจำนวนหนึ่ง ซึ่งสามารถพบได้ในวิธีใช้สำหรับตัวสร้างที่เกี่ยวข้อง QApplication- พารามิเตอร์การเปิดตัวที่ไม่รวมอยู่ในรายการนี้ควรได้รับการวิเคราะห์อย่างอิสระ ในตอนท้ายของบทเรียนนี้ หลังจากวางการควบคุมหลายอย่างไว้ในหน้าต่างแอปพลิเคชันหลักแล้ว เราจะแนะนำให้ทดลองกับพารามิเตอร์การเปิดตัว -style ซึ่งใน Qt build ใด ๆ ค่าต่อไปนี้เป็นไปได้: แม่ลาย, หน้าต่าง, แพลทินัม.

บรรทัด 08 เปลี่ยนหนึ่งในคุณลักษณะของวัตถุวิดเจ็ต เมื่อใช้เมธอด setWindowTitle() เราตั้งค่าข้อความของเราเองสำหรับชื่อเรื่องของหน้าต่างในอนาคตของเรา โปรดทราบว่าภาพสตริงนั้นรวมอยู่ในการเรียกฟังก์ชันแปล ตร()- นี่เป็นข้อกำหนดในการทำให้แอปพลิเคชันเป็นสากล สำหรับ wrapper ทั้งหมดดังกล่าว สามารถใช้เครื่องมือ Qt พิเศษเพื่อสร้างไฟล์พิเศษพร้อมการแปลเป็นภาษาต่างๆ ซึ่งสามารถใช้ในแอปพลิเคชันเพื่อทำการแทนที่อัตโนมัติ โดยทั่วไปแล้ว ไฟล์ดังกล่าวจะรวมอยู่ในบิลด์แอปพลิเคชันเป็นทรัพยากร

บรรทัดที่ 10 จะเปิดหน้าต่างแอปพลิเคชัน ก่อน Qt4 ก่อนที่จะเปิดหน้าต่าง วิดเจ็ตได้รับการประกาศอย่างชัดเจนว่าเป็นวิดเจ็ตหลักของแอปพลิเคชัน ทำได้โดยใช้รหัสต่อไปนี้

App.setMainWidget(&wgt);

เริ่มต้นจาก Qt4 การสื่อสารดังกล่าวจะดำเนินการโดยอัตโนมัติโดยการเข้าถึงตัวชี้ส่วนกลาง คิวแอปไปยังอินสแตนซ์ของคลาสแอปพลิเคชัน

บรรทัดที่ 11 เริ่มต้นลูปการประมวลผลข้อความของระบบปฏิบัติการที่ส่งตรงไปยังหน้าต่างแอปพลิเคชัน การวนซ้ำจะสิ้นสุดลงเมื่อมีการดำเนินการคำสั่งปิดแอปพลิเคชันใดๆ รหัสออกจากแอปพลิเคชันจะถูกส่งกลับโดย exec() เมื่อออกจากเมธอด โค้ดนี้เองที่จะกลายเป็นโค้ดส่งคืนของฟังก์ชัน main() โดยส่งผ่านตัวดำเนินการ กลับ.

ตอนนี้เรามาลองสร้างแอปพลิเคชันกัน วิธีที่ง่ายที่สุดในการทำเช่นนี้คือบน Linux ในการดำเนินการนี้ คุณเพียงแค่ต้องเปิดคอนโซลและเรียกใช้คำสั่งบางคำสั่ง ซึ่งเราจะอธิบายในตอนนี้ สำหรับ Windows งานดังกล่าวอาจต้องมีการตั้งค่าเส้นทางไปยังไดเร็กทอรีที่มียูทิลิตี้ qmake จาก Qt SDK อยู่ ยูทิลิตี้นี้ใช้กฎของระบบการสร้างโปรเจ็กต์ QMake

ก่อนอื่นเราต้องค้นหาว่ามีอะไรให้เราบ้างจากคอนโซล ถ้าเราอยู่ในคอนโซล bash (*nix) นี่ก็ค่อนข้างง่าย พิมพ์คำสั่ง คิวเมคและกด Tab สองครั้ง เราควรเห็นรายการคำสั่งทั้งหมดที่ขึ้นต้นด้วยชุดค่าผสม คิวเมค- ตัวอย่างเช่น ในกรณีของฉัน ฉันเห็นคำสั่งสองคำสั่ง: คิวเมคและ qmake-qt4- ซึ่งหมายความว่าฉันมีไลบรารี่สองเวอร์ชันที่ติดตั้งจากพื้นที่เก็บข้อมูล ทีม คิวเมคสอดคล้องกับเวอร์ชัน Qt5 (ค่าเริ่มต้นคือเวอร์ชันล่าสุด) และคำสั่ง qmake-qt4สอดคล้องกับ Qt4 ตอนนี้ ขึ้นอยู่กับคำสั่งที่ฉันใช้ ฉันจะสร้างโดยใช้เวอร์ชัน Qt5 หรือใช้เวอร์ชัน Qt4

หากทุกอย่างในระบบของเราได้รับการกำหนดค่าตามปกติและเวอร์ชัน Qt SDK สำเร็จ โปรเจ็กต์ควรถูกสร้างขึ้นโดยใช้คำสั่งสามคำสั่งต่อไปนี้

$ qmake -project $ qmake $ สร้าง

คำสั่งแรกจะสร้างไฟล์โครงการ ไฟล์โครงการมีส่วนต่อท้าย .โปร- ในบริบทของ Windows การพูดว่า "extension โปร“.แนวคิด ส่วนต่อท้ายชื่อไฟล์และ นามสกุลไฟล์หมายถึงสิ่งที่แตกต่างกันอย่างสิ้นเชิงถึงแม้จะดูคล้ายกันก็ตาม ตรวจสอบให้แน่ใจว่าใช้อย่างถูกต้อง

คำสั่งที่สองควรสร้างไฟล์สคริปต์การคอมไพล์ - Makefile คำสั่งที่สามควรเรียกใช้สคริปต์การคอมไพล์ที่ควรสร้างไฟล์แอปพลิเคชันที่ปฏิบัติการได้

หากไม่เกิดขึ้นเราจะพยายามค้นหาปัญหา

เปิดไฟล์โครงการ ลองค้นหาบรรทัดต่อไปนี้ที่นั่น

QT += กุย

หากไม่มีบรรทัดดังกล่าว คุณควรเพิ่มมัน มิฉะนั้น ขึ้นอยู่กับเวอร์ชันของ SDK โปรเจ็กต์อาจถูกมองว่าเป็นโปรเจ็กต์คอนโซล และเส้นทางไปยังไฟล์ส่วนหัวของคลาส GUI จะไม่รวมอยู่ในนั้น ซึ่งจะส่งผลให้เกิดข้อผิดพลาดในการคอมไพล์โดยระบุว่าไม่พบไฟล์ส่วนหัวที่รวมไว้

โปรดทราบว่าหากคุณกำลังจัดการกับ Qt SDK เวอร์ชัน 5 คำจำกัดความนี้ก็ต้องรวมกลุ่มด้วย วิดเจ็ตตามที่แสดงด้านล่าง

QT += วิดเจ็ต gui

ตัวอย่างการสร้างเทมเพลตแอปพลิเคชัน GUI จาก QtCreator

เปิด QtCreator หากต้องการสร้างโปรเจ็กต์ใหม่ ให้เปิดตัวช่วยสร้างโปรเจ็กต์จากเมนู "ไฟล์->ไฟล์ใหม่หรือโปรเจ็กต์..." ในหน้าต่างที่เปิดขึ้นในหน้าแรกของวิซาร์ด คุณจะได้รับพร้อมท์ให้เลือกเทมเพลตสำหรับโครงการในอนาคต สำหรับกลุ่มโครงการ "แอปพลิเคชัน" ให้เลือกตัวเลือก "แอปพลิเคชัน Qt GUI" และคลิกที่ปุ่ม "เลือก" เพื่อไปยังหน้าถัดไปของตัวช่วยสร้าง

บนหน้าที่สองของวิซาร์ดการสร้างโปรเจ็กต์ คุณจะถูกขอให้เลือกชื่อโปรเจ็กต์และไดเร็กทอรีตำแหน่งของโปรเจ็กต์ การใช้ชื่อโปรเจ็กต์ที่ระบุ ไดเร็กทอรีย่อยจะถูกสร้างขึ้นซึ่งมีไฟล์โปรเจ็กต์อยู่ ไดเรกทอรีย่อยจะถูกสร้างขึ้นในไดเรกทอรีตำแหน่งที่ระบุ ดังนั้นชื่อโปรเจ็กต์จะต้องถูกกำหนดตามกฎที่ชื่อไดเร็กทอรีต้องปฏิบัติตาม อย่างไรก็ตาม เพื่อหลีกเลี่ยงปัญหา อย่าใช้ตัวอักษรรัสเซียและการเว้นวรรค ใช้ตัวอักษรภาษาอังกฤษ ตัวเลข ขีดล่างและขีดกลาง (เครื่องหมายลบ) ให้โครงการของเราถูกเรียกว่า แอพ1- มาเขียนมันในบรรทัดกัน ชื่อและในบรรทัดสำหรับเลือกไดเร็กทอรีโปรเจ็กต์ เราจะระบุไดเร็กทอรีที่เราจะสร้างโปรเจ็กต์บน Qt ต่อไป ควรหลีกเลี่ยงเส้นทางที่มีตัวอักษรรัสเซียและช่องว่าง ไม่ช้าก็เร็วอาจทำให้เกิดปัญหาได้ หากคุณต้องการจำเส้นทางนี้ไว้ใช้ครั้งต่อไป ให้ทำเครื่องหมายในช่อง "ใช้เป็นที่ตั้งโครงการเริ่มต้น" คลิกที่ปุ่ม "ถัดไป" เพื่อไปยังหน้าถัดไปของวิซาร์ด

ในหน้าที่สามของวิซาร์ดการสร้างโปรเจ็กต์ ระบบจะขอให้คุณเลือก Qt SDK จากรายการที่พบและลงทะเบียนใน QtCreator เลือกตัวเลือก Qt4 สำหรับเวอร์ชัน SDK ที่เลือก คุณต้องกำหนดโปรไฟล์การสร้างโครงการ มีการเสนอตัวเลือก "Release" และ "Debug" โครงสร้าง "Release" ไม่มีสัญลักษณ์การดีบักในไฟล์ปฏิบัติการ และแนะนำสำหรับการถ่ายโอนไปสู่การใช้งานจริง ในกรณีอื่นทั้งหมด การใช้บิลด์ "ดีบัก" จะสะดวกกว่า ในตัวอย่างปัจจุบัน การเลือกชุดประกอบไม่สำคัญ คุณสามารถปล่อยให้ทั้งสองโปรไฟล์เปิดใช้งานได้ ทางด้านขวาของชื่อโปรไฟล์จะมีช่องป้อนข้อมูลซึ่งจะเขียนเส้นทางที่จะใช้ประกอบแอสเซมบลีที่เกี่ยวข้อง บ่อยครั้งที่เส้นทางเหล่านี้ได้รับการแก้ไขตามประเพณีที่แตกต่างกัน ในตัวอย่างของเรา เราสามารถปล่อยให้เส้นทางเหล่านี้ไม่เปลี่ยนแปลงได้ คลิกที่ปุ่ม "ถัดไป" เพื่อไปยังหน้าถัดไปของวิซาร์ด

บนหน้าที่สี่ของวิซาร์ดการสร้างโปรเจ็กต์ ระบบจะขอให้คุณเลือกชื่อคลาสสำหรับรูปแบบหลักของโปรเจ็กต์ คลาสพื้นฐานที่ควรสืบทอดรูปแบบหลักของโปรเจ็กต์ และชื่อของไฟล์ที่อินเทอร์เฟซ และการดำเนินการของคลาสที่สร้างขึ้นของแบบฟอร์มหลักจะตั้งอยู่ นอกจากนี้ หน้าควรระบุว่าจะใช้การออกแบบรูปแบบภาพหรือไม่ เนื่องจากเราจะไม่ใช้การออกแบบภาพ เราจึงควรตรวจสอบให้แน่ใจว่าไม่ได้ทำเครื่องหมายในช่อง "สร้างแบบฟอร์ม"

สิ่งที่น่าสนใจที่สุดในหน้าที่สี่ของ New Project Wizard คือการเลือกคลาสพื้นฐานเพื่อสร้างคลาสฟอร์ม มีสามตัวเลือกให้เลือก

1. QMainWindow- ในกรณีส่วนใหญ่ ทางเลือกที่เหมาะสมที่สุด. เมื่อสืบทอดจากคลาสนี้ เราจะได้เครื่องมือสำเร็จรูปสำหรับการวางเมนู แถบสถานะ และฟิลด์ส่วนกลาง ซึ่งสามารถใช้งานได้ทั้งในรูปแบบ SDI (Single Document Interface) และในรูปแบบ MDI (Multi Document Interface)
2. QWidget— คลาสนี้เป็นวิดเจ็ตที่ง่ายที่สุด ในคำศัพท์ของ Qt นี่เป็นองค์ประกอบที่ง่ายที่สุดที่เกี่ยวข้องกับพื้นที่กราฟิกบางประเภทบนหน้าจอ ตามกฎแล้วจะใช้คลาสพื้นฐานสำหรับหน้าต่างหลักในการสร้างแอปพลิเคชันรูปแบบเดียวที่เรียบง่ายและเหมาะสำหรับวัตถุประสงค์เริ่มต้นของ "นักเรียน" เนื่องจากไม่มีสิ่งที่ "ฟุ่มเฟือย"
3. QDialog— คลาสพื้นฐานสำหรับการสร้างกล่องโต้ตอบโมดอล

สำหรับตัวอย่างของเรา เราจะเลือกเป็นคลาสพื้นฐาน ตัวเลือกที่ง่ายที่สุดคือ QWidget- ชื่อของคลาสหลักของฟอร์มและไฟล์ที่จะระบุตำแหน่งอินเทอร์เฟซและการใช้งานสามารถปล่อยให้เป็นค่าเริ่มต้นได้ คลิกที่ปุ่ม "ถัดไป" เพื่อไปยังหน้าถัดไปของวิซาร์ด

หน้าที่ห้าของวิซาร์ดการสร้างโปรเจ็กต์ช่วยให้คุณสามารถกำหนดความสัมพันธ์ของโปรเจ็กต์ที่ถูกสร้างขึ้นกับโปรเจ็กต์ที่เปิดอยู่แล้ว และระบุตัวเลือกของระบบควบคุมเวอร์ชันโปรเจ็กต์ที่มีอยู่ ในตัวอย่างปัจจุบัน เราไม่สนใจคุณลักษณะเหล่านี้ ดังนั้นเราควรดำเนินการตัวช่วยสร้างให้เสร็จสิ้นโดยคลิกปุ่ม "เสร็จสิ้น"

ขั้นตอนในการสร้างโปรเจ็กต์อาจแตกต่างกันเล็กน้อยใน QtCreator เวอร์ชันต่างๆ แต่โดยพื้นฐานแล้ว นี่คือประเด็นหลักที่คุณควรเข้าใจเมื่อสร้างโปรเจ็กต์ GUI คำอธิบายปัจจุบันสร้างขึ้นจาก QtCreator เวอร์ชัน 2.7.0

หลังจากเสร็จสิ้น New Project Wizard ใน QtCreator แล้ว มุมมองที่มีโปรเจ็กต์ที่สร้างขึ้นจะเปิดขึ้น รันโปรเจ็กต์เพื่อตรวจสอบการตั้งค่าสภาพแวดล้อมการพัฒนาของคุณ หากทุกอย่างเป็นไปตามลำดับ เทมเพลตโปรเจ็กต์ที่สร้างขึ้นควรคอมไพล์และรัน หากต้องการเปิดโครงการตามปกติ คุณสามารถคลิกที่ปุ่มที่มีสามเหลี่ยมสีเขียวอยู่บนแถบเครื่องมือ ปุ่มที่มีรูปสามเหลี่ยมสีเขียวพร้อมด้วงทำหน้าที่ในการเปิดโหมดแก้ไขจุดบกพร่อง ในกรณีนี้ หากมีการตั้งค่าเบรกพอยต์ในโปรเจ็กต์ เมื่อถึงจุดนั้นแล้ว การดำเนินการของแอปพลิเคชันที่ทำงานอยู่จะหยุดลงและบรรทัดที่ทำการเบรกจะถูกเน้นในตัวแก้ไขการดีบัก

QtCreator แตกต่างอย่างเห็นได้ชัดในการออกแบบจากสภาพแวดล้อมการพัฒนาอื่นๆ อย่างไรก็ตาม การออกแบบเป็นไปตามหลักสรีรศาสตร์อย่างน่าประหลาดใจ เหนือสิ่งอื่นใด ในยุคของหน้าจอกว้าง แถบเครื่องมือที่อยู่ด้านซ้ายในหน้าต่างหลักของสภาพแวดล้อมการพัฒนาดูได้เปรียบมาก ที่ด้านล่างของแถบเครื่องมือดังที่ได้กล่าวไปแล้วจะมีปุ่มสำหรับเปิดแอปพลิเคชันและที่ด้านบนจะมีปุ่มสำหรับเลือกแท็บสำหรับหน้าต่างหลักของสภาพแวดล้อมการพัฒนา มาดูรายการแท็บหลักกัน

• "ยินดีต้อนรับ" — การคัดเลือกโครงการ
• "แก้ไข" — การแก้ไขโปรแกรม
• "Debug" - การดีบักโปรเจ็กต์ รวมหน้าต่างที่จำเป็นสำหรับการตรวจสอบวัตถุ
• "โปรเจ็กต์" — การตั้งค่าสำหรับโปรเจ็กต์ที่โหลดเข้าสู่สภาพแวดล้อมการพัฒนา คุณควรศึกษาตัวเลือกที่นำเสนอในแท็บนี้อย่างรอบคอบ
• "วิเคราะห์" - การวิเคราะห์โครงการโดยใช้เครื่องมือพิเศษสำหรับตรวจจับปัญหาคอขวดของประสิทธิภาพและปัญหาหน่วยความจำรั่ว
• "ความช่วยเหลือ" หน้าต่างช่วยเหลือแบบรวม คุณอาจต้องการทำงานกับแอปพลิเคชันช่วยเหลือแบบสแตนด์อโลน QtAssistant

ตัวอย่างง่ายๆ ของการวางวิดเจ็ตในหน้าต่างแอปพลิเคชัน

มาดูโปรเจ็กต์ที่เราสร้างขึ้นในส่วนที่แล้วโดยใช้ตัวช่วยสร้างสภาพแวดล้อมการพัฒนา QtCreator กัน โครงการที่สร้างขึ้นประกอบด้วยไฟล์ต่อไปนี้

• app1.pro- ไฟล์โครงการ
• main.cpp widget.h และ วิดเจ็ต.cpp./li>
• วิดเจ็ต.h— อินเทอร์เฟซคลาสของหน้าต่างแอปพลิเคชันหลัก
• วิดเจ็ต.cpp— การใช้งานคลาสหน้าต่างแอปพลิเคชันหลัก

ชื่อไฟล์ในโครงการของคุณอาจแตกต่างกันเล็กน้อย อาจเป็นเพราะคุณได้ระบุไว้อย่างชัดเจนที่อื่นเมื่อสร้างโปรเจ็กต์ หรือค่าเริ่มต้นสำหรับ QtCreator เวอร์ชันของคุณแตกต่างออกไป

มาเปิดไฟล์การใช้งานของหน้าต่างแอปพลิเคชันหลักกันดีกว่า - วิดเจ็ต.cpp- ลองเปลี่ยนเป็นสถานะที่แสดงในตัวอย่างต่อไปนี้ โปรดจำไว้ว่าหมายเลขบรรทัดมีไว้เพื่อความสะดวกในการแสดงความคิดเห็นเท่านั้น

01. #รวม 02. #รวม 03. #รวม 04. 05. #include "widget.h" 06. 07. Widget::Widget(QWidget *parent) 08. : QWidget(parent) 09. ( 10. setWindowTitle(tr("Hello world!!!")); 11. setMinimumSize(200, 80); 12. QLabel * plb = new QLabel(tr("Test"), this); QLineEdit * ple = new QLineEdit(นี่); , 80, 24); 18. 19. QPushButton * ppb = new QPushButton(tr("Ok"), this); ->setGeometry(20, 50, 80, 24. ) 22. 23. วิดเจ็ต:: ~วิดเจ็ต() 24. ( 25. 26. )

บรรทัด 01-03 รวมไฟล์ที่มีอินเตอร์เฟสสำหรับคลาสวิดเจ็ตต่อไปนี้

1. คิวเลเบล— คลาสป้ายกำกับ มักใช้เพื่อวางข้อมูลข้อความคงที่ เข้าใจแท็ก HTML บางส่วนสำหรับการจัดรูปแบบ สามารถใช้เพื่อวางรูปภาพแบบคงที่ เช่นจากไฟล์ที่มีรูปภาพ สืบทอดมาจาก คิวเฟรมจึงสามารถปรับให้เข้ากับรูปทรงขอบต่างๆ (เส้นขอบ) ได้
2. คิวไลน์แก้ไข— คลาสสำหรับสร้างช่องป้อนข้อมูลข้อความบรรทัดเดียว
3. QPushButton— คลาสปุ่ม ส่วนใหญ่มักใช้ในการประมวลผลสัญญาณ คลิก()- คลิกที่ปุ่ม

ตัวสร้างคลาส วิดเจ็ตมีสองบรรทัดสำหรับการตั้งค่าคุณลักษณะของหน้าต่าง (บรรทัดที่ 10-11) และ 8 บรรทัดสำหรับการสร้างและวางวิดเจ็ตอื่น ๆ สามรายการบนฟิลด์หน้าต่าง (บรรทัดที่ 13-20)

การตั้งค่าคุณลักษณะหน้าต่างประกอบด้วยคำสั่งเพื่อตั้งชื่อหน้าต่างแอปพลิเคชันและขนาดต่ำสุดของหน้าต่างแอปพลิเคชัน ในการกำหนดขนาดขั้นต่ำ จะใช้วิธีการที่ใช้ความกว้างและความสูงของหน้าต่างเป็นพิกเซล

บรรทัดที่ 13 มีการสร้างอินสแตนซ์ของคลาส QLabel วัตถุถูกสร้างขึ้นแบบไดนามิกโดยใช้ตัวดำเนินการใหม่ ในการสร้างวัตถุ จะใช้ตัวสร้าง พารามิเตอร์ตัวแรกระบุสตริงที่วัตถุที่สร้างขึ้นควรเป็นตัวแทน พารามิเตอร์ตัวที่สองของตัวสร้างนี้ควรระบุที่อยู่ของวัตถุที่จะกลายเป็นเจ้าของวัตถุป้ายกำกับที่สร้างขึ้น ที่อยู่ของเจ้าของถูกตั้งค่าเป็น นี้- ตามกฎของภาษา C++ นี้เป็นตัวชี้ไปยังวัตถุภายในที่มันถูกใช้ นั่นคือ ในบริบทนี้ มันเป็นตัวชี้ไปยังอินสแตนซ์ที่สร้างขึ้นของคลาส วิดเจ็ต- ดังนั้นบรรทัดที่ 13 จะสร้างออบเจ็กต์คลาสป้ายกำกับที่ควรแสดงถึงข้อความที่ระบุและเจ้าของถูกกำหนดให้กับออบเจ็กต์ปัจจุบัน

ถึงเวลาที่จะพูดคุยเกี่ยวกับห่วงโซ่ความเป็นเจ้าของที่นำไปใช้ในระบบคลาส Qt เพื่อแก้ไขปัญหาการทำลายอ็อบเจ็กต์เพื่อป้องกันการรั่วไหลของหน่วยความจำโดยไม่ตั้งใจ ควรจำไว้ว่าวัตถุที่สร้างขึ้นแบบไดนามิกเช่น โดยใช้ตัวดำเนินการ ใหม่จะอยู่ในพื้นที่หน่วยความจำพิเศษที่เรียกว่า กองและอาศัยอยู่บนกองจนกระทั่งถูกทำลายโดยผู้ปฏิบัติงานอย่างชัดเจน ลบ- หากโปรแกรมเมอร์ไม่ติดตามการทำลายวัตถุที่ไม่จำเป็นและไม่เรียกผู้ปฏิบัติงานให้ทำลายวัตถุเหล่านั้น ลบนี่จึงกลายเป็นสาเหตุของการรั่วไหลของหน่วยความจำในแอปพลิเคชัน ซึ่งเป็นปัญหาร้ายแรงสำหรับภาษาการเขียนโปรแกรมจำนวนหนึ่ง ซึ่งรวมถึงภาษา C++ ด้วย

มีแผนที่รู้จักกันดีหลายประการสำหรับการติดตามการทำลายวัตถุที่สร้างขึ้นแบบไดนามิกโดยอัตโนมัติ หนึ่งในนั้นคือการใช้พอยน์เตอร์อัจฉริยะซึ่งควรจะพูดคุยกันในภายหลัง อีกวิธีหนึ่งคือการสร้างห่วงโซ่การเป็นเจ้าของ ซึ่งเราจะหารือกันตอนนี้ วิธีที่สามคือการสร้างระบบย่อยการรวบรวมขยะซึ่งควรติดตามวัตถุที่ไม่จำเป็นและทำลายพวกมัน วิธีหลังซึ่งเป็นวิธีดั้งเดิมสำหรับเคอร์เนลของภาษาสมัยใหม่จำนวนมาก ในทางปฏิบัติแล้วไม่ได้ใช้ในภาษา C++ สองวิธีแรกได้รับความนิยมมากกว่าในภาษา C++ แบบดั้งเดิม

ดังนั้น ห่วงโซ่ความเป็นเจ้าของจึงนำแนวคิดง่ายๆ ต่อไปนี้ไปใช้ วัตถุถูกสร้างขึ้น การทำลายล้างซึ่งเราดำเนินการติดตาม วิธีที่ง่ายที่สุดคือการสร้างออบเจ็กต์ดังกล่าวตามคำจำกัดความแบบคงที่ จากนั้นมันจะถูกทำลายโดยอัตโนมัติเมื่อการทำงานของโปรแกรมไปถึงจุดสิ้นสุดของบล็อกคำสั่ง (...) ที่ได้ถูกกำหนดไว้ ต่อไป เมื่อสร้างวัตถุอื่นแบบไดนามิก เราจะกำหนดวัตถุที่เป็นเจ้าของให้กับวัตถุเหล่านั้น ความรับผิดชอบของเจ้าของจะรวมถึงการทำลายวัตถุที่มีเจ้าของในร่างกายของผู้ทำลายของตนเอง โปรดจำไว้ว่า destructor เป็นวิธีการพิเศษที่ถูกเรียกเมื่อวัตถุถูกทำลาย ดังนั้นจึงเป็นไปได้ที่จะสร้างห่วงโซ่ความเป็นเจ้าของโดยสัมพันธ์กับออบเจ็กต์แรก องค์ประกอบทั้งหมดจะถูกทำลายโดยอัตโนมัติเมื่อออบเจ็กต์แรกถูกทำลาย เมื่อจัดโครงการดังกล่าว คุณจะต้องคำนึงถึงอายุการใช้งานของวัตถุที่ได้รับการกำหนดให้เป็นเจ้าของวัตถุอื่นอย่างถูกต้องเท่านั้น เพื่อไม่ให้วัตถุถูกทำลายก่อนเวลาอันควร

นี่เป็นรูปแบบความเป็นเจ้าของที่นำไปใช้ในระบบคลาส Qt เมื่อสร้างคลาสจำนวนมากจากไลบรารีนี้ คุณสามารถใช้ตัวสร้างที่มีพารามิเตอร์เพียงตัวเดียวหรือตัวสุดท้ายที่จะนำตัวชี้ไปยังวัตถุที่ถูกกำหนดให้เป็นเจ้าของให้กับวัตถุที่ถูกสร้างขึ้น พารามิเตอร์นี้อธิบายเป็นพารามิเตอร์ที่มีค่าเริ่มต้น ซึ่งถูกกำหนดให้เป็นศูนย์ ดังนั้น หากไม่ได้ระบุที่อยู่ของเจ้าของ พารามิเตอร์จะถูกตั้งค่าเป็นศูนย์และโครงร่างความเป็นเจ้าของสำหรับออบเจ็กต์ดังกล่าวจะถูกปิดใช้งาน ในกรณีนี้ คุณควรจำไว้ว่าต้องทำลายวัตถุดังกล่าวอย่างชัดเจน

เมื่อใช้ไดอะแกรมวงจรความเป็นเจ้าของ บางไลบรารีจะใช้พารามิเตอร์ที่เรียกว่า เจ้าของซึ่งแปลมาจากภาษาอังกฤษว่า เจ้าของ- อย่างไรก็ตาม ในไลบรารี Qt พารามิเตอร์นี้เรียกว่า พ่อแม่ซึ่งแปลมาจากภาษาอังกฤษว่า พ่อแม่- เป็นผลให้มือใหม่บางคนมีความเข้าใจผิดเนื่องจากแนวคิดของ "ผู้ปกครอง" โดยทั่วไปหมายถึงห่วงโซ่การสืบทอดใน OOP แต่ห่วงโซ่การสืบทอดและห่วงโซ่ความเป็นเจ้าของไม่มีอะไรที่เหมือนกัน โปรดใช้ความระมัดระวังและอย่าตกเป็นเหยื่อของความเข้าใจผิดในเรื่องนี้

กลับมาที่บรรทัดที่ 13 อีกครั้ง ที่นั่นเราได้สร้างออบเจ็กต์ซึ่งเจ้าของถูกกำหนดให้กับออบเจ็กต์ปัจจุบันของหน้าต่างแอปพลิเคชันหลัก ตัวแปร กรุณาซึ่งเก็บที่อยู่ของวัตถุที่สร้างขึ้นจะถูกทำลายโดยอัตโนมัติเมื่อถึงจุดสิ้นสุดของโค้ดตัวสร้าง อย่างไรก็ตาม อ็อบเจ็กต์ที่ถูกจัดสรรในหน่วยความจำจะยังคงมีอยู่ และจะคงอยู่จนกว่าอ็อบเจ็กต์ของหน้าต่างแอปพลิเคชันหลักจะถูกทำลาย การทำลายวัตถุหน้าต่างหลักจะทำลายวัตถุทั้งหมดที่วัตถุหน้าต่างเป็นเจ้าของโดยอัตโนมัติ

ในบรรทัดที่ 14 เราเข้าถึงวิธีการตั้งค่าแอตทริบิวต์เรขาคณิตที่กำหนดตำแหน่งของวัตถุที่กำหนดเองโดยสัมพันธ์กับเจ้าของ ค่าแรกและค่าที่สองระบุพิกัดแนวนอนและแนวตั้งสำหรับมุมซ้ายบนของวัตถุ ค่าที่สามและสี่ระบุความกว้างและความสูงของวัตถุที่กำหนดเอง

หากคุณแน่ใจว่าตัวอย่างที่สร้างขึ้นในส่วนก่อนหน้าประกอบและรันโดยไม่มีข้อผิดพลาด ตัวอย่างนี้ ซึ่งเป็นส่วนขยายของตัวอย่างก่อนหน้าก็ควรจะรันเช่นกัน

เมื่อใช้แอปพลิเคชันนี้ คุณสามารถทดลองใช้ตัวเลือกการเปิดแอปพลิเคชันได้ วิธีที่ง่ายที่สุดในการทำเช่นนี้คือในคอนโซล ไปที่ไดเร็กทอรีบิลด์แอปพลิเคชันแล้วทำตามตัวเลือกต่อไปนี้เพื่อรันแอปพลิเคชันด้วยพารามิเตอร์ ในการเปิดตัวแต่ละครั้ง สไตล์วิดเจ็ตการวาดควรมีความแตกต่างที่เห็นได้ชัดเจน

$ ./app1 -style=motif $ ./app1 -style=windows $ ./app1 -style=platinum

ในตัวอย่างนี้ ไฟล์ปฏิบัติการของแอปพลิเคชันจะถูกระบุด้วยชื่อ แอพ1- เป็นไปได้ว่าในกรณีของคุณ ไฟล์ปฏิบัติการอาจมีชื่อแตกต่างออกไป ในระบบปฏิบัติการ Windows ไฟล์ปฏิบัติการจะมีนามสกุล อดีต- นอกจากนี้ในระบบปฏิบัติการ Windows คุณสามารถเปิดไฟล์ปฏิบัติการจากไดเร็กทอรีปัจจุบันได้โดยไม่ต้องระบุเส้นทางสัมพัทธ์เช่น โดยไม่มีข้อบ่งชี้ ( ./ ) - อักขระจุดคือคำพ้องสำหรับไดเร็กทอรีปัจจุบัน และอักขระเครื่องหมายทับคืออักขระตัวคั่นในรายการพาธของไฟล์ นอกจากนี้ โปรดทราบว่าสัญลักษณ์ดอลลาร์เป็นสัญลักษณ์พรอมต์มาตรฐานในคอนโซล *nix สำหรับผู้ใช้ทั่วไป และไม่จำเป็นต้องพิมพ์เป็นส่วนหนึ่งของคำสั่ง ในคอนโซล Windows อักขระพร้อมต์มักจะเป็นอักขระวงเล็บมุม ( > ).

ตัวเลือกการเริ่มสามารถระบุได้เมื่อเรียกใช้แอปพลิเคชันจากสภาพแวดล้อมการพัฒนา QtCreator โดยคลิกที่ไอคอนบนแถบเครื่องมือด้านซ้าย โครงการ- แท็บการตั้งค่าที่เกี่ยวข้องจะเปิดขึ้น ที่ด้านบนของหน้าต่าง คุณจะเห็นระบบแท็บแบบมีลำดับชั้น แท็บระดับบนสุดจะกำหนดโปรเจ็กต์ เนื่องจากสามารถเปิดหลายโปรเจ็กต์ได้ในสภาพแวดล้อมการพัฒนา แท็บระดับถัดไปจะต้องมีแท็บ เหนือสิ่งอื่นใด สร้างและเรียกใช้ซึ่งเราต้องการ ในแท็บนี้ ให้คุณเลือกเวอร์ชัน Qt SDK ในกรณีที่คุณกำลังสร้างโปรเจ็กต์สำหรับหลายเวอร์ชันพร้อมกัน หากคุณกำลังประกอบโปรเจ็กต์สำหรับเวอร์ชันเดียว การเลือกจะประกอบด้วยองค์ประกอบเดียว ภายในวิดเจ็ตการเลือกเวอร์ชัน Qt SDK มีปุ่มเก๋ๆ สองปุ่มที่มีขอบโค้งมน สร้างและ วิ่ง- คลิกปุ่ม วิ่งเพื่อเลือกกลุ่มการตั้งค่าที่เหมาะสม ที่นั่นในกลุ่มพารามิเตอร์ที่มีชื่อเดียวกัน วิ่งคุณจะพบช่องป้อนข้อมูลบรรทัดเดียวตรงข้ามป้ายกำกับ ข้อโต้แย้ง- นี่คือเป้าหมายสูงสุดที่เราเลือก ลองเขียนบรรทัดต่อไปนี้ตรงนั้น

สไตล์=แม่ลาย

เปิดแอปพลิเคชัน จากนั้นลองใช้ค่าอื่น: หน้าต่างและ แพลทินัม- จำได้ว่าวัตถุคลาส QApplicationรองรับรายการพารามิเตอร์การเรียกทำงานสองสามโหล ซึ่งสามารถอ่านได้ในวิธีใช้สำหรับตัวสร้างคลาสที่เกี่ยวข้อง

ขณะที่คุณดูตัวอย่าง ให้ตรวจสอบข้อมูลอ้างอิงสำหรับคลาสที่ใช้ในตัวอย่าง ลองเพิ่มอินสแตนซ์อื่นๆ ของป้ายกำกับ ช่องป้อนข้อมูลบรรทัดเดียว และคลาสปุ่มลงในแบบฟอร์ม นอกจากนี้ ให้ลองอ่านวิธีใช้และเพิ่มออบเจ็กต์ของคลาสต่อไปนี้ลงในแบบฟอร์ม

1. QComboBox— คลาสรายการแบบเลื่อนลง
2. QCheckBox— คลาสธง (ตัวตรวจสอบ)
3. QTextEdit— คลาสของฟิลด์อินพุตหลายบรรทัด ใช้สำหรับแก้ไขและนำเสนอข้อความ มีความสามารถที่หลากหลายมากในการนำเสนอเอกสารโดยแยกฟังก์ชันของผู้แต่งเอกสารพิเศษออกเป็นคลาสที่แยกจากกัน

โดยสรุปของบทเรียน ควรสังเกตว่าวิธีการที่ใช้เพื่อการจัดวางวัตถุแบบ "เข้มงวด" บนฟิลด์แบบฟอร์ม ผ่านการบ่งชี้อย่างชัดเจนของเรขาคณิตของตำแหน่งนั้น ไม่ใช่วิธีดั้งเดิมและแนะนำในไลบรารีคลาส Qt บทเรียนต่อไปนี้จะกล่าวถึงตัวจัดการเลย์เอาต์ ซึ่งเป็นวิธีการที่ทันสมัยและสะดวกสบายในการวางวิดเจ็ตบนแบบฟอร์ม

นี่คือชุดเครื่องมือพัฒนาซอฟต์แวร์ข้ามแพลตฟอร์มในภาษาการเขียนโปรแกรม C++ นอกจากนี้ยังมี "การเชื่อมโยง" กับภาษาการเขียนโปรแกรมอื่น ๆ อีกมากมาย: Python - PyQt, Ruby - QtRuby, Java - Qt Jambi, PHP - PHP-Qt และอื่น ๆ
ช่วยให้คุณสามารถเรียกใช้ซอฟต์แวร์ที่เขียนด้วยตัวช่วยบนระบบปฏิบัติการที่ทันสมัยที่สุด โดยเพียงแค่รวบรวมโปรแกรมสำหรับแต่ละระบบปฏิบัติการโดยไม่ต้องเปลี่ยนซอร์สโค้ด รวมคลาสพื้นฐานทั้งหมดที่อาจจำเป็นในการพัฒนาซอฟต์แวร์แอพพลิเคชั่น ตั้งแต่องค์ประกอบอินเทอร์เฟซแบบกราฟิกไปจนถึงคลาสสำหรับการทำงานกับเครือข่าย ฐานข้อมูล และ XML Qt เป็นแบบเชิงวัตถุอย่างสมบูรณ์ ขยายได้ง่าย และรองรับเทคนิคการเขียนโปรแกรมแบบอิงคอมโพเนนต์
ในบทความนี้ ฉันจะแสดงให้คุณเห็นถึงวิธีการเขียนโปรแกรม “Hello, World!” แบบง่ายๆ ใช้ไลบรารี Qt4

สภาพแวดล้อมการพัฒนา

ก่อนอื่น เรามากำหนดสภาพแวดล้อมการพัฒนากันก่อน โดยส่วนตัวแล้วฉันใช้ IDE Code::Blocks ข้ามแพลตฟอร์มเพื่อเขียนโปรแกรม (คุณสามารถอ่านเพิ่มเติมเกี่ยวกับการทำงานใน IDE นี้ด้วย Qt4) นอกจากนี้ยังมีปลั๊กอินสำหรับการทำงานกับ Qt ใน Eclipse Qt สำหรับ MS Windows เวอร์ชันเชิงพาณิชย์สามารถรวมเข้ากับ MSVS ได้ โปรแกรมสามารถเขียนในโปรแกรมแก้ไขข้อความใดก็ได้แล้วคอมไพล์จากบรรทัดคำสั่ง
เพื่อความชัดเจน ฉันจะแสดงวิธีการคอมไพล์โปรแกรมที่เขียนด้วย Qt ด้วยตนเอง

โปรแกรมแรก

ขั้นแรก สร้างไฟล์ในตัวแก้ไขข้อความใดๆ และตั้งชื่อไฟล์ เช่น main.cpp
ลองเขียนสิ่งต่อไปนี้ลงไป:

1. #รวม
2. #รวม
3. แอปแอปพลิเคชัน Q(argc, argv);
4. QDialog *dialog = QDialog ใหม่;
5. QLabel *label = new QLabel(กล่องโต้ตอบ);
6. ป้ายกำกับ -> setText ( "สวัสดีชาวโลก!" );
7. กล่องโต้ตอบ -> แสดง ();
8. กลับ app.exec();

ในบรรทัดที่ 1 และ 2 เราได้รวมไฟล์ส่วนหัว Qt ซึ่งมีคลาสหลักอยู่
ในบรรทัดที่ 4 เราประกาศฟังก์ชั่นหลัก - ฟังก์ชั่นหลักที่เริ่มการทำงานของโปรแกรมใด ๆ มันจะส่งคืนจำนวนเต็ม (ผลลัพธ์ของโปรแกรม 0 - หากทุกอย่างเป็นไปตามลำดับ) และรับตัวแปรสองตัวเป็นอินพุต - จำนวนพารามิเตอร์บรรทัดคำสั่งและอาร์เรย์ที่เก็บไว้
ในบรรทัดที่ 5 เราสร้างวัตถุแอปพลิเคชัน เราส่งตัวแปรบรรทัดคำสั่งไปยังวัตถุนี้
ในบรรทัดที่ 6 เราสร้างกล่องโต้ตอบ - หน้าต่างกราฟิกรูปสี่เหลี่ยมผืนผ้าพร้อมแถบชื่อเรื่องและปุ่มที่มุมขวาบน สร้างป้ายกำกับ (บรรทัดที่ 7) เมื่อเราสร้างป้ายกำกับ เราจะส่งตัวชี้ไปยังไดอะล็อกไปยังตัวสร้าง ซึ่งจะกลายเป็นพาเรนต์ เมื่อคุณลบพาเรนต์ ลูกทั้งหมดจะถูกลบโดยอัตโนมัติ ซึ่งสะดวกมาก จากนั้นเราตั้งค่าข้อความของป้ายกำกับโดยการเรียกใช้ฟังก์ชัน setText() (บรรทัดที่ 8) ดังที่คุณเห็นจากตัวอย่าง คุณสามารถใช้แท็ก html สำหรับข้อความที่แสดงได้
ในบรรทัดที่ 9 เราจะแสดงกล่องโต้ตอบป้ายกำกับของเราบนหน้าจอ
สุดท้าย ในบรรทัดที่ 10 เราจะเริ่มลูปเหตุการณ์ระบบปฏิบัติการของแอปพลิเคชัน เราส่งคืนผลลัพธ์ของการดำเนินการของวัตถุตามผลลัพธ์ของโปรแกรม

การรวบรวม

ทีนี้มาคอมไพล์โปรแกรมที่เขียนกันดีกว่า
ไปที่ไดเร็กทอรีที่เราบันทึกไฟล์ main.cpp ของเราแล้วรันคำสั่ง

$ qmake -project

สิ่งนี้จะสร้างเทมเพลตโปรเจ็กต์ Qt4 ซึ่งจะรวมไฟล์ซอร์สโค้ดทั้งหมดที่อยู่ในไดเร็กทอรีนี้โดยอัตโนมัติ ผลลัพธ์จะเป็นไฟล์ที่มีชื่อเดียวกันกับไดเร็กทอรีปัจจุบันและนามสกุล .pro มันจะมีลักษณะเช่นนี้:

เทมเพลต=แอป
เป้าหมาย =
ขึ้นอยู่กับเส้นทาง +=
รวมเส้นทาง +=

#ป้อนข้อมูล
แหล่งที่มา += main.cpp

เป็นผลให้เราจะได้รับ Makefile ซึ่งเราใช้ในการคอมไพล์โปรแกรมโดยการรันคำสั่งต่อไปนี้:

รอจนกว่ากระบวนการคอมไพล์จะสิ้นสุดและรันโปรแกรมแรกของเรา มันจะมีลักษณะดังนี้:

โปรแกรมที่สอง

หากต้องการควบคุมหน้าต่างที่สร้างขึ้นและวิดเจ็ตอื่น ๆ อย่างสมบูรณ์ คุณต้องสร้างคลาสที่ได้รับมาจากหน้าต่างเหล่านั้น มาสร้างคลาส MyDialog ที่ได้รับมากันดีกว่า เราจะใช้คลาส QDialog เป็นคลาสหลัก เราจะใส่คำอธิบายของชั้นเรียนของเราไว้ในไฟล์ส่วนหัว mydialog.h:

1. #รวม
2. #รวม
3. #รวม
4. #รวม
5. คลาส MyDialog: QDialog สาธารณะ (
6. Q_วัตถุ
7. สาธารณะ:
8. MyDialog(QWidget *พาเรนต์ = 0);

* ซอร์สโค้ดนี้ถูกเน้นด้วย Source Code Highlighter

ในสี่บรรทัดแรก เราจะรวมไฟล์ส่วนหัวที่จำเป็นขององค์ประกอบกราฟิกที่ใช้ - กล่องโต้ตอบ ปุ่ม ป้ายกำกับ และเครื่องมือจัดการเค้าโครงแนวตั้ง ใช้ไฟล์ส่วนหัวขนาดใหญ่เช่น , ไม่แนะนำให้ใช้ ฯลฯ ในโปรเจ็กต์ขนาดใหญ่ เนื่องจากจะทำให้เวลาในการคอมไพล์เพิ่มขึ้น
ในบรรทัดที่ 6 เรากำหนดคลาสของเราให้ได้รับมาจาก QDialog
ในบรรทัดถัดไป เราได้ระบุแมโคร Q_OBJECT ซึ่งบอกตัวประมวลผลล่วงหน้า Qt ว่าคลาสนี้จะใช้คุณลักษณะ Qt เพิ่มเติม เช่น ระบบสัญญาณและสล็อต
ในบรรทัดที่ 9 เราระบุตัวสร้างสำหรับกล่องโต้ตอบของเรา มีพารามิเตอร์อินพุตเพียงตัวเดียว - ตัวชี้ไปยังวัตถุหลัก (0 หากไม่มีพาเรนต์)
เราจะกำหนด Constructor ของคลาสของเราในไฟล์ mydialog.cpp:

1. #รวม "mydialog.h"
2. MyDialog::MyDialog(QWidget *พาเรนต์) : QDialog(พาเรนต์) (
3. QVBoxLayout *layout = QVBoxLayout ใหม่ (สิ่งนี้);
4. QLabel *label = new QLabel(this );
5. ป้ายกำกับ -> setText ( "สวัสดีชาวโลก!" );
6. QPushButton *button = QPushButton ใหม่ (สิ่งนี้);
7. ปุ่ม -> setText ("ปิด" );
8. เค้าโครง -> addWidget (ป้ายกำกับ);
9. เค้าโครง -> addWidget (ปุ่ม);
10. เชื่อมต่อ (ปุ่ม, สัญญาณ (คลิก ()), นี้ , SLOT (ปิด ()));

* ซอร์สโค้ดนี้ถูกเน้นด้วย Source Code Highlighter

ในบรรทัดที่ 4 เราสร้างตัวจัดการเลย์เอาต์ที่จะแสดงวิดเจ็ตทั้งหมดที่เพิ่มในแนวตั้งโดยอัตโนมัติ การสร้างคำจารึกจะคล้ายกับตัวอย่างก่อนหน้า
ในบรรทัดที่ 7 และ 8 เราสร้างปุ่มและตั้งค่าข้อความ ในสองบรรทัดถัดไป เราจะเพิ่มวิดเจ็ตของเราไปยังเครื่องมือจัดการเค้าโครง เพื่อที่มันจะจัดเรียงวิดเจ็ตเหล่านั้นโดยอัตโนมัติ
ในบรรทัดที่ 11 เราเชื่อมต่อสัญญาณ clicked() ของปุ่มเข้ากับช่อง close() ของกล่องโต้ตอบของเรา แต่ละวัตถุ Qt สามารถมีสัญญาณและช่องของตัวเอง ซึ่งสามารถเชื่อมต่อกับสัญญาณและช่องของวัตถุอื่น ๆ และสื่อสารระหว่างองค์ประกอบของโปรแกรม
ไฟล์ main.cpp จะมีลักษณะดังนี้:

1. #รวม
2. #รวม "mydialog.h"
3. int หลัก (int argc, ถ่าน * argv) (
4. แอปแอปพลิเคชัน Q(argc, argv);
5. MyDialog *dialog = MyDialog ใหม่;
6. กล่องโต้ตอบ -> แสดง ();
7. กลับ app.exec();

* ซอร์สโค้ดนี้ถูกเน้นด้วย Source Code Highlighter

การสร้างโครงการใหม่เป็นทีม

$ qmake -project

เพื่อให้ไฟล์ใหม่ถูกเพิ่มเข้าไปโดยอัตโนมัติและเราจะคอมไพล์มัน นี่คือลักษณะของโปรแกรมใหม่ของเรา:

โปรแกรมที่สาม

หากกล่องโต้ตอบมีองค์ประกอบกราฟิกจำนวนมาก การสร้างหน้าต่างดังกล่าวอาจค่อนข้างน่าเบื่อ เพื่อให้กระบวนการนี้ง่ายขึ้น มีเครื่องมือที่เรียกว่า Qt Designer มาเปิดตัวกันเลย

และเลือกสร้างกล่องโต้ตอบแบบไม่มีปุ่ม เราเพิ่มป้ายกำกับและปุ่มลงไปและแก้ไขข้อความ การใช้เครื่องมือตัวแก้ไขสัญญาณ/สล็อต เราเชื่อมต่อสัญญาณคลิก () ของปุ่มเข้ากับช่องปิด () ของกล่องโต้ตอบ เราจัดเรียงพวกมันในแนวตั้งโดยใช้ตัวจัดการเลย์เอาต์ บันทึกไฟล์ผลลัพธ์ภายใต้ชื่อ mydialog.ui หลังจากนั้นมันจะถูกแปลงเป็นไฟล์ส่วนหัวชื่อ ui_mydialog.h โดยอัตโนมัติ
เราเปลี่ยนไฟล์ส่วนหัวของกล่องโต้ตอบ mydialog.h ดังนี้:

นี่คือชุดเครื่องมือพัฒนาซอฟต์แวร์ข้ามแพลตฟอร์มในภาษาการเขียนโปรแกรม C++ นอกจากนี้ยังมี "การเชื่อมโยง" กับภาษาการเขียนโปรแกรมอื่น ๆ อีกมากมาย: Python - PyQt, Ruby - QtRuby, Java - Qt Jambi, PHP - PHP-Qt และอื่น ๆ
ช่วยให้คุณสามารถเรียกใช้ซอฟต์แวร์ที่เขียนด้วยตัวช่วยบนระบบปฏิบัติการที่ทันสมัยที่สุด โดยเพียงแค่รวบรวมโปรแกรมสำหรับแต่ละระบบปฏิบัติการโดยไม่ต้องเปลี่ยนซอร์สโค้ด รวมคลาสพื้นฐานทั้งหมดที่อาจจำเป็นในการพัฒนาซอฟต์แวร์แอพพลิเคชั่น ตั้งแต่องค์ประกอบอินเทอร์เฟซแบบกราฟิกไปจนถึงคลาสสำหรับการทำงานกับเครือข่าย ฐานข้อมูล และ XML Qt เป็นแบบเชิงวัตถุอย่างสมบูรณ์ ขยายได้ง่าย และรองรับเทคนิคการเขียนโปรแกรมแบบอิงคอมโพเนนต์
ในบทความนี้ ฉันจะแสดงให้คุณเห็นถึงวิธีการเขียนโปรแกรม “Hello, World!” แบบง่ายๆ ใช้ไลบรารี Qt4

สภาพแวดล้อมการพัฒนา

ก่อนอื่น เรามากำหนดสภาพแวดล้อมการพัฒนากันก่อน โดยส่วนตัวแล้วฉันใช้ IDE Code::Blocks ข้ามแพลตฟอร์มเพื่อเขียนโปรแกรม (คุณสามารถอ่านเพิ่มเติมเกี่ยวกับการทำงานใน IDE นี้ด้วย Qt4) นอกจากนี้ยังมีปลั๊กอินสำหรับการทำงานกับ Qt ใน Eclipse Qt สำหรับ MS Windows เวอร์ชันเชิงพาณิชย์สามารถรวมเข้ากับ MSVS ได้ โปรแกรมสามารถเขียนในโปรแกรมแก้ไขข้อความใดก็ได้แล้วคอมไพล์จากบรรทัดคำสั่ง
เพื่อความชัดเจน ฉันจะแสดงวิธีการคอมไพล์โปรแกรมที่เขียนด้วย Qt ด้วยตนเอง

โปรแกรมแรก

ขั้นแรก สร้างไฟล์ในตัวแก้ไขข้อความใดๆ และตั้งชื่อไฟล์ เช่น main.cpp
ลองเขียนสิ่งต่อไปนี้ลงไป:

1. #รวม
2. #รวม
3. แอปแอปพลิเคชัน Q(argc, argv);
4. QDialog *dialog = QDialog ใหม่;
5. QLabel *label = new QLabel(กล่องโต้ตอบ);
6. ป้ายกำกับ -> setText ( "สวัสดีชาวโลก!" );
7. กล่องโต้ตอบ -> แสดง ();
8. กลับ app.exec();

ในบรรทัดที่ 1 และ 2 เราได้รวมไฟล์ส่วนหัว Qt ซึ่งมีคลาสหลักอยู่
ในบรรทัดที่ 4 เราประกาศฟังก์ชั่นหลัก - ฟังก์ชั่นหลักที่เริ่มการทำงานของโปรแกรมใด ๆ มันจะส่งคืนจำนวนเต็ม (ผลลัพธ์ของโปรแกรม 0 - หากทุกอย่างเป็นไปตามลำดับ) และรับตัวแปรสองตัวเป็นอินพุต - จำนวนพารามิเตอร์บรรทัดคำสั่งและอาร์เรย์ที่เก็บไว้
ในบรรทัดที่ 5 เราสร้างวัตถุแอปพลิเคชัน เราส่งตัวแปรบรรทัดคำสั่งไปยังวัตถุนี้
ในบรรทัดที่ 6 เราสร้างกล่องโต้ตอบ - หน้าต่างกราฟิกรูปสี่เหลี่ยมผืนผ้าพร้อมแถบชื่อเรื่องและปุ่มที่มุมขวาบน สร้างป้ายกำกับ (บรรทัดที่ 7) เมื่อเราสร้างป้ายกำกับ เราจะส่งตัวชี้ไปยังไดอะล็อกไปยังตัวสร้าง ซึ่งจะกลายเป็นพาเรนต์ เมื่อคุณลบพาเรนต์ ลูกทั้งหมดจะถูกลบโดยอัตโนมัติ ซึ่งสะดวกมาก จากนั้นเราตั้งค่าข้อความของป้ายกำกับโดยการเรียกใช้ฟังก์ชัน setText() (บรรทัดที่ 8) ดังที่คุณเห็นจากตัวอย่าง คุณสามารถใช้แท็ก html สำหรับข้อความที่แสดงได้
ในบรรทัดที่ 9 เราจะแสดงกล่องโต้ตอบป้ายกำกับของเราบนหน้าจอ
สุดท้าย ในบรรทัดที่ 10 เราจะเริ่มลูปเหตุการณ์ระบบปฏิบัติการของแอปพลิเคชัน เราส่งคืนผลลัพธ์ของการดำเนินการของวัตถุตามผลลัพธ์ของโปรแกรม

การรวบรวม

ทีนี้มาคอมไพล์โปรแกรมที่เขียนกันดีกว่า
ไปที่ไดเร็กทอรีที่เราบันทึกไฟล์ main.cpp ของเราแล้วรันคำสั่ง

$ qmake -project

สิ่งนี้จะสร้างเทมเพลตโปรเจ็กต์ Qt4 ซึ่งจะรวมไฟล์ซอร์สโค้ดทั้งหมดที่อยู่ในไดเร็กทอรีนี้โดยอัตโนมัติ ผลลัพธ์จะเป็นไฟล์ที่มีชื่อเดียวกันกับไดเร็กทอรีปัจจุบันและนามสกุล .pro มันจะมีลักษณะเช่นนี้:

เทมเพลต=แอป
เป้าหมาย =
ขึ้นอยู่กับเส้นทาง +=
รวมเส้นทาง +=

#ป้อนข้อมูล
แหล่งที่มา += main.cpp

เป็นผลให้เราจะได้รับ Makefile ซึ่งเราใช้ในการคอมไพล์โปรแกรมโดยการรันคำสั่งต่อไปนี้:

รอจนกว่ากระบวนการคอมไพล์จะสิ้นสุดและรันโปรแกรมแรกของเรา มันจะมีลักษณะดังนี้:

โปรแกรมที่สอง

หากต้องการควบคุมหน้าต่างที่สร้างขึ้นและวิดเจ็ตอื่น ๆ อย่างสมบูรณ์ คุณต้องสร้างคลาสที่ได้รับมาจากหน้าต่างเหล่านั้น มาสร้างคลาส MyDialog ที่ได้รับมากันดีกว่า เราจะใช้คลาส QDialog เป็นคลาสหลัก เราจะใส่คำอธิบายของชั้นเรียนของเราไว้ในไฟล์ส่วนหัว mydialog.h:

1. #รวม
2. #รวม
3. #รวม
4. #รวม
5. คลาส MyDialog: QDialog สาธารณะ (
6. Q_วัตถุ
7. สาธารณะ:
8. MyDialog(QWidget *พาเรนต์ = 0);

* ซอร์สโค้ดนี้ถูกเน้นด้วย Source Code Highlighter

ในสี่บรรทัดแรก เราจะรวมไฟล์ส่วนหัวที่จำเป็นขององค์ประกอบกราฟิกที่ใช้ - กล่องโต้ตอบ ปุ่ม ป้ายกำกับ และเครื่องมือจัดการเค้าโครงแนวตั้ง ใช้ไฟล์ส่วนหัวขนาดใหญ่เช่น , ไม่แนะนำให้ใช้ ฯลฯ ในโปรเจ็กต์ขนาดใหญ่ เนื่องจากจะทำให้เวลาในการคอมไพล์เพิ่มขึ้น
ในบรรทัดที่ 6 เรากำหนดคลาสของเราให้ได้รับมาจาก QDialog
ในบรรทัดถัดไป เราได้ระบุแมโคร Q_OBJECT ซึ่งบอกตัวประมวลผลล่วงหน้า Qt ว่าคลาสนี้จะใช้คุณลักษณะ Qt เพิ่มเติม เช่น ระบบสัญญาณและสล็อต
ในบรรทัดที่ 9 เราระบุตัวสร้างสำหรับกล่องโต้ตอบของเรา มีพารามิเตอร์อินพุตเพียงตัวเดียว - ตัวชี้ไปยังวัตถุหลัก (0 หากไม่มีพาเรนต์)
เราจะกำหนด Constructor ของคลาสของเราในไฟล์ mydialog.cpp:

1. #รวม "mydialog.h"
2. MyDialog::MyDialog(QWidget *พาเรนต์) : QDialog(พาเรนต์) (
3. QVBoxLayout *layout = QVBoxLayout ใหม่ (สิ่งนี้);
4. QLabel *label = new QLabel(this );
5. ป้ายกำกับ -> setText ( "สวัสดีชาวโลก!" );
6. QPushButton *button = QPushButton ใหม่ (สิ่งนี้);
7. ปุ่ม -> setText ("ปิด" );
8. เค้าโครง -> addWidget (ป้ายกำกับ);
9. เค้าโครง -> addWidget (ปุ่ม);
10. เชื่อมต่อ (ปุ่ม, สัญญาณ (คลิก ()), นี้ , SLOT (ปิด ()));

* ซอร์สโค้ดนี้ถูกเน้นด้วย Source Code Highlighter

ในบรรทัดที่ 4 เราสร้างตัวจัดการเลย์เอาต์ที่จะแสดงวิดเจ็ตทั้งหมดที่เพิ่มในแนวตั้งโดยอัตโนมัติ การสร้างคำจารึกจะคล้ายกับตัวอย่างก่อนหน้า
ในบรรทัดที่ 7 และ 8 เราสร้างปุ่มและตั้งค่าข้อความ ในสองบรรทัดถัดไป เราจะเพิ่มวิดเจ็ตของเราไปยังเครื่องมือจัดการเค้าโครง เพื่อที่มันจะจัดเรียงวิดเจ็ตเหล่านั้นโดยอัตโนมัติ
ในบรรทัดที่ 11 เราเชื่อมต่อสัญญาณ clicked() ของปุ่มเข้ากับช่อง close() ของกล่องโต้ตอบของเรา แต่ละวัตถุ Qt สามารถมีสัญญาณและช่องของตัวเอง ซึ่งสามารถเชื่อมต่อกับสัญญาณและช่องของวัตถุอื่น ๆ และสื่อสารระหว่างองค์ประกอบของโปรแกรม
ไฟล์ main.cpp จะมีลักษณะดังนี้:

1. #รวม
2. #รวม "mydialog.h"
3. int หลัก (int argc, ถ่าน * argv) (
4. แอปแอปพลิเคชัน Q(argc, argv);
5. MyDialog *dialog = MyDialog ใหม่;
6. กล่องโต้ตอบ -> แสดง ();
7. กลับ app.exec();

* ซอร์สโค้ดนี้ถูกเน้นด้วย Source Code Highlighter

การสร้างโครงการใหม่เป็นทีม

$ qmake -project

เพื่อให้ไฟล์ใหม่ถูกเพิ่มเข้าไปโดยอัตโนมัติและเราจะคอมไพล์มัน นี่คือลักษณะของโปรแกรมใหม่ของเรา:

โปรแกรมที่สาม

หากกล่องโต้ตอบมีองค์ประกอบกราฟิกจำนวนมาก การสร้างหน้าต่างดังกล่าวอาจค่อนข้างน่าเบื่อ เพื่อให้กระบวนการนี้ง่ายขึ้น มีเครื่องมือที่เรียกว่า Qt Designer มาเปิดตัวกันเลย

และเลือกสร้างกล่องโต้ตอบแบบไม่มีปุ่ม เราเพิ่มป้ายกำกับและปุ่มลงไปและแก้ไขข้อความ การใช้เครื่องมือตัวแก้ไขสัญญาณ/สล็อต เราเชื่อมต่อสัญญาณคลิก () ของปุ่มเข้ากับช่องปิด () ของกล่องโต้ตอบ เราจัดเรียงพวกมันในแนวตั้งโดยใช้ตัวจัดการเลย์เอาต์ บันทึกไฟล์ผลลัพธ์ภายใต้ชื่อ mydialog.ui หลังจากนั้นมันจะถูกแปลงเป็นไฟล์ส่วนหัวชื่อ ui_mydialog.h โดยอัตโนมัติ
เราเปลี่ยนไฟล์ส่วนหัวของกล่องโต้ตอบ mydialog.h ดังนี้:

ทุกปีจะมีระบบปฏิบัติการเพิ่มมากขึ้นเรื่อยๆ ดังนั้นนักพัฒนาจึงยากขึ้นเรื่อยๆ ในการตอบสนองความต้องการของผู้ใช้ แพลตฟอร์มคอมพิวเตอร์ยอดนิยมสามแพลตฟอร์ม ได้แก่ Windows, Linux และ Mac OS รวมถึงแพลตฟอร์มมือถือสามแพลตฟอร์ม ได้แก่ Android, iOS และ Windows Mobile ยังคงต่อสู้กันอย่างแข็งขันกันเอง ซึ่งหมายความว่าแอปพลิเคชันคุณภาพสูงจะต้องทำงานบนแพลตฟอร์มหลักทั้งหมด

การพัฒนาข้ามแพลตฟอร์มช่วยในการรับมือกับปัญหานี้ หนึ่งในสภาพแวดล้อมการพัฒนาข้ามแพลตฟอร์มที่ได้รับความนิยมมากที่สุด - Qt Creator - จะมีการกล่าวถึงในบทความนี้ เราจะดูวิธีการติดตั้งและกำหนดค่า Qt Creator รวมถึงวิธีทำงานใน Qt Creator

Qt Creator คืออะไร

Qt Creator (เมื่อไม่นานมานี้เรียกว่า Greenhouse) เป็นหนึ่งใน IDE ข้ามแพลตฟอร์มที่พบบ่อยที่สุด ข้อดีของมันคือความสะดวก ความเร็วในการทำงาน และยังมีอิสระ เนื่องจากเป็นซอฟต์แวร์โอเพ่นซอร์ส รองรับภาษาเช่น C, C++, QML

โปรแกรมนี้เขียนโดยบริษัทชื่อ Trolltech ซึ่งบรรลุวัตถุประสงค์ในการสร้างสภาพแวดล้อมโดยสมบูรณ์ โดยทำงานร่วมกับเฟรมเวิร์กกราฟิก Qt อินเทอร์เฟซแบบกราฟิกที่สะดวกสบายพร้อมรองรับ Qt Widgets และ QML รวมถึงคอมไพเลอร์ที่รองรับจำนวนมาก ช่วยให้คุณสร้างแอปพลิเคชันข้ามแพลตฟอร์มของคุณเองได้อย่างรวดเร็วและสะดวก

เป้าหมายหลักของ IDE นี้คือเพื่อให้การพัฒนาข้ามแพลตฟอร์มที่เร็วที่สุดโดยใช้เฟรมเวิร์กของตัวเอง ด้วยเหตุนี้ นักพัฒนาจึงมีโอกาสที่ดีเยี่ยมที่จะไม่เขียนแอปพลิเคชันแบบเนทิฟ (เช่น แยกกันสำหรับแต่ละแพลตฟอร์ม) แต่เพื่อสร้างโค้ดทั่วไป และอาจปรับแต่งให้เข้ากับลักษณะของระบบปฏิบัติการที่ใช้ได้

Qt Creator ยังมียูทิลิตี้ Qt Designer ซึ่งช่วยให้คุณปรับแต่งลักษณะที่ปรากฏของหน้าต่างแอปพลิเคชันของคุณโดยการเพิ่มและลากองค์ประกอบ (คล้ายกับ Windows Forms ใน Visual Studio) ระบบบิลด์ที่ใช้คือ qmake, cmake และ autotools

การติดตั้ง Qt Creator

ถึงเวลาดูวิธีการติดตั้ง Qt Creator แล้ว หากนักพัฒนาดูแลและสร้างตัวติดตั้งออฟไลน์สำหรับ Windows แสดงว่าไม่มีฟีเจอร์นี้ใน Linux 32 บิต ดังนั้น ในระหว่างการติดตั้ง คุณอาจจำเป็นต้องมีการเชื่อมต่ออินเทอร์เน็ตที่เสถียร (~20-30 นาที) ขั้นแรก ให้ดาวน์โหลดตัวติดตั้ง:

• ดาวน์โหลด Qt Creator สำหรับ Linux 32 บิต (คลิก " ดูตัวเลือกอื่นๆ").
• ดาวน์โหลด Qt Creator สำหรับ Linux 64 บิต

หลังจากการดาวน์โหลดเสร็จสิ้น ให้ไปที่โฟลเดอร์ที่มีไฟล์ คลิกขวา และเลือก "คุณสมบัติ".

ตอนนี้ไปที่แท็บกัน “สิทธิ”และทำเครื่องหมายในช่อง "อนุญาตให้ไฟล์นี้ทำงานเป็นโปรแกรม".

มาเปิดโปรแกรมกันเถอะ

ตอนนี้เรากด "ต่อไป".

ที่นี่คุณจะต้องเลือกบัญชีที่มีอยู่หรือสร้างบัญชีใหม่ การดำเนินการนี้จำเป็นในการตรวจสอบใบอนุญาต (เชิงพาณิชย์หรือไม่ใช่เชิงพาณิชย์)

คลิก "ต่อไป".

เลือกไดเร็กทอรีที่จะเก็บ Qt สิ่งสำคัญคือต้องไม่มีอักขระซีริลลิกหรือช่องว่างในเส้นทาง!

เมนูนี้ประกอบด้วยส่วนประกอบต่างๆ ตัวอย่างเช่น คุณสามารถเลือกติดตั้งเครื่องมือสำหรับการพัฒนาบน Android หรือส่วนประกอบต้นทางได้ (ซึ่งจำเป็นสำหรับการประกอบแบบคงที่ หากใครต้องการสิ่งนี้ เขียนในความคิดเห็น แล้วฉันจะเขียนบทความแยกต่างหาก) หากคุณไม่แน่ใจว่าคุณต้องการส่วนประกอบเหล่านี้หรือไม่ ให้ปล่อยไว้เช่นนี้ในตอนนี้ - แม้หลังจากติดตั้ง Qt แล้ว ก็สามารถลบและเพิ่มองค์ประกอบได้

ในหน้าต่างนี้เรายอมรับใบอนุญาต คลิก "ต่อไป".

หากคุณพร้อมแล้ว ให้เริ่มการติดตั้ง คุณจะได้รับแจ้งให้ใส่รหัสผ่าน superuser (sudo) หลังจากนั้นจะเริ่มการดาวน์โหลดและแยกไฟล์ อีกวิธีหนึ่งคือการติดตั้งผ่านเทอร์มินัล ก่อนอื่นคุณต้องอัพเดตรายการแพ็คเกจ

ดาวน์โหลดและติดตั้ง Qt:

sudo apt ติดตั้ง qt5 เป็นค่าเริ่มต้น

ตอนนี้ติดตั้ง Qt Creator:

sudo apt ติดตั้ง qtcreator

และแหล่งที่มาหากจำเป็น

sudo apt ติดตั้งตัวอย่าง qtbase5 ตัวอย่าง qtdeclarative5

การตั้งค่าผู้สร้าง Qt

หลังจากการติดตั้งเสร็จสิ้น ให้รีสตาร์ทคอมพิวเตอร์และเปิด Qt Creator ไปที่เมนู "เครื่องมือ" -> "ตัวเลือก".

มีหลายแท็บที่ต้องพิจารณาที่นี่

1. วันพุธ- นี่คือการปรับแต่งรูปลักษณ์ของ IDE รวมถึงการเปลี่ยนแป้นพิมพ์ลัดและการจัดการยูทิลิตี้ภายนอก

2. โปรแกรมแก้ไขข้อความ- ที่นี่คุณสามารถปรับแต่งลักษณะที่ปรากฏ แบบอักษร และสีของโปรแกรมแก้ไขได้

3. ซี++- การเน้นไวยากรณ์ การทำงานกับนามสกุลไฟล์และ UI (เช่น แบบฟอร์ม)

4.แอนดรอยด์- เส้นทางไปยังเครื่องมือที่จำเป็นจะถูกรวบรวมไว้ที่นี่และกำหนดค่าอุปกรณ์ที่เชื่อมต่อหรือเสมือนในเมนูนี้ด้วย

การติดตั้งส่วนประกอบ Qt Creator

หากจู่ๆ เกิดขึ้นว่าคุณลืมติดตั้งส่วนประกอบ หรือในทางกลับกัน ต้องการลบออก Qt Maintenance Tool จะช่วยคุณได้ นี่คือเครื่องมือที่ช่วยให้คุณจัดการส่วนประกอบทั้งหมดของ Qt Creator

หากต้องการเปิดใช้งาน ให้ไปที่เมนูแอปพลิเคชัน เลือก "การพัฒนา" -> "เครื่องมือบำรุงรักษา Qt".

เลือกตัวเลือกที่ต้องการ (ลบ/เพิ่มส่วนประกอบ อัปเดตส่วนประกอบ หรือลบ Qt) จากนั้นดำเนินการที่จำเป็นและปิดหน้าต่าง

การทำงานกับ Qt Creator - โปรเจ็กต์แรก

ถึงเวลาแล้ว! การติดตั้ง Qt Creator เสร็จสมบูรณ์ ถึงเวลาสร้างแอปพลิเคชันข้ามแพลตฟอร์มครั้งแรกบน Linux แล้วคอมไพล์บน Windows ปล่อยให้มันเป็น... โปรแกรมที่แสดงไอคอน Qt ปุ่ม และคำจารึก ซึ่งวลีสุ่มจะปรากฏขึ้นเมื่อกดปุ่ม โปรเจ็กต์นี้เรียบง่าย และแน่นอน เป็นแบบข้ามแพลตฟอร์ม!

ก่อนอื่น เรามาเปิดสภาพแวดล้อมการพัฒนากันก่อน คลิกกันได้เลย "ไฟล์" -> "สร้างไฟล์หรือโครงการ..."- มาเลือกแอปพลิเคชัน Qt Widgets กัน ซึ่งสร้างได้ง่ายและรวดเร็ว และชื่อของมันคือ "ข้ามแพลตฟอร์ม"- นั่นไง!

ตั้งค่า - ค่าเริ่มต้น เรายังปล่อยให้หน้าต่างหลักไม่เปลี่ยนแปลง มาสร้างโครงการกันเถอะ

ก่อนอื่นคุณต้องกำหนดค่าแบบฟอร์ม - หน้าต่างหลักของแอปพลิเคชัน โดยค่าเริ่มต้นจะว่างเปล่า แต่จะคงอยู่ได้ไม่นาน

ไปที่โฟลเดอร์กันเถอะ "แบบฟอร์ม" -> "mainwindow.ui"- หน้าต่าง Qt Designer จะเปิดขึ้น:

ลบแถบเมนูและแถบเครื่องมือออกจากแบบฟอร์มโดยคลิกขวาและเลือกรายการที่เหมาะสม ตอนนี้ลากองค์ประกอบมุมมองกราฟิก ปุ่มกด และป้ายกำกับดังนี้:

หากต้องการเปลี่ยนข้อความ ให้ดับเบิลคลิกที่องค์ประกอบ ในคุณสมบัติป้ายกำกับ (ทางด้านขวา) ให้เลือกตำแหน่งข้อความในแนวตั้งและแนวนอน - แนวตั้ง

ถึงเวลาหาผลลัพธ์ของไอคอนแล้ว ไปที่ตัวแก้ไขคลิกขวาที่โฟลเดอร์ใดก็ได้ทางด้านซ้ายแล้วเลือก "เพิ่มใหม่..."- ตอนนี้เรากด "Qt" -> "ไฟล์ทรัพยากร Qt"- ชื่อ-นามสกุล ในหน้าต่างที่เปิดขึ้น ให้คลิก "เพิ่ม" -> "เพิ่มคำนำหน้า"และหลังจากเพิ่ม - "เพิ่มไฟล์"- เลือกไฟล์และในหน้าต่างที่ปรากฏขึ้น "ตำแหน่งไฟล์ไม่ถูกต้อง"คลิก "สำเนา".

มันได้ผล! เราบันทึกทุกอย่าง เปิดแบบฟอร์มอีกครั้ง คลิกขวาที่มุมมองกราฟิกแล้วเลือก "styleSheet..." -> "เพิ่มทรัพยากร" -> "ภาพพื้นหลัง"- ในส่วนด้านซ้ายของหน้าต่างที่ปรากฏขึ้น ให้เลือกคำนำหน้า 1 และทางด้านขวา - รูปภาพของเรา คลิก "ตกลง"- ปรับความยาวและความกว้าง

ทั้งหมด! ตอนนี้คุณสามารถเริ่มเขียนโค้ดได้แล้ว การคลิกขวาที่ปุ่มจะเปิดเมนูบริบทตอนนี้คุณต้องคลิก "ไปที่ช่อง..." -> "คลิก()"- ในหน้าต่างเราป้อนรหัสต่อไปนี้:

หรือคุณสามารถดาวน์โหลดโปรเจ็กต์เต็มได้ที่ GitHub การทำงานกับ Qt Creator เสร็จสิ้น ให้คลิกที่ไอคอนลูกศรสีเขียวทางด้านซ้าย และรอให้โปรแกรมเปิดขึ้น (หากลูกศรเป็นสีเทา ให้คลิกที่ไอคอนค้อนก่อน) มันเริ่มต้นแล้ว! ไชโย!

โปรแกรมเมอร์มือใหม่มักจะสงสัยอยู่เสมอว่าเทคโนโลยีใดที่จะเริ่มต้นการเรียนรู้สิ่งนี้หรืออย่างอื่น โปรแกรมเมอร์มือใหม่ควรเรียน Qt หรือไม่? จำเป็นแน่นอน! ตัวอย่างเช่น อ่านโพสต์นี้หรือค้นหาบางอย่างบนอินเทอร์เน็ต ยังไม่แน่ใจว่าคุณต้องการ Qt หรือไม่? หากคุณเขียนด้วยภาษา C++ คุณควรรู้ Qt;

ไปกันเลย...

ตัวอย่างเช่น ลองเขียนเครื่องคิดเลขง่ายๆ โดยบวกตัวเลขสองตัว

เรามาสร้างโครงการใหม่กันเถอะ อย่างที่เราเห็นมีแอปพลิเคชั่นหลายประเภท เราในฐานะผู้เริ่มต้นเลือก "แอปพลิเคชัน Qt Widgets":

เราระบุชื่อของโปรเจ็กต์และโฟลเดอร์ที่จะวางไฟล์สำหรับฉัน: C:\projects\qt

Qt จะสร้างไฟล์ต่อไปนี้โดยอัตโนมัติ:

• Lesson1.pro - ไฟล์โครงการ
• main.cpp - ไฟล์หลักพร้อมฟังก์ชัน main()
• mainwindow.cpp - ซอร์สโค้ดของหน้าต่างหลัก
• mainwindow.h - ไฟล์ส่วนหัวของหน้าต่างหลัก
• mainwindow.ui - ไฟล์ฟอร์มหน้าต่างหลัก

คลิกปุ่ม "เสร็จสิ้น" - ตัวแก้ไขสำหรับการพัฒนาโปรแกรมใน Qt จะเปิดขึ้น

สำหรับตอนนี้ ทุกอย่างควรจะชัดเจนสำหรับนักพัฒนา Qt มือใหม่...

เปิดแบบฟอร์มหลัก (โดยไปที่ mainwindow.ui)

ด้านซ้ายคือส่วนประกอบสำหรับสร้างแบบฟอร์มหน้าจอ ด้านขวาคือแบบฟอร์มเอง ว่างเปล่า มาเพิ่มส่วนประกอบที่จำเป็นกัน และอย่าลืมตั้งชื่อฟิลด์อินพุต QLineEdit ดังนี้: edtA, edtB และ edtC ตามลำดับ

เราเห็นช่องป้อนข้อมูลบนหน้าจอ คำบรรยายทางด้านซ้าย และปุ่ม "A + B =" เมื่อเราคลิกที่ปุ่มนี้ เราจะต้องเพิ่ม A และ B และวางผลลัพธ์ไว้ใน C

ฉันควรทำอย่างไร? นักพัฒนา Qt มือใหม่จะถือว่าคุณต้องแนบตัวจัดการการคลิกปุ่มเข้ากับปุ่ม และเขาจะพูดถูก! ในกรอบอื่น ๆ ก็มีสิ่งเช่น เหตุการณ์- แต่ Qt ตัดสินใจที่จะอวดและสร้างสัญญาณ/ช่องขึ้นมา แม้ว่าโดยพื้นฐานแล้วนี่เป็นสิ่งเดียวกันในทางปฏิบัติ

คลิกขวาที่ปุ่ม "A + B =" เมนูป๊อปอัปจะเปิดขึ้น:

คลิกที่ "ไปที่สล็อต"

เลือกสัญญาณ clicked() และในตัวแก้ไขโค้ดที่เปิดขึ้น ให้เขียนโค้ดขนาดเล็กใน Qt:

Void MainWindow::on_btnOK_clicked() ( int a = ui->edtA->text().toInt(); // นำข้อความ edtA และแปลงเป็นตัวเลข a int b = ui->edtB->text() .toInt (); // นำข้อความ edtB มาแปลงเป็นตัวเลข b int c = a + b; // เพิ่มตัวเลข QString s = QString::number(c); // แปลงผลลัพธ์เป็นสตริง ui ->edtC->setText (s); // พิมพ์ผลลัพธ์ใน edtC )

ฟังก์ชันการประมวลผลสัญญาณ clicked() เรียกว่าสล็อต on_btnOK_clicked()