Qt Creator-ის ინსტალაცია და კონფიგურაცია. რატომ მიყვარს Qt და თქვენ ყველას უნდა გიყვარდეთ ის Qt პროგრამირება დამწყებთათვის

08.09.2024

მარტივი მაგალითი ხელით შეკრებისთვის

Qt-ის უკეთ გასაგებად, სწორი იქნებოდა კონსოლში მაინც მარტივი მაგალითის ხელით აშენება. შეკრების ტექნიკა იგივეა ნებისმიერი ზომის პროექტებისთვის და მნიშვნელოვანია იმის გაგება, თუ როგორ კეთდება ეს.

მოდით შევხედოთ GUI აპლიკაციის მარტივ მაგალითს, რომელიც ხსნის ცარიელ ფანჯარას ეკრანზე. აირჩიეთ დირექტორია დისკზე, სადაც ჩვენ შევქმნით ფაილს მთავარი.cppშემდეგი შინაარსით. მაგალითს დაემატა ხაზების ნუმერაცია მაგალითზე შემდგომი კომენტარების გასამარტივებლად. უნდა გვესმოდეს, რომ სტრიქონის ნუმერაცია არ უნდა იყოს ჩართული სამუშაო ფაილში, რადგან ის არ არის სწორი C++ გამოხატვის სინტაქსის ნაწილი.

01. #შეიცავს 02. #შეიცავს 03. 04. int main(int argc, char *argv) 05. ( 06. QApplication app(argc, argv); 07. QWidget wgt; 08. wgt.setWindowTitle(tr("Hello world")); 09. 10 .wgt.show();

01 და 02 სტრიქონები მოიცავს სათაურის ფაილებს QApplicationდა QWidget, რომელიც, სხვა საკითხებთან ერთად, შეიცავს კლასის დეკლარაციებს QApplicationდა QWidget. ჩვენს მაგალითში ჩვენ ვქმნით ამ კლასების მაგალითებს.

აღსანიშნავია Qt-ში გამოყენებული სათაურის ფაილების დასახელების მოსახერხებელი ტრადიცია. Qt-ის მე-4 ვერსიიდან, თუ დაგჭირდათ დასახელებული კლასი Qxxx, მაშინ, სავარაუდოდ, მისი განმარტება არის სათაურის ფაილში Qxxx.

ამ მაგალითში კლასი QApplicationგვაინტერესებს, როგორც შეტყობინებების შეგროვების ციკლის ორგანიზატორი, რომელიც მოვა ჩვენი GUI აპლიკაციის ფანჯარაში. იხილეთ ხაზი 11 (ფანჯრის შეტყობინების მარყუჟის დაწყება). კლასი QApplicationგანხორციელებული სინგლტონის მსგავსებით. მათთვის, ვინც არ იცნობს ამ ტერმინს დიზაინის ნიმუშების თეორიიდან (ან შაბლონები, ინგლისურიდან. ნიმუშები) ცოტა ახსნა მოგცეთ. სინგლიტონის არსი არის ის, რომ კლასის განხორციელება ხელს უშლის მოცემული კლასის ერთზე მეტი ინსტანციის შექმნის შესაძლებლობას. ეს ფუნქცია ჩვენთვის მნიშვნელოვანია, რადგან ის გულისხმობს Qt ბიბლიოთეკის შიგნით გლობალური ცვლადის განსაზღვრის შესაძლებლობას მოცემული კლასის ერთი ეგზემპლარის მითითებით. იხილეთ აღწერილობა სიმბოლოსთვის qApp Qt დახმარებაში.

Qt ბიბლიოთეკა იყენებს ვიჯეტის ტერმინოლოგიას. ვიჯეტი- კონტრაქცია, მოწყობილობა) როგორც GUI ინტერფეისის ელემენტი. ასეთი ელემენტების თვისებების მინიმალური საერთო ნაკრები წარმოდგენილია კლასით QWidget.

06 და 07 ხაზები ქმნის აპლიკაციისა და ვიჯეტის კლასის ობიექტებს. ორივე შემთხვევაში ობიექტები იქმნება სტატიკურად. ასეთი ობიექტების სიცოცხლის ხანგრძლივობა შემოიფარგლება განცხადების ბლოკით (...), რომელშიც ისინი შეიქმნა. როგორც კი პროგრამის კოდის შესრულება მიაღწევს დახურვის ფრჩხილს, ორივე ეს ობიექტი ავტომატურად ნადგურდება. ამრიგად, ამ მაგალითში ჩვენ არ ვიფიქრებთ იმაზე, თუ როგორ გავანადგუროთ Qt ობიექტები და მოგვიანებით განვიხილავთ ამ საკითხს.

ობიექტის შექმნისას QApplicationგამოიყენება პარამეტრიზებული კონსტრუქტორი, რომელსაც გადაეცემა აპლიკაციის გაშვების არგუმენტები (კოპირებულია main() ფუნქციის არგუმენტებიდან). კლასის ობიექტის შიგნით ეს არგუმენტები გაანალიზებულია. აპლიკაციის კლასი მხარს უჭერს გაშვების რამდენიმე პარამეტრს, რომლებიც შეგიძლიათ იხილოთ შესაბამისი კონსტრუქტორის დახმარებაში QApplication. გაშვების პარამეტრები, რომლებიც არ შედის ამ სიაში, დამოუკიდებლად უნდა გაანალიზდეს. ამ გაკვეთილის ბოლოს, აპლიკაციის მთავარ ფანჯარაში რამდენიმე კონტროლის განთავსებით, ჩვენ შემოგთავაზებთ ექსპერიმენტებს -style გაშვების პარამეტრზე, რისთვისაც ნებისმიერ Qt კონსტრუქციაში შესაძლებელია შემდეგი მნიშვნელობები: მოტივი, ფანჯრები, პლატინის.

ხაზი 08 ცვლის ვიჯეტის ობიექტის ერთ-ერთ ატრიბუტს. setWindowTitle() მეთოდის გამოყენებით, ჩვენ დავაყენეთ საკუთარი ტექსტი ჩვენი მომავალი ფანჯრის სათაურისთვის. გაითვალისწინეთ, რომ სიმებიანი სურათი შეფუთულია ტრანსლაციის ფუნქციის გამოძახებით tr(). ეს არის განაცხადის ინტერნაციონალიზაციის მოთხოვნა. ყველა ასეთი შეფუთვისთვის, სპეციალური Qt ხელსაწყოები შეიძლება გამოყენებულ იქნას სპეციალური ფაილების შესაქმნელად სხვადასხვა ენაზე თარგმნით, რომლებიც შეიძლება გამოყენებულ იქნას აპლიკაციაში ავტომატური ჩანაცვლების შესასრულებლად. როგორც წესი, ასეთი ფაილები შედის აპლიკაციის მშენებლობაში, როგორც რესურსები.

ხაზი 10 ხსნის განაცხადის ფანჯარას. Qt4-მდე, ფანჯრის გახსნამდე, ვიჯეტი აშკარად იყო გამოცხადებული აპლიკაციის მთავარ ვიჯეტად. ეს გაკეთდა შემდეგი კოდის გამოყენებით.

App.setMainWidget(&wgt);

Qt4-დან დაწყებული, ასეთი კომუნიკაცია ხდება ავტომატურად გლობალურ მაჩვენებელზე წვდომით qAppგანაცხადის კლასის მაგალითზე.

ხაზი 11 იწყებს ოპერაციული სისტემის შეტყობინებების დამუშავების ციკლს, რომელიც მიმართულია განაცხადის ფანჯარაში. მარყუჟი მთავრდება, როდესაც აპლიკაციის დახურვის რომელიმე ბრძანება შესრულდება. განაცხადის გასასვლელი კოდი ბრუნდება exec()-ით, როდესაც მეთოდი გადის. სწორედ ეს კოდი ხდება main() ფუნქციის დაბრუნების კოდი ოპერატორის გავლით დაბრუნება.

ახლა ვცადოთ აპლიკაციის შექმნა. ამის გაკეთების ყველაზე მარტივი გზა Linux-ზეა. ამისათვის თქვენ უბრალოდ უნდა გახსნათ კონსოლი და გაუშვათ რამდენიმე ბრძანება, რომელსაც ახლა აღვწერთ. Windows-ისთვის, ასეთმა სამუშაომ შეიძლება მოითხოვოს ბილიკების დაყენება დირექტორიაში, სადაც მდებარეობს qmake პროგრამა Qt SDK-დან. ეს პროგრამა ახორციელებს QMake პროექტის აშენების სისტემის წესებს.

ჯერ უნდა გავარკვიოთ, რა არის ჩვენთვის ხელმისაწვდომი კონსოლიდან. თუ ჩვენ ვართ bash (*nix) კონსოლში, მაშინ ეს საკმაოდ მარტივია. ჩაწერეთ ბრძანება qmakeდა ორჯერ დააჭირეთ tab. ჩვენ უნდა ვნახოთ ყველა ბრძანების სია, რომელიც იწყება კომბინაციით qmake. მაგალითად, ჩემს შემთხვევაში მე ვხედავ ორ ბრძანებას: qmakeდა qmake-qt4. ეს ნიშნავს, რომ მე მაქვს ბიბლიოთეკის ორი ვერსია დაინსტალირებული საცავიდან. გუნდი qmakeშეესაბამება Qt5 ვერსიას (ნაგულისხმევი უახლესი ვერსიისთვის) და ბრძანებას qmake-qt4შესაბამისად შეესაბამება Qt4. ახლა, იმისდა მიხედვით, თუ რომელ ბრძანებას ვიყენებ, ან ავაშენებ Qt5 ვერსიით ან Qt4 ვერსიით.

თუ ჩვენს სისტემაში ყველაფერი ნორმალურად არის კონფიგურირებული და Qt SDK ვერსიები წარმატებულია, მაშინ პროექტი უნდა აშენდეს შემდეგი სამი ბრძანების გამოყენებით.

$ qmake -პროექტი $ qmake $ make

პირველი ბრძანება შექმნის პროექტის ფაილს. პროექტის ფაილს აქვს სუფიქსი .პრო. ვინდოუსის კონტექსტში სწორი იქნება ვთქვათ „გაფართოება პროცნებები ფაილის სახელის სუფიქსიდა ფაილის გაფართოებანიშნავს სრულიად განსხვავებულ ნივთებს, თუმცა ისინი მსგავსია. დარწმუნდით, რომ გამოიყენეთ იგი სწორად.

მეორე ბრძანებამ უნდა შექმნას კომპილაციის სკრიპტის ფაილი - Makefile. მესამე ბრძანებამ უნდა აწარმოოს კომპილაციის სკრიპტი, რომელიც უნდა აწარმოოს შესრულებადი აპლიკაციის ფაილი.

თუ ეს არ მოხდა, მაშინ ჩვენ შევეცდებით პრობლემის პოვნას.

გახსენით პროექტის ფაილი. შეეცადეთ იპოვოთ შემდეგი ხაზი იქ.

QT += gui

თუ ასეთი ხაზი არ არის, მაშინ უნდა დაამატოთ იგი, წინააღმდეგ შემთხვევაში, SDK ვერსიიდან გამომდინარე, პროექტი შეიძლება აღიქმებოდეს როგორც კონსოლის პროექტი და GUI კლასის სათაურის ფაილების ბილიკები მასში არ იქნება ჩართული. ეს გამოიწვევს კომპილაციის შეცდომებს იმის შესახებ, რომ სათაურის ფაილები ვერ მოიძებნა.

გაითვალისწინეთ, რომ თუ საქმე გაქვთ Qt SDK 5 ვერსიასთან, მაშინ ეს განმარტება ასევე უნდა შეიცავდეს ჯგუფს ვიჯეტებიროგორც ნაჩვენებია ქვემოთ.

QT += gui ვიჯეტები

QtCreator-ისგან GUI აპლიკაციის შაბლონის შექმნის მაგალითი

გახსენით QtCreator. ახალი პროექტის შესაქმნელად გაუშვით პროექტის შექმნის ოსტატი მენიუდან "ფაილი-> ახალი ფაილი ან პროექტი...". ფანჯარაში, რომელიც იხსნება ოსტატის პირველ გვერდზე, მოგეთხოვებათ აირჩიოთ შაბლონი მომავალი პროექტისთვის. "Application" პროექტის ჯგუფისთვის აირჩიეთ "Qt GUI Application" ვარიანტი და დააწკაპუნეთ ღილაკზე "არჩევა" ოსტატის შემდეგ გვერდზე გადასასვლელად.

პროექტის შექმნის ოსტატის მეორე გვერდზე თქვენ მოგეთხოვებათ აირჩიოთ პროექტის სახელი და მისი მდებარეობის დირექტორია. მითითებული პროექტის სახელის გამოყენებით შეიქმნება ქვედირექტორია, რომელშიც განთავსდება პროექტის ფაილები. ქვედირექტორი შეიქმნება მითითებულ განთავსების დირექტორიაში. ამრიგად, პროექტის სახელი უნდა განისაზღვროს იმ წესებით, რომლებსაც დირექტორის სახელი უნდა დაემორჩილოს. თუმცა, პრობლემების თავიდან ასაცილებლად, არ გამოიყენოთ რუსული ასოები და ინტერვალი. გამოიყენეთ ინგლისური ასოები, რიცხვები და ხაზები და ტირეები (მინუს ნიშანი). დაე, ჩვენი პროექტი ეწოდოს აპლიკაცია 1. დავწეროთ სტრიქონში სახელი, ხოლო პროექტის დირექტორიას შერჩევის ხაზში მივუთითებთ დირექტორიას, სადაც გავაგრძელებთ პროექტების შექმნას Qt-ზე. თავიდან უნდა იქნას აცილებული რუსული ასოებითა და ინტერვალით ბილიკები. ადრე თუ გვიან მათ შეიძლება პრობლემები შეუქმნან. თუ დაგჭირდებათ ამ ბილიკის დამახსოვრება მომდევნო ჯერზე, მონიშნეთ ჩამრთველი „გამოიყენე როგორც ნაგულისხმევი პროექტის ადგილმდებარეობა“. დააჭირეთ ღილაკს "შემდეგი" ოსტატის შემდეგ გვერდზე გადასასვლელად.

პროექტის შექმნის ოსტატის მესამე გვერდზე თქვენ მოგეთხოვებათ აირჩიოთ Qt SDK QtCreator-ში ნაპოვნი და დარეგისტრირებული სიიდან. აირჩიეთ Qt4 ვარიანტი. არჩეული SDK ვერსიისთვის, თქვენ უნდა განსაზღვროთ პროექტის აშენების პროფილები. შემოთავაზებულია "გამოშვება" და "გამართვა" კონსტრუქცია "გამოშვება" არ შეიცავს გამართვის სიმბოლოებს შესრულებად ფაილში და რეკომენდირებულია რეალურ გამოყენებაში გადასატანად. ყველა სხვა შემთხვევაში უფრო მოსახერხებელია "Debug" build-ის გამოყენება. მიმდინარე მაგალითში, შეკრების არჩევანს მნიშვნელობა არ აქვს. შეგიძლიათ ორივე პროფილი ჩართული დატოვოთ. პროფილის სახელის მარჯვნივ არის შეყვანის ველი, რომელშიც ჩაწერილია ბილიკი, რომლის გასწვრივ შესრულდება შესაბამისი შეკრება. ხშირად ეს ბილიკები რედაქტირდება სხვადასხვა ტრადიციების საფუძველზე. ჩვენს მაგალითში შეგვიძლია ეს ბილიკები უცვლელად დავტოვოთ. დააჭირეთ ღილაკს "შემდეგი" ოსტატის შემდეგ გვერდზე გადასასვლელად.

პროექტის შექმნის ოსტატის მეოთხე გვერდზე თქვენ მოგეთხოვებათ აირჩიოთ კლასის სახელი პროექტის ძირითადი ფორმისთვის, საბაზისო კლასი, საიდანაც უნდა იყოს მემკვიდრეობით მიღებული პროექტის მთავარი ფორმა და ფაილების სახელები, სადაც ინტერფეისი. და განთავსდება ძირითადი ფორმის შექმნილი კლასის განხორციელება. გარდა ამისა, გვერდზე უნდა იყოს მითითებული, გამოყენებული იქნება თუ არა ვიზუალური ფორმის დიზაინი. ვინაიდან ჩვენ არ გამოვიყენებთ ვიზუალურ დიზაინს, უნდა დავრწმუნდეთ, რომ „ფორმის გენერირება“ მონიშნული არ არის.

New Project Wizard-ის მეოთხე გვერდზე ყველაზე საინტერესოა საბაზისო კლასის არჩევა ფორმის კლასის შესაქმნელად. შემოთავაზებულია სამი ვარიანტი.

QMainWindow- უმეტეს შემთხვევაში, ყველაზე შესაფერისი არჩევანი. ამ კლასიდან მემკვიდრეობით ვიღებთ მზა ინსტრუმენტებს მენიუს, სტატუსის ზოლისა და ცენტრალური ველის განთავსებისთვის, რომელიც შეიძლება განხორციელდეს როგორც SDI (Single Document Interface) სტილში, ასევე MDI (Multi Document Interface) სტილში.
QWidget— ეს კლასი უმარტივესი ვიჯეტია. Qt ტერმინოლოგიაში, ეს არის უმარტივესი ელემენტი, რომელთანაც დაკავშირებულია ეკრანზე რაიმე სახის გრაფიკული არე. როგორც ძირითადი ფანჯრის საბაზო კლასი, იგი გამოიყენება, როგორც წესი, მარტივი ერთფორმიანი აპლიკაციების შექმნისას და შესანიშნავია საწყისი „სტუდენტური“ მიზნებისთვის, იმის გამო, რომ ის არ შეიცავს არაფერს „ზედმეტს“.
QDialog- საბაზისო კლასი მოდალური დიალოგური ფანჯრების შესაქმნელად.

ჩვენი მაგალითისთვის ჩვენ ავირჩევთ საბაზისო კლასად, უმარტივესი ვარიანტია QWidget. ფორმის ძირითადი კლასის და იმ ფაილების სახელები, სადაც განთავსდება მისი ინტერფეისი და განხორციელება, შეიძლება დარჩეს ნაგულისხმევ მნიშვნელობებად. დააჭირეთ ღილაკს "შემდეგი" ოსტატის შემდეგ გვერდზე გადასასვლელად.

პროექტის შექმნის ოსტატის მეხუთე გვერდი საშუალებას გაძლევთ განსაზღვროთ შექმნილი პროექტის ურთიერთობა უკვე ღია პროექტებთან და მიუთითოთ ნებისმიერი ხელმისაწვდომი პროექტის ვერსიის კონტროლის სისტემის არჩევანი. მიმდინარე მაგალითში ჩვენ არ გვაინტერესებს ეს ფუნქციები, ამიტომ ჩვენ უნდა დავასრულოთ ოსტატი ღილაკზე "დასრულება" დაწკაპუნებით.

პროექტის შექმნის ნაბიჯები შეიძლება ოდნავ განსხვავდებოდეს QtCreator-ის სხვადასხვა ვერსიაში, მაგრამ არსებითად, აქ არის ძირითადი პუნქტები, რომლებიც უნდა გესმოდეთ GUI პროექტის შექმნისას. მიმდინარე აღწერა გაკეთდა QtCreator ვერსიის 2.7.0 საფუძველზე.

QtCreator-ში New Project Wizard-ის დასრულების შემდეგ გაიხსნება ხედი შექმნილი პროექტით. გაუშვით პროექტი თქვენი განვითარების გარემოს პარამეტრების შესამოწმებლად. თუ ყველაფერი რიგზეა, მაშინ შექმნილი პროექტის შაბლონი უნდა შედგეს და გაუშვას. პროექტის ნორმალურად დასაწყებად, შეგიძლიათ დააჭიროთ ღილაკს მწვანე სამკუთხედით, რომელიც მდებარეობს ინსტრუმენტთა პანელზე. ღილაკი მწვანე სამკუთხედის გამოსახულებით ხოჭოსთან ერთად ასრულებს გამართვის რეჟიმის გაშვების ფუნქციებს. ამ შემთხვევაში, თუ პროექტში დაყენებულია წყვეტის წერტილები, მაშინ როდესაც ისინი მიიღწევა, გაშვებული აპლიკაციის შესრულება შეჩერდება და ხაზი, რომელზეც მოხდა შესვენება, მონიშნული იქნება გამართვის რედაქტორში.

QtCreator შესამჩნევად განსხვავდება დიზაინით სხვა განვითარების გარემოსგან. თუმცა მისი დიზაინი საოცრად ერგონომიულია. სხვა საკითხებთან ერთად, ფართო ეკრანების ეპოქაში, განვითარების გარემოს მთავარ ფანჯარაში მარცხნივ განთავსებული ხელსაწყოების პანელი ძალიან მომგებიანი გამოიყურება. ინსტრუმენტთა პანელის ბოლოში, როგორც უკვე აღვნიშნეთ, არის აპლიკაციის გაშვების ღილაკები, ხოლო ზევით არის ღილაკები განვითარების გარემოს მთავარი ფანჯრისთვის ჩანართების არჩევისთვის. მოდით შევხედოთ ძირითადი ჩანართების ჩამონათვალს.

"მოგესალმებით" - პროექტის შერჩევა
"რედაქტირება" - პროგრამის რედაქტირება.
„გამართვა“ - პროექტის გამართვა. მოყვება ობიექტების მონიტორინგისთვის საჭირო ფანჯრები.
„პროექტები“ — განვითარების გარემოში ჩატვირთული პროექტების პარამეტრები. თქვენ უნდა ყურადღებით შეისწავლოთ ამ ჩანართზე წარმოდგენილი ვარიანტები.
"Analyze" - პროექტების ანალიზი სპეციალური ხელსაწყოების გამოყენებით შესრულების შეფერხებებისა და მეხსიერების გაჟონვის პრობლემების გამოსავლენად.
"დახმარება" ინტეგრირებული დახმარების ფანჯარა. შეიძლება გირჩევნიათ მუშაობა დამოუკიდებელ დახმარების აპლიკაციასთან, QtAssistant.

აპლიკაციის ფანჯარაში ვიჯეტების განთავსების მარტივი მაგალითი

ავიღოთ პროექტი, რომელიც შევქმენით წინა განყოფილებაში QtCreator განვითარების გარემოს ოსტატის გამოყენებით. შექმნილი პროექტი მოიცავს შემდეგ ფაილებს.

app1.pro- პროექტის ფაილი
მთავარი.cppვიჯეტი.თ და ვიჯეტი.cpp./li>
ვიჯეტი.თ- ძირითადი პროგრამის ფანჯრის კლასის ინტერფეისი.
ვიჯეტი.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. 13. QLabel * plb = new QLabel(tr("Test"), this * ple = new QLineEdit(this); , 80, 24); ~ვიჯეტი() 24. ( 25. 26. )

სტრიქონები 01-03 მოიცავს ფაილებს ინტერფეისით შემდეგი ვიჯეტის კლასებისთვის.

QLabel- ეტიკეტის კლასი. ხშირად გამოიყენება სტატიკური ტექსტური ინფორმაციის განთავსებისთვის. ესმის ზოგიერთი HTML ტეგი ფორმატირებისთვის. შეიძლება გამოყენებულ იქნას სურათის სტატიკურად დასაყენებლად. მაგალითად, ფაილიდან სურათით. მემკვიდრეობით მიღებული QFrame, ასე რომ, მისი მორგება შესაძლებელია სხვადასხვა ზღურბლზე (საზღვრებზე).
QLineEdit— კლასი ერთსტრიქონიანი ტექსტური ინფორმაციის შეყვანის ველების შესაქმნელად.
QPushButton- ღილაკების კლასი. ყველაზე ხშირად გამოიყენება სიგნალის დამუშავებისთვის დააწკაპუნეთ ()- დააჭირეთ ღილაკს.

კლასის კონსტრუქტორი კორპუსი ვიჯეტიშეიცავს ორ ხაზს ფანჯრის ატრიბუტების დასაყენებლად (ხაზები 10-11) და 8 სტრიქონი ფანჯრის ველზე სამი სხვა ვიჯეტის შესაქმნელად და განთავსებისთვის (ხაზები 13-20).

ფანჯრის ატრიბუტების დაყენება შედგება განაცხადის ფანჯრის სახელისა და აპლიკაციის ფანჯრის მინიმალური ზომის დაყენების ბრძანებისგან. მინიმალური ზომის დასაყენებლად გამოიყენება მეთოდი, რომელიც იღებს ფანჯრის სიგანეს და სიმაღლეს პიქსელებში.

ხაზი 13 შეიცავს QLabel კლასის ინსტანციის შექმნას. ობიექტი იქმნება დინამიურად ახალი ოპერატორის გამოყენებით. ობიექტის შესაქმნელად გამოიყენება კონსტრუქტორი, რომლის პირველი პარამეტრი განსაზღვრავს სტრიქონს, რომელსაც შექმნილი ობიექტი უნდა წარმოადგენდეს. ამ კონსტრუქტორის მეორე პარამეტრში უნდა იყოს მითითებული ობიექტის მისამართი, რომელიც გახდება შექმნილი ლეიბლის ობიექტის მფლობელი. მფლობელის მისამართი დაყენებულია ეს. C++ ენის წესების მიხედვით, ესარის მაჩვენებელი ობიექტის, რომლის ფარგლებშიც იგი გამოიყენება. ანუ ამ კონტექსტში ის არის კლასის შექმნილი ინსტანციის მაჩვენებელი ვიჯეტი. ამრიგად, მე-13 სტრიქონი ქმნის ლეიბლის კლასის ობიექტს, რომელიც უნდა წარმოადგენდეს მითითებულ ტექსტს და რომლის მფლობელიც მინიჭებულია მიმდინარე ობიექტზე.

აქ დროა ვისაუბროთ საკუთრების ჯაჭვებზე, რომლებიც დანერგილია Qt კლასის სისტემაში ობიექტების განადგურების პრობლემის გადასაჭრელად მეხსიერების შემთხვევითი გაჟონვის თავიდან ასაცილებლად. უნდა გვახსოვდეს, რომ დინამიურად შექმნილი ობიექტები, ე.ი. ოპერატორის გამოყენებით ახალი, განლაგებულია მეხსიერების სპეციალურ ზონაში ე.წ გროვადა რომლებიც ცხოვრობენ გროვაზე, სანამ ოპერატორის მიერ აშკარად არ განადგურდებიან წაშლა. თუ პროგრამისტი არ აკონტროლებს ობიექტების განადგურებას, რომლებიც არასაჭირო გახდა და არ მოუწოდებს ოპერატორს მათი განადგურებისთვის წაშლა, მაშინ ეს ხდება აპლიკაციაში მეხსიერების გაჟონვის მიზეზი, რაც სერიოზულ პრობლემას წარმოადგენს რიგი პროგრამირების ენებისთვის, რომლებიც მოიცავს C++ ენას.

არსებობს რამდენიმე ცნობილი სქემა დინამიურად შექმნილი ობიექტების განადგურების ავტომატურად თვალყურის დევნებისთვის. ერთ-ერთი მათგანია ჭკვიანი პოინტერების გამოყენება, რაც შემდგომში უნდა განიხილებოდეს. კიდევ ერთი გზაა საკუთრების ჯაჭვების შექმნა, რაზეც ახლა განვიხილავთ. მესამე გზა არის ნაგვის შეგროვების ქვესისტემის შექმნა, რომელიც უნდა აკონტროლებდეს არასაჭირო ობიექტებს და გაანადგუროს ისინი. ეს უკანასკნელი მეთოდი, ტრადიციული მრავალი თანამედროვე ენის ბირთვისთვის, პრაქტიკულად არ გამოიყენება C++-ში. პირველი ორი მეთოდი ბევრად უფრო პოპულარულია C++ ენის ტრადიციებში.

ასე რომ, საკუთრების ჯაჭვები ახორციელებენ შემდეგ მარტივ იდეას. იქმნება ობიექტი, რომლის განადგურების მონიტორინგს ჩვენ ვიღებთ ვალდებულებას. უმარტივესი გზაა ასეთი ობიექტის შექმნა სტატიკური განსაზღვრებით და შემდეგ ის ავტომატურად განადგურდება, როდესაც პროგრამის შესრულება მიაღწევს განცხადების ბლოკის ბოლოს (...), რომელშიც ის იყო განსაზღვრული. შემდეგი, სხვა ობიექტების დინამიურად შექმნისას, ჩვენ მივანიჭებთ მათ მფლობელის ობიექტებს. მფლობელების პასუხისმგებლობა მოიცავს საკუთრებაში არსებული ობიექტების განადგურებას საკუთარი დესტრუქტორის სხეულში. შეგახსენებთ, რომ დესტრუქტორი არის სპეციალური მეთოდი, რომელსაც ეწოდება ობიექტის განადგურების დროს. ამრიგად, შესაძლებელია პირველი ობიექტის მიმართ ისეთი საკუთრების ჯაჭვის აგება, რომლის ყველა ელემენტი ავტომატურად განადგურდება პირველი ობიექტის განადგურებისას. ასეთი სქემის ორგანიზებისას საჭიროა მხოლოდ სწორად გაითვალისწინოთ ობიექტის სიცოცხლის ხანგრძლივობა, რომელიც დანიშნულია სხვა ობიექტის მფლობელად, რათა ობიექტები ნაადრევად არ განადგურდეს.

ეს არის ზუსტად Qt კლასის სისტემაში დანერგილი საკუთრების სქემა. ამ ბიბლიოთეკიდან მრავალი კლასის შექმნისას, შეგიძლიათ გამოიყენოთ კონსტრუქტორი, რომლის ერთადერთი ან ბოლო პარამეტრი აღებს მაჩვენებელს ობიექტზე, რომელიც მინიჭებულია როგორც შექმნილი ობიექტის მფლობელი. ეს პარამეტრი აღწერილია, როგორც პარამეტრი ნაგულისხმევი მნიშვნელობით, რომელიც განისაზღვრება როგორც ნული. ამრიგად, თუ მფლობელის მისამართი არ არის მითითებული, მაშინ პარამეტრი დაყენებულია ნულზე და ასეთი ობიექტის საკუთრების სქემა გამორთულია. ამ შემთხვევაში, თქვენ უნდა გახსოვდეთ ასეთი ობიექტის მკაფიოდ განადგურება.

საკუთრების სქემის სქემების დანერგვისას, ზოგიერთი ბიბლიოთეკა იყენებს პარამეტრს ე.წ მფლობელი, რომელიც ინგლისურიდან ითარგმნება როგორც მფლობელი. თუმცა Qt ბიბლიოთეკაში ამ პარამეტრს ეძახიან მშობელი, რომელიც ინგლისურიდან ითარგმნება როგორც მშობელი. შედეგად, ზოგიერთ ახალბედას გაუგებრობა აქვს იმის გამო, რომ კონცეფცია "მშობელი" ტრადიციულად ეხება მემკვიდრეობით ჯაჭვებს OOP-ში, მაგრამ მემკვიდრეობის ჯაჭვებსა და საკუთრების ჯაჭვებს საერთო არაფერი აქვთ. იყავით ფრთხილად და ნუ გახდებით ამ საკითხში მცდარი წარმოდგენების მსხვერპლი.

კიდევ ერთხელ დავუბრუნდეთ მე-13 სტრიქონს. იქ შევქმენით ობიექტი, რომლის მფლობელი მინიჭებულია აპლიკაციის მთავარი ფანჯრის მიმდინარე ობიექტზე. ცვლადი plb, რომელიც ინახავს შექმნილი ობიექტის მისამართს, ავტომატურად განადგურდება კონსტრუქტორის კოდის დასასრულის მიღწევისას. თუმცა, ობიექტი, რომელიც გამოყოფილი იყო მეხსიერებაში, გააგრძელებს სიცოცხლეს და იცხოვრებს მანამ, სანამ მთავარი აპლიკაციის ფანჯრის ობიექტი არ განადგურდება. მთავარი ფანჯრის ობიექტის განადგურება ავტომატურად გაანადგურებს ყველა ობიექტს, რომელსაც ფანჯრის ობიექტი ფლობს.

მე-14 სტრიქონზე ჩვენ ვწვდებით გეომეტრიის ატრიბუტების დაყენების მეთოდს, რომელიც განსაზღვრავს მორგებული ობიექტის განლაგებას მის მფლობელთან მიმართებაში. პირველი და მეორე მნიშვნელობები მიუთითებს ჰორიზონტალურ და ვერტიკალურ კოორდინატებზე ობიექტის ზედა მარცხენა კუთხისთვის. მესამე და მეოთხე მნიშვნელობები მიუთითებს მორგებული ობიექტის სიგანესა და სიმაღლეზე.

თუ თქვენ დარწმუნდით, რომ წინა განყოფილებაში შექმნილი მაგალითი აწყობილი და შეცდომის გარეშე მუშაობდა, მაშინ ეს მაგალითიც, რომელიც წინას გაფართოებაა, უნდა გაუშვათ.

ამ აპლიკაციის გამოყენებით შეგიძლიათ ექსპერიმენტი გააკეთოთ აპლიკაციის გაშვების ვარიანტებზე. ამის გაკეთების ყველაზე მარტივი გზა კონსოლშია. გადადით აპლიკაციის შექმნის დირექტორიაში და მიჰყევით შემდეგ ვარიანტებს, რომ გაუშვათ აპლიკაცია პარამეტრებით. თითოეულ გაშვებაში უნდა იყოს შესამჩნევი განსხვავება ვიჯეტების დახატვის სტილში.

$ ./app1 -style=მოტივი $ ./app1 -style=windows $ ./app1 -style=პლატინი

ამ მაგალითში განაცხადის შესრულებადი ფაილი მითითებულია სახელით აპლიკაცია 1. შესაძლებელია, რომ თქვენს შემთხვევაში შესრულებად ფაილს სხვა სახელი ჰქონდეს. Windows ოპერაციულ სისტემაში შესრულებად ფაილებს აქვთ გაფართოება exe. გარდა ამისა, Windows ოპერაციულ სისტემაში შეგიძლიათ გაუშვათ შესრულებადი ფაილი მიმდინარე დირექტორიადან შედარებითი ბილიკის მითითების გარეშე, ე.ი. მითითების გარეშე ( ./ ) - წერტილის სიმბოლო არის მიმდინარე დირექტორიას სინონიმი, ხოლო წინ დახრილი სიმბოლო არის გამყოფი სიმბოლო ფაილის ბილიკში. ასევე, გახსოვდეთ, რომ დოლარის სიმბოლო არის სტანდარტული მოთხოვნის სიმბოლო *nix კონსოლში ჩვეულებრივი მომხმარებლისთვის და არ საჭიროებს აკრეფას ბრძანების ნაწილად. Windows-ის კონსოლში მოთხოვნის სიმბოლო ჩვეულებრივ არის კუთხის ფრჩხილის სიმბოლო ( > ).

გაშვების ვარიანტების დაზუსტება ასევე შესაძლებელია QtCreator-ის განვითარების გარემოდან აპლიკაციის გაშვებისას. ამისათვის დააწკაპუნეთ ინსტრუმენტთა მარცხენა პანელზე არსებულ ხატულაზე პროექტები. შესაბამისი პარამეტრების ჩანართი გაიხსნება. ფანჯრის ზედა ნაწილში შეგიძლიათ იხილოთ ჩანართების იერარქიული სისტემა. ზედა დონის ჩანართები განსაზღვრავს პროექტს, რადგან მრავალი პროექტი შეიძლება იყოს გახსნილი განვითარების გარემოში. ჩანართების შემდეგი დონე, სხვა საკითხებთან ერთად, უნდა შეიცავდეს ჩანართს აშენება და გაშვება, რომელიც ჩვენ გვჭირდება. ამ ჩანართში, თქვენ ირჩევთ Qt SDK ვერსიას, იმ შემთხვევაში, თუ თქვენ აშენებთ პროექტს ერთდროულად რამდენიმე ვერსიისთვის. თუ თქვენ აწყობთ პროექტს ერთი ვერსიისთვის, მაშინ არჩევანი შედგება ერთი ელემენტისგან. Qt SDK ვერსიის შერჩევის ვიჯეტის შიგნით არის ორი სტილიზებული ღილაკი მომრგვალებული კიდეებით - ღილაკები აშენებადა გაიქეცი. დააჭირეთ ღილაკს გაიქეციპარამეტრების შესაბამისი ჯგუფის შესარჩევად. იქ, ამავე სახელწოდების პარამეტრულ ჯგუფში გაიქეცითქვენ იპოვით ერთი ხაზის შეყვანის ველს ეტიკეტის საპირისპიროდ არგუმენტები. ეს არის ჩვენი არჩევანის საბოლოო მიზანი. დავწეროთ იქ შემდეგი სტრიქონი.

სტილი=მოტივი

გაუშვით აპლიკაცია. შემდეგ სცადეთ სხვა მნიშვნელობები: ფანჯრებიდა პლატინის. შეგახსენებთ, რომ კლასის ობიექტი QApplicationმხარს უჭერს რამდენიმე ათეული გაშვების პარამეტრის ჩამონათვალს, რომელთა შესახებაც შეგიძლიათ წაიკითხოთ შესაბამისი კლასის კონსტრუქტორების დახმარებაში.

მაგალითზე მუშაობისას გადახედეთ მაგალითში გამოყენებული კლასების საცნობარო ინფორმაციას. სცადეთ ფორმაში დაამატოთ ლეიბლის სხვა ეგზემპლარები, ერთი ხაზის შეყვანის ველი და ღილაკების კლასები. გარდა ამისა, შეეცადეთ წაიკითხოთ დახმარება და დაამატოთ შემდეგი კლასების ობიექტები ფორმაში.

QComboBox- ჩამოსაშლელი სიის კლასი.
QCheckBox— დროშის (ჩეკერის) კლასი.
QTextEdit— მრავალხაზოვანი შეყვანის ველის კლასი. გამოიყენება როგორც ტექსტის რედაქტირებისთვის, ასევე წარმოდგენისთვის. შეიცავს დოკუმენტების წარმოდგენის ძალიან მდიდარ შესაძლებლობებს სპეციალური დოკუმენტების შემქმნელების ფუნქციების ცალკეულ კლასებად გამოყოფით.

გაკვეთილის დასასრულს უნდა აღინიშნოს, რომ ფორმის ველზე ობიექტების „ხისტი“ განთავსების მეთოდი, განლაგების გეომეტრიის აშკარა მითითებით, არ არის ტრადიციული და რეკომენდებულია Qt კლასის ბიბლიოთეკაში. შემდეგი გაკვეთილები განიხილავს განლაგების მენეჯერებს, რომლებიც თანამედროვე და მოსახერხებელი საშუალებებია ვიჯეტების ფორმაზე განთავსებისთვის.

ეს არის მრავალპლატფორმული პროგრამული უზრუნველყოფის განვითარების ინსტრუმენტარიუმი C++ პროგრამირების ენაზე. ასევე არსებობს მრავალი სხვა პროგრამირების ენა: Python - PyQt, Ruby - QtRuby, Java - Qt Jambi, PHP - PHP-Qt და სხვა.
საშუალებას გაძლევთ გაუშვათ მისი დახმარებით დაწერილი პროგრამული უზრუნველყოფა უმეტეს თანამედროვე ოპერაციულ სისტემებზე, პროგრამის უბრალოდ შედგენით თითოეული OS-სთვის, საწყისი კოდის შეცვლის გარეშე. მოიცავს ყველა ძირითად კლასს, რომელიც შეიძლება საჭირო გახდეს აპლიკაციის პროგრამული უზრუნველყოფის შემუშავებისას, დაწყებული გრაფიკული ინტერფეისის ელემენტებიდან ქსელთან მუშაობის კლასებამდე, მონაცემთა ბაზებთან და XML-თან. Qt არის სრულად ობიექტზე ორიენტირებული, ადვილად გაფართოებადი და მხარს უჭერს კომპონენტებზე დაფუძნებულ პროგრამირების ტექნიკას.
ამ სტატიაში მე გაჩვენებთ, თუ როგორ უნდა დაწეროთ მარტივი პროგრამა "Hello, World!". Qt4 ბიბლიოთეკის გამოყენებით

განვითარების გარემო

ჯერ განვსაზღვროთ განვითარების გარემო. პირადად მე ვიყენებ cross-platform IDE Code::Blocks პროგრამის დასაწერად (შეგიძლიათ წაიკითხოთ მეტი Qt4-ით ამ IDE-ში მუშაობის შესახებ). ასევე არის Eclipse-ში Qt-თან მუშაობის დანამატები. Qt-ის კომერციული ვერსია MS Windows-ისთვის შეიძლება ინტეგრირებული იყოს MSVS-ში. პროგრამები ასევე შეიძლება დაიწეროს ნებისმიერ ტექსტურ რედაქტორში და შემდეგ შედგეს ბრძანების ხაზიდან.
სიცხადისთვის, მე გაჩვენებთ, თუ როგორ უნდა შევადგინოთ Qt-ში დაწერილი პროგრამები ხელით.

პირველი პროგრამა

პირველი, შექმენით ფაილი ნებისმიერ ტექსტურ რედაქტორში და დაარქვით მას, მაგალითად main.cpp
მოდით ჩავწეროთ მასში შემდეგი:

#შეიცავს

#შეიცავს

QApplication აპლიკაცია (argc, argv);

QDialog *dialog = new QDialog;

QLabel *label = new QLabel(dialog);

label->setText( "გამარჯობა, მსოფლიო!" );

დიალოგი->ჩვენება();

დააბრუნეთ app.exec();

1 და 2 სტრიქონებში ჩვენ ჩავრთეთ Qt სათაურის ფაილები, რომლებშიც განლაგებულია ძირითადი კლასები.
მე-4 სტრიქონში გამოვაცხადეთ ძირითადი ფუნქცია - მთავარი ფუნქცია, საიდანაც იწყება ნებისმიერი პროგრამის შესრულება. ის აბრუნებს მთელ რიცხვს (პროგრამის შედეგს; 0 - თუ ყველაფერი რიგზეა) და იღებს ორ ცვლადს შეყვანად - ბრძანების ხაზის პარამეტრების რაოდენობას და მასივს, რომელშიც ისინი ინახება.
მე-5 ხაზზე ვქმნით აპლიკაციის ობიექტს. ჩვენ გადავცემთ ბრძანების ხაზის ცვლადებს ამ ობიექტს.
მე-6 სტრიქონზე ვქმნით დიალოგს - მართკუთხა ფორმის გრაფიკულ ფანჯარას სათაურის ზოლით და ღილაკებით ზედა მარჯვენა კუთხეში. შექმენით ლეიბლი (სტრიქონი 7). როდესაც ჩვენ ვქმნით ლეიბლს, ჩვენ გადავცემთ მაჩვენებელს დიალოგში მის კონსტრუქტორს, რომელიც ხდება მისი მშობელი. როდესაც თქვენ წაშლით მშობელს, მისი ყველა შვილი ავტომატურად იშლება, რაც ძალიან მოსახერხებელია. შემდეგ ჩვენ ვაყენებთ ლეიბლის ტექსტს setText() ფუნქციის გამოძახებით (სტრიქონი 8). როგორც მაგალითიდან ხედავთ, ნაჩვენები ტექსტისთვის შეგიძლიათ გამოიყენოთ html ტეგები.
მე-9 სტრიქონზე ჩვენ ვაჩვენებთ ჩვენს ლეიბლის დიალოგს ეკრანზე.
ბოლოს მე-10 სტრიქონზე ვიწყებთ აპლიკაციის ოპერაციული სისტემის მოვლენის ციკლს. ჩვენ ვაბრუნებთ ობიექტის მუშაობის შედეგს პროგრამის შედეგად.

კომპილაცია

ახლა შევადგინოთ დაწერილი პროგრამა.
მოდით გადავიდეთ დირექტორიაში, სადაც შევინახეთ ჩვენი main.cpp ფაილი და გაუშვით ბრძანება

$ qmake -პროექტი

ეს შექმნის Qt4 პროექტის შაბლონს, რომელიც ავტომატურად მოიცავს ამ დირექტორიაში მდებარე ყველა კოდის ფაილს. შედეგი იქნება ფაილი იგივე სახელით, როგორც მიმდინარე დირექტორია და გაფართოება .pro. ეს ასე გამოიყურება:

TEMPLATE=აპი
სამიზნე =
DEPENDPATH += .
INCLUDEPATH += .

#შეყვანა
SOURCES += main.cpp

შედეგად, ჩვენ მივიღებთ Makefile-ს, რომელსაც ვიყენებთ პროგრამის კომპილაციისთვის შემდეგი ბრძანების გაშვებით:

დაველოდოთ კომპილაციის პროცესის დასრულებას და გავუშვათ ჩვენი პირველი პროგრამა. ეს დაახლოებით ასე გამოიყურება:

მეორე პროგრამა

შექმნილ ფანჯრებზე და სხვა ვიჯეტებზე სრული კონტროლის მოსაპოვებლად, თქვენ უნდა შექმნათ მათგან მიღებული კლასები. მოდით შევქმნათ მიღებული კლასი MyDialog. ჩვენ გამოვიყენებთ QDialog კლასს, როგორც მშობელ კლასს. ჩვენ განვათავსებთ ჩვენი კლასის აღწერას სათაურის ფაილში mydialog.h:

#შეიცავს

#შეიცავს

#შეიცავს

#შეიცავს

კლასი MyDialog: საჯარო QDialog (

Q_OBJECT

საჯარო:

MyDialog(QWidget *მშობელი = 0);

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

პირველ ოთხ სტრიქონში ჩვენ შევაქვთ გამოყენებული გრაფიკული ელემენტების საჭირო სათაურის ფაილები - დიალოგი, ღილაკი, ლეიბლი და ვერტიკალური განლაგების მენეჯერი. გამოიყენეთ ისეთი დიდი სათაურის ფაილები, როგორიცაა , მსხვილ პროექტებში არ არის რეკომენდებული, რადგან ეს ზრდის შედგენის დროს.
მეექვსე ხაზზე, ჩვენ განვსაზღვრეთ ჩვენი კლასი QDialog-დან გამომდინარე.
შემდეგ სტრიქონზე ჩვენ დავაზუსტეთ Q_OBJECT მაკრო, რომელიც ეუბნება Qt წინასწარ პროცესორს, რომ ეს კლასი გამოიყენებს დამატებით Qt ფუნქციებს, მაგალითად, სიგნალისა და სლოტის სისტემას.
მე-9 სტრიქონზე ჩვენ ვაზუსტებთ ჩვენი დიალოგური ფანჯრის კონსტრუქტორს. მას აქვს მხოლოდ ერთი შეყვანის პარამეტრი - მაჩვენებელი მშობელი ობიექტისკენ (0 თუ არ არის მშობელი).
ჩვენ განვსაზღვრავთ ჩვენი კლასის კონსტრუქტორს mydialog.cpp ფაილში:

#include "mydialog.h"

MyDialog::MyDialog(QWidget *მშობელი) : QDialog(მშობელი) (

QVBoxLayout *განლაგება = ახალი QVBoxLayout(ეს);

QLabel *label = new QLabel(this);

label->setText( "გამარჯობა, მსოფლიო!" );

QPushButton *button = new QPushButton(this );

button->setText("დახურვა");

განლაგება->addWidget(label);

განლაგება->addWidget(ღილაკი);

connect(ღილაკი, SIGNAL(დააწკაპუნეთ()), ეს , SLOT(close()));

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

მე-4 ხაზზე ჩვენ ვქმნით განლაგების მენეჯერს, რომელიც ავტომატურად აჩვენებს მასში დამატებულ ყველა ვიჯეტს ვერტიკალურად. წარწერის შექმნა წინა მაგალითის მსგავსია.
მე-7 და მე-8 სტრიქონებში ვქმნით ღილაკს და ვაყენებთ მის ტექსტს. მომდევნო ორ სტრიქონზე ვამატებთ ჩვენს ვიჯეტებს განლაგების მენეჯერს ისე, რომ ის ავტომატურად მოაწყობს მათ.
მე-11 სტრიქონზე ჩვენ ვაკავშირებთ ღილაკის დაწკაპუნებულ() სიგნალს ჩვენი დიალოგური ფანჯრის close() სლოტთან. თითოეულ Qt ობიექტს შეიძლება ჰქონდეს საკუთარი სიგნალები და სლოტები, რომლებიც შეიძლება დაკავშირებული იყოს სხვა ობიექტების სიგნალებთან და სლოტებთან და ამით დაუკავშირდეს პროგრამის ელემენტებს.
main.cpp ფაილი ასე გამოიყურება:

#შეიცავს

#include "mydialog.h"

int main(int argc, char * argv) (

QApplication აპლიკაცია (argc, argv);

MyDialog *dialog = ახალი MyDialog;

დიალოგი->ჩვენება();

დააბრუნეთ app.exec();

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

პროექტის გუნდურად აღდგენა

$ qmake -პროექტი

ისე, რომ მას ავტომატურად დაემატება ახალი ფაილები და ვაკომპლექტებთ. ასე გამოიყურება ჩვენი ახალი პროგრამა:

მესამე პროგრამა

თუ დიალოგური ფანჯარა შეიცავს უამრავ გრაფიკულ ელემენტს, მაშინ ასეთი ფანჯრების შექმნა შეიძლება საკმაოდ დამღლელი იყოს. ამ პროცესის გასამარტივებლად, არსებობს ინსტრუმენტი სახელწოდებით Qt Designer. მოდით გავუშვათ იგი

და აირჩიეთ დიალოგური ფანჯრის შექმნა ღილაკების გარეშე. ჩვენ ვამატებთ მას ლეიბლს და ღილაკს და ვასწორებთ მათ ტექსტს. Signal/Slot Editor ხელსაწყოს გამოყენებით ჩვენ ვაკავშირებთ ღილაკის დაწკაპუნებულ() სიგნალს დიალოგური ფანჯრის დახურვის() სლოტთან. ჩვენ ვაწყობთ მათ ვერტიკალურად განლაგების მენეჯერის გამოყენებით. შეინახეთ მიღებული ფაილი სახელით mydialog.ui. მოგვიანებით ის ავტომატურად გარდაიქმნება სათაურის ფაილად სახელად ui_mydialog.h.
ჩვენ ვცვლით ჩვენი დიალოგური ფანჯრის mydialog.h სათაურის ფაილს შემდეგნაირად:

განვითარების გარემო

პირველი პროგრამა

#შეიცავს

#შეიცავს

QApplication აპლიკაცია (argc, argv);

QDialog *dialog = new QDialog;

QLabel *label = new QLabel(dialog);

label->setText( "გამარჯობა, მსოფლიო!" );

დიალოგი->ჩვენება();

დააბრუნეთ app.exec();

კომპილაცია

$ qmake -პროექტი

TEMPLATE=აპი
სამიზნე =
DEPENDPATH += .
INCLUDEPATH += .

#შეყვანა
SOURCES += main.cpp

მეორე პროგრამა

#შეიცავს

#შეიცავს

#შეიცავს

#შეიცავს

კლასი MyDialog: საჯარო QDialog (

Q_OBJECT

საჯარო:

MyDialog(QWidget *მშობელი = 0);

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

#include "mydialog.h"

MyDialog::MyDialog(QWidget *მშობელი) : QDialog(მშობელი) (

QVBoxLayout *განლაგება = ახალი QVBoxLayout(ეს);

QLabel *label = new QLabel(this);

label->setText( "გამარჯობა, მსოფლიო!" );

QPushButton *button = new QPushButton(this );

button->setText("დახურვა");

განლაგება->addWidget(label);

განლაგება->addWidget(ღილაკი);

connect(ღილაკი, SIGNAL(დააწკაპუნეთ()), ეს , SLOT(close()));

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

#შეიცავს

#include "mydialog.h"

int main(int argc, char * argv) (

QApplication აპლიკაცია (argc, argv);

MyDialog *dialog = ახალი MyDialog;

დიალოგი->ჩვენება();

დააბრუნეთ app.exec();

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

პროექტის გუნდურად აღდგენა

$ qmake -პროექტი

მესამე პროგრამა

ყოველწლიურად უფრო და უფრო მეტი ოპერაციული სისტემა ჩნდება და, შესაბამისად, დეველოპერებს უფრო და უფრო უჭირთ მომხმარებლების საჭიროებების დაკმაყოფილება. სამი ყველაზე პოპულარული კომპიუტერული პლატფორმა - Windows, Linux და Mac OS, ასევე სამი მობილური პლატფორმა - Android, iOS და Windows Mobile - აგრძელებენ აქტიურ ბრძოლას ერთმანეთთან. ეს ნიშნავს, რომ მაღალი ხარისხის აპლიკაცია უნდა მუშაობდეს ყველა ძირითად პლატფორმაზე.

კროს-პლატფორმული განვითარება დაგეხმარებათ ამ პრობლემის მოგვარებაში. ამ სტატიაში განხილული იქნება ერთ-ერთი ყველაზე პოპულარული კროს-პლატფორმული განვითარების გარემო - Qt Creator. ჩვენ განვიხილავთ, თუ როგორ უნდა დააინსტალიროთ და დააკონფიგურიროთ Qt Creator, ასევე როგორ ვიმუშაოთ Qt Creator-ში.

რა არის Qt Creator

Qt Creator (არც ისე დიდი ხნის წინ სახელწოდებით Greenhouse) არის ერთ-ერთი ყველაზე გავრცელებული cross-platform IDE. მისი უპირატესობებია მოხერხებულობა, მუშაობის სიჩქარე და ასევე თავისუფლება, რადგან ეს არის ღია კოდის პროგრამული უზრუნველყოფა. მხარდაჭერილია ისეთი ენები, როგორიცაა C, C++, QML.

პროგრამა დაწერილი იყო კომპანია Trolltech-ის მიერ, რომელმაც სრულად შეასრულა გარემოს შექმნის მიზანი - მუშაობა Qt გრაფიკულ ჩარჩოზე. მოსახერხებელი გრაფიკული ინტერფეისი Qt ვიჯეტებისა და QML-ის მხარდაჭერით, ისევე როგორც მხარდაჭერილი შემდგენელების დიდი რაოდენობა, საშუალებას გაძლევთ სწრაფად და მოხერხებულად შექმნათ თქვენი საკუთარი კროს-პლატფორმული აპლიკაცია.

ამ IDE-ის მთავარი მიზანია უზრუნველყოს ყველაზე სწრაფი კროს-პლატფორმული განვითარება საკუთარი ჩარჩოს გამოყენებით. ამის წყალობით, დეველოპერებს აქვთ შესანიშნავი შესაძლებლობა, რომ არ დაწერონ პროგრამები მშობლიურად (ანუ ცალ-ცალკე თითოეული პლატფორმისთვის), არამედ შექმნან საერთო კოდი და, შესაძლოა, მოარგონ იგი გამოყენებული ოპერაციული სისტემების მახასიათებლებს.

Qt Creator ასევე შეიცავს Qt Designer უტილიტას, რომელიც საშუალებას გაძლევთ დააკონფიგურიროთ თქვენი აპლიკაციის ფანჯრის გარეგნობა ელემენტების დამატებით და გადათრევით (მსგავსი Windows Forms Visual Studio-ში). გამოყენებული build სისტემებია qmake, cmake და autotools.

Qt Creator-ის ინსტალაცია

ასე რომ, დროა გადახედოთ როგორ დააინსტალიროთ Qt Creator. თუ Windows-ისთვის დეველოპერებმა იზრუნეს და შექმნეს ოფლაინ ინსტალერი, მაშინ Linux 32-ბიტიანში ეს ფუნქცია არ არის გათვალისწინებული. ამიტომ, ინსტალაციის დროს შეიძლება დაგჭირდეთ სტაბილური ინტერნეტ კავშირი (~ 20-30 წუთი). პირველ რიგში, ჩამოტვირთეთ ინსტალერი:

ჩამოტვირთეთ Qt Creator Linux-ისთვის 32-ბიტიანი (დააწკაპუნეთ " სხვა ვარიანტების ნახვა").
ჩამოტვირთეთ Qt Creator Linux-ისთვის 64-ბიტიანი.

ჩამოტვირთვის დასრულების შემდეგ გადადით ფაილის საქაღალდეში, დააწკაპუნეთ მარჯვენა ღილაკით და აირჩიეთ "თვისებები".

ახლა მოდით გადავიდეთ ჩანართზე "უფლებები"და შეამოწმეთ ყუთი "ამ ფაილს პროგრამის სახით გაშვების დაშვება".

მოდით გავუშვათ პროგრამა.

ახლა ჩვენ ვაჭერთ "შემდეგი".

აქ თქვენ უნდა აირჩიოთ არსებული ანგარიში ან შექმნათ ერთი. ეს ქმედება აუცილებელია ლიცენზიის (კომერციული თუ არაკომერციული) შესამოწმებლად.

დააწკაპუნეთ "შემდეგი".

აირჩიეთ დირექტორია, რომელშიც განთავსდება Qt. მნიშვნელოვანია, რომ გზაზე არ იყოს კირიული სიმბოლოები ან სივრცეები!

ეს მენიუ შეიცავს კომპონენტების არჩევანს. მაგალითად, შეგიძლიათ აირჩიოთ ანდროიდზე განვითარების ინსტრუმენტების დაყენება, ან წყაროს კომპონენტები (ეს საჭიროა სტატიკური აწყობისთვის, თუ ვინმეს ეს სჭირდება, დაწერეთ კომენტარებში და მე დავწერ ცალკე სტატიას). თუ არ ხართ დარწმუნებული, გჭირდებათ ეს კომპონენტები თუ არა, დატოვეთ ისინი ახლა ასე - Qt-ის დაყენების შემდეგაც შესაძლებელი იქნება ელემენტების ამოღება და დამატება.

ამ ფანჯარაში ჩვენ ვიღებთ ლიცენზიას. დააწკაპუნეთ "შემდეგი".

თუ მზად ხართ, დაიწყეთ ინსტალაცია. თქვენ მოგეთხოვებათ თქვენი სუპერმომხმარებლის პაროლი (sudo), რის შემდეგაც დაიწყება ფაილების ჩამოტვირთვა და ამოღება. ალტერნატიული მეთოდია ტერმინალის საშუალებით ინსტალაცია. ჯერ უნდა განაახლოთ პაკეტების სია.

ჩამოტვირთეთ და დააინსტალირეთ Qt:

sudo apt install qt5-default

ახლა დააინსტალირეთ Qt Creator:

sudo apt დააინსტალირე qtcreator

და, საჭიროების შემთხვევაში, წყაროები.

sudo apt install qtbase5-მაგალითები qtdeclarative5-მაგალითები

Qt Creator-ის დაყენება

ინსტალაციის დასრულების შემდეგ გადატვირთეთ კომპიუტერი და გაუშვით Qt Creator. მენიუში გადასვლა "ინსტრუმენტები" -> "პარამეტრები".

აქ გასათვალისწინებელია რამდენიმე ჩანართი.

1. ოთხშაბათი- ეს არის თავად IDE-ს გარეგნობის მორგება, ასევე კლავიატურის მალსახმობების შეცვლა და გარე კომუნალური საშუალებების მართვა.

2. ტექსტის რედაქტორი- აქ შეგიძლიათ შეცვალოთ რედაქტორის გარეგნობა, შრიფტები და ფერები.

3. C++- სინტაქსის ხაზგასმა, ფაილების გაფართოებებთან და ინტერფეისთან (ანუ ფორმებთან) მუშაობა.

4.ანდროიდი- აქ გროვდება ბილიკები საჭირო ინსტრუმენტებთან და დაკავშირებული ან ვირტუალური მოწყობილობები ასევე კონფიგურებულია ამ მენიუში.

Qt Creator კომპონენტების ინსტალაცია

თუ მოულოდნელად მოხდა, რომ დაგავიწყდათ კომპონენტის დაყენება, ან, პირიქით, გსურთ მისი ამოღება, მაშინ Qt Maintenance Tool მოვა სამაშველოში. ეს არის ინსტრუმენტი, რომელიც საშუალებას გაძლევთ მართოთ Qt Creator-ის ყველა კომპონენტი.

მის გასაშვებად გადადით აპლიკაციების მენიუში, აირჩიეთ "Development" -> "Qt Maintenance Tool".

აირჩიეთ საჭირო ვარიანტი (წაშლა/დაამატეთ კომპონენტები, განაახლეთ კომპონენტები ან წაშალეთ Qt). შემდეგ შეასრულეთ საჭირო ოპერაციები და დახურეთ ფანჯარა.

Qt Creator-თან მუშაობა - პირველი პროექტი

აბა, საათი დადგა! Qt Creator-ის ინსტალაცია დასრულებულია. დროა შექმნათ თქვენი პირველი კროს-პლატფორმული აპლიკაცია Linux-ზე და შემდეგ შეადგინოთ იგი Windows-ზე. დაე იყოს... პროგრამა, რომელიც აჩვენებს Qt ხატულას, ღილაკს და წარწერას, რომელზეც ღილაკის დაჭერისას გამოჩნდება შემთხვევითი ფრაზა. პროექტი მარტივია და, რა თქმა უნდა, კროს-პლატფორმულია!

პირველი, მოდით გავხსნათ განვითარების გარემო. მოდით დავაჭიროთ "ფაილი" -> "შექმენით ფაილი ან პროექტი...". მოდით ავირჩიოთ Qt Widgets აპლიკაცია - მისი შექმნა სწრაფი და მარტივია. და მისი სახელია "ჯვარედინი პლატფორმა". ასეა საქმე!

Set - ნაგულისხმევი. ჩვენ ასევე ვტოვებთ მთავარ ფანჯარას უცვლელად. მოდით შევქმნათ პროექტი.

ჯერ უნდა დააკონფიგურიროთ ფორმა - აპლიკაციის მთავარი ფანჯარა. ნაგულისხმევად ცარიელია, მაგრამ ასე დიდხანს არ დარჩება.

მოდით გადავიდეთ საქაღალდეში "Forms" -> "mainwindow.ui". Qt Designer ფანჯარა გაიხსნება:

ამოიღეთ მენიუს ზოლი და ხელსაწყოთა ზოლი ფორმიდან მარჯვენა ღილაკით და შესაბამისი ელემენტის არჩევით. ახლა გადაიტანეთ Graphics View, Push Button და Label ელემენტები ასე:

ტექსტის შესაცვლელად, ორჯერ დააწკაპუნეთ ელემენტზე. ლეიბლის თვისებებში (მარჯვნივ) აირჩიეთ ტექსტის პოზიცია ვერტიკალურად და ჰორიზონტალურად - ვერტიკალურად.

ახლა დროა გავარკვიოთ ხატის გამოსავალი. მოდით გადავიდეთ რედაქტორში, დააწკაპუნეთ მაუსის მარჯვენა ღილაკით მარცხნივ ნებისმიერ საქაღალდეზე და აირჩიეთ "ახლის დამატება...". ახლა ჩვენ ვაჭერთ "Qt" -> "Qt რესურსის ფაილი". დასახელება - რეზ. ფანჯარაში, რომელიც იხსნება, დააწკაპუნეთ "დამატება" -> "პრეფიქსის დამატება"და დამატების შემდეგ - "ფაილების დამატება". აირჩიეთ ფაილი და ფანჯარაში, რომელიც გამოჩნდება "ფაილის არასწორი მდებარეობა"დააწკაპუნეთ "ასლი".

იმუშავა! ჩვენ ყველაფერს ვზოგავთ. კვლავ გახსენით ფორმა. დააწკაპუნეთ მარჯვენა ღილაკით Graphics View-ზე და აირჩიეთ "styleSheet..." -> "Resource დამატება" -> "background-image". ფანჯრის მარცხენა ნაწილში, რომელიც გამოჩნდება, აირჩიეთ prefix1, ხოლო მარჯვნივ - ჩვენი სურათი. დააწკაპუნეთ "კარგი". დაარეგულირეთ სიგრძე და სიგანე.

ყველა! ახლა თქვენ შეგიძლიათ დაიწყოთ კოდირება. ღილაკზე მარჯვენა ღილაკით იხსნება კონტექსტური მენიუ, ახლა თქვენ უნდა დააჭიროთ "გადადით სლოტზე..." -> "დააწკაპუნეთ()". ფანჯარაში ჩვენ ვწერთ შემდეგ კოდს:

ან შეგიძლიათ ჩამოტვირთოთ სრული პროექტი GitHub-ზე. Qt Creator-თან მუშაობა დასრულებულია, დააწკაპუნეთ მარცხნივ მწვანე ისრის ხატულაზე და დაელოდეთ პროგრამის გაშვებას (თუ ისარი ნაცრისფერია, ჯერ დააწკაპუნეთ ჩაქუჩის ხატულაზე). დაიწყო! ჰორი!

დამწყები პროგრამისტი მუდმივად ეჭვობს, რომელი ტექნოლოგიების დაუფლება უნდა დაიწყოს, ამა თუ სხვა. უნდა ისწავლოს თუ არა დამწყებმა პროგრამისტმა Qt? აუცილებლად აუცილებელია! მაგალითად, წაიკითხეთ ეს პოსტი ან მოძებნეთ რამე ინტერნეტში. ჯერ კიდევ არ ხართ დარწმუნებული, გჭირდებათ თუ არა Qt? თუ თქვენ წერთ C++, თქვენ უნდა იცოდეთ Qt, უბრალოდ არ გაქვთ სხვა ალტერნატივა.

მაშ, წავიდეთ...

მოდით, მაგალითად, დავწეროთ მარტივი კალკულატორი - დავამატოთ ორი რიცხვი.

შევქმნათ ახალი პროექტი. როგორც ვხედავთ, არსებობს რამდენიმე სახის აპლიკაცია. ჩვენ, როგორც დამწყებთათვის, ვირჩევთ "Qt ვიჯეტების აპლიკაცია":

ჩვენ მივუთითებთ პროექტის სახელს და საქაღალდეს ფაილების განსათავსებლად, ჩემთვის: 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 =" ღილაკზე, იხსნება ამომხტარი მენიუ:

დააჭირეთ "სლოტზე გადასვლას"

აირჩიეთ დაწკაპუნებული() სიგნალი და კოდის რედაქტორში, რომელიც იხსნება, ჩაწერეთ პატარა კოდი 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: ->edtC->setText (s) // შედეგის ამობეჭდვა edtC-ში )

clicked() სიგნალის დამუშავების ფუნქციას ეწოდება on_btnOK_clicked() სლოტი.

QtCreator-ისგან GUI აპლიკაციის შაბლონის შექმნის მაგალითი

აპლიკაციის ფანჯარაში ვიჯეტების განთავსების მარტივი მაგალითი

განვითარების გარემო

პირველი პროგრამა

კომპილაცია

მეორე პროგრამა

მესამე პროგრამა

განვითარების გარემო

პირველი პროგრამა

კომპილაცია

მეორე პროგრამა

მესამე პროგრამა

რა არის Qt Creator

Qt Creator-ის ინსტალაცია

Qt Creator-ის დაყენება

Qt Creator კომპონენტების ინსტალაცია

Qt Creator-თან მუშაობა - პირველი პროექტი

შეატყობინეთ შეცდომას

ტექსტი, რომელიც გაეგზავნება ჩვენს რედაქტორებს:

თქვენი კომენტარი (სურვილისამებრ):