Framework QT

Qt Essentials Definisci il fondamento di QT su tutte le piattaforme. Sono disponibili su tutte le piattaforme di sviluppo supportate e sulle piattaforme target testate.

Riepilogo:

1. Il QT Framework è un insieme completo di classi di librerie C ++ che semplificano lo sviluppo dell’applicazione.

2. QT produce codice altamente leggibile, mantenibile e riutilizzabile con prestazioni di runtime elevate e una piccola impronta.

3. QT è multipiattaforma, consentendo agli sviluppatori di creare applicazioni per più piattaforme.

4. Qt Essentials, come Qt Core, Qt GUI, Qt Multimedia, Qt Network, Qt Quick e Qt SQL, formano il fondamento di QT su tutte le piattaforme.

5. Qt fornisce anche componenti aggiuntivi come Qt OpenGL, QT Wayland Compositor, QT Sensor, QT WebView, Qt Safe Renerer e Qt SCXML per attività specifiche.

6. Il framework QT dà la priorità alla risoluzione delle potenziali minacce di vulnerabilità e problemi di sicurezza.

7. Gli sviluppatori dovrebbero avere una conoscenza preliminare di C ++ prima di usare QT.

8. La serie di tutorial QT copre argomenti come il promemoria C ++, l’introduzione a QT, le funzionalità del Creatore QT, la creazione di Windows e pulsanti, Gerarchia di classe QT e altro ancora.

9. Il modello di osservatore, i segnali e le slot e le informazioni di trasmissione sono alcune delle funzionalità avanzate trattate nella serie di tutorial.

Domande:

1. Qt usa C++?
   Sì, QT è scritto principalmente in C ++ e fornisce una serie di classi di librerie C ++ per lo sviluppo delle applicazioni.
2. Cosa sono Qt Essentials?
   Gli elementi essenziali QT sono il fondamento di QT e includono moduli come Qt Core, Qt GUI, QT Multimedia, QT Network, Qt Quick e Qt SQL.
3. Quali sono alcuni componenti aggiuntivi QT?
   Alcuni componenti aggiuntivi QT includono Qt OpenGL, QT Wayland Compositor, QT Sensors, QT WebView, Qt Safe Renerer e QT SCXML.
4. In che modo QT dà la priorità alla sicurezza?
   Il gruppo QT affronta attivamente le potenziali vulnerabilità e problemi di sicurezza e segue una politica di sicurezza delineata nella politica di sicurezza del progetto QT.
5. Quale conoscenza è richiesta per usare QT?
   Gli sviluppatori dovrebbero conoscere C ++ prima di iniziare con QT.
6. Quali argomenti sono trattati nella serie di tutorial QT?
   La serie di tutorial copre argomenti come un promemoria C ++, Introduzione alle funzionalità QT, QT Creator, Creazione di Windows e pulsanti, Gerarchia di classe QT e altro ancora.
7. Quali caratteristiche avanzate sono coperte nella serie di tutorial?
   La serie di tutorial copre caratteristiche avanzate come il modello di osservatore, i segnali e gli slot e la trasmissione di informazioni.
8. È QT Cross-piattaforma?
   Sì, QT è multipiattaforma e consente agli sviluppatori di creare applicazioni che vengono eseguite su più piattaforme.
9. Qual è lo scopo dei componenti aggiuntivi Essential e Qt?
   Qt Essential fornisce le basi di QT, mentre i componenti aggiuntivi QT offrono funzionalità aggiuntive per attività specifiche.
10. In che modo QT garantisce la sicurezza?
    QT analizza attivamente i rapporti di vulnerabilità e intraprende un’azione pronta per affrontarli. Il gruppo QT partecipa anche a gruppi diretti pertinenti per problemi di sicurezza.
11. Quali sono alcuni vantaggi dell’utilizzo di QT?
    QT consente agli sviluppatori di scrivere codice altamente leggibile e mantenibile con eccellenti prestazioni di runtime. Fornisce inoltre funzionalità multipiattaforma.
12. Qual è il framework QT?
    Il framework QT è costituito da un insieme completo di classi di librerie C ++ che semplificano lo sviluppo delle applicazioni e forniscono modularità.
13. Qual è il modello di osservatore?
    Il modello di osservatore è un modello di progettazione in cui un oggetto, chiamato soggetto, mantiene un elenco di osservatori che dipendono da esso. Quando lo stato del soggetto cambia, notifica a tutti i suoi osservatori di aggiornare automaticamente.
14. Cosa sono segnali e slot?
    Segnali e slot sono un meccanismo in QT per la comunicazione tra gli oggetti. I segnali vengono emessi da oggetti quando si verificano eventi particolari e le slot sono funzioni che possono essere collegate per ricevere e gestire i segnali.
15. Come possono essere trasmesse le informazioni in QT?
    Le informazioni possono essere trasmesse in QT utilizzando segnali e slot, in cui i segnali trasportano le informazioni e le slot ricevono ed elaborarle.

Risposte:

1. Qt usa C++?
Sì, QT utilizza principalmente C ++ per il suo sviluppo. Ciò consente agli sviluppatori di sfruttare la potenza e la flessibilità del linguaggio C ++ nelle loro applicazioni QT.

2. Cosa sono Qt Essentials?
Qt Essentials sono moduli fondamentali in QT che formano il fondamento del framework. Questi includono Qt Core, Qt GUI, QT Multimedia, QT Network, Qt Quick e Qt SQL. Forniscono funzionalità essenziali per vari aspetti dello sviluppo dell’applicazione, come classi non grafiche, componenti grafici dell’interfaccia utente, supporto multimediale, programmazione di rete, sviluppo dichiarativo delle applicazioni e integrazione del database utilizzando SQL.

3. Quali sono alcuni componenti aggiuntivi QT?
QT fornisce vari componenti aggiuntivi che offrono funzionalità aggiuntive per attività specifiche. Alcuni esempi di componenti aggiuntivi QT sono:

• Qt OpenGL: classi per il supporto OpenGL. Dutorate a favore delle classi Qopengl nel modulo GUI QT.
• Compositore Qt Wayland: framework per lo sviluppo di un compositore Wayland.
• Sensori QT: classi per l’accesso all’hardware del sensore e al riconoscimento dei gesti del movimento.
• QT WebView: un modulo che consente di visualizzare il contenuto Web in un’applicazione QML utilizzando API native della piattaforma anziché uno stack del browser Web completo.
• QT SAFE RENDER: fornisce un componente di rendering dell’interfaccia utente per il rendering di articoli critici per la sicurezza, come gli indicatori di avvertimento, nei sistemi di sicurezza funzionale.
• QT SCXML: offre classi e strumenti per la creazione di macchine a stato dai file SCXML e incorporarli nelle applicazioni.

4. In che modo QT dà la priorità alla sicurezza?
Il gruppo QT prende sul serio i problemi di sicurezza e ha un approccio dedicato per affrontare le potenziali vulnerabilità. Poiché QT viene sviluppato come progetto open source, l’analisi del rapporto di vulnerabilità viene effettuata da membri del personale designato e collaboratori esterni. Il gruppo QT partecipa attivamente a gruppi diretti pertinenti e intraprendono prontamente la ricezione di rapporti di vulnerabilità. Le procedure dettagliate per la gestione dei rapporti di vulnerabilità sono delineate nella politica di sicurezza del progetto QT.

5. Quale conoscenza è richiesta per usare QT?
Prima di iniziare con QT, si consiglia di avere una buona comprensione di C++. QT utilizza pesantemente C ++ per il suo sviluppo e avere una solida comprensione della lingua renderà più facile lavorare con il quadro QT e le sue API.

6. Quali argomenti sono trattati nella serie di tutorial QT?
La serie di tutorial QT copre una vasta gamma di argomenti per aiutare i principianti a iniziare con lo sviluppo dell’applicazione QT. Alcuni degli argomenti trattati includono:

• Un promemoria C ++ per aggiornare le basi
• Un’introduzione a QT, le sue caratteristiche e le funzionalità multipiattaforma
• Una guida per l’installazione dell’SDK QT
• Una panoramica del creatore di QT e delle sue caratteristiche
• Creazione della prima finestra e comprendere il processo di compilazione
• Aggiunta di elementi interattivi come pulsanti all’applicazione
• Comprensione della gerarchia della classe Qt e il concetto di genitorialità Qobject
• Sottoclasse qwidget e creazione di widget personalizzati
• Ulteriori risorse e raccomandazioni di lettura

7. Quali caratteristiche avanzate sono coperte nella serie di tutorial?
Oltre alle basi, la serie di tutorial QT approfondisce argomenti più avanzati. Alcuni esempi delle funzionalità avanzate coperte sono:

• Il modello Observer: esplorare il concetto e come implementarlo nelle applicazioni QT
• Segnali e slot: comprensione del meccanismo di comunicazione tra oggetti
• Informazioni di trasmissione: come passare le informazioni tra diverse parti dell’applicazione utilizzando segnali e slot
• Caratteristiche di segnali e slot: funzionalità e capacità aggiuntive dei segnali e del meccanismo di slot

8. È QT Cross-piattaforma?
Sì, QT è un framework multipiattaforma. Consente agli sviluppatori di scrivere le loro applicazioni una volta e distribuirle su più piattaforme, tra cui Windows, MacOS, Linux, Android e iOS. QT fornisce astrazioni e API che gestiscono i dettagli specifici della piattaforma, rendendo più semplice lo sviluppo di applicazioni che funzionano in modo coerente attraverso diversi sistemi operativi.

9. Qual è lo scopo dei componenti aggiuntivi Essential e Qt?
QT Essentials forma la base del framework QT fornendo funzionalità e classi di base ampiamente utilizzate nello sviluppo delle applicazioni. Garantiscono un’esperienza di sviluppo coerente e affidabile su diverse piattaforme. D’altra parte, i componenti aggiuntivi QT offrono moduli e funzionalità aggiuntivi più specifici per determinati casi d’uso o domini. Forniscono funzionalità e capacità estese oltre gli elementi essenziali.

10. In che modo QT garantisce la sicurezza?
QT adotta un approccio proattivo alla sicurezza analizzando e affrontando le potenziali vulnerabilità nei suoi prodotti. Il gruppo QT partecipa a gruppi diretti pertinenti e risponde prontamente ai rapporti di vulnerabilità. Inoltre, come progetto open source, QT invita i collaboratori esterni a rivedere e analizzare il codice, migliorando la sicurezza generale del framework.

11. Quali sono alcuni vantaggi dell’utilizzo di QT?
Ci sono diversi vantaggi nell’utilizzo di QT per lo sviluppo dell’applicazione:

• QT fornisce un set completo di lezioni di libreria C ++ che semplificano lo sviluppo dell’applicazione, rendendo più veloce e più facile creare applicazioni robuste.
• Il codice scritto usando QT è altamente leggibile, mantenibile e riutilizzabile, riducendo gli sforzi di sviluppo e migliorando la produttività.
• QT è multipiattaforma, consentendo agli sviluppatori di scrivere un’applicazione una volta e distribuirla su più piattaforme.
• Il framework offre eccellenti prestazioni di runtime, garantendo applicazioni fluide e reattive.
• Qt ha un’impronta ridotta, il che significa che gli eseguibili risultanti sono compatti ed efficienti.

12. Qual è il framework QT?
Il QT Framework è una raccolta completa di classi di librerie C ++ che forniscono una vasta gamma di funzionalità per lo sviluppo dell’applicazione. Offre una struttura modulare, consentendo agli sviluppatori di utilizzare solo i componenti di cui hanno bisogno. QT fornisce strumenti, API e astrazioni per vari aspetti dello sviluppo delle applicazioni, tra cui la progettazione dell’interfaccia utente, l’integrazione del database, il networking, il multimedia e molto altro. È progettato per semplificare il processo di sviluppo, promuovere il riutilizzo del codice e abilitare lo sviluppo di applicazioni multipiattaforma.

13. Qual è il modello di osservatore?
Il modello di osservatore è un modello di progettazione comportamentale che consente la comunicazione da uno a molti oggetti. Nel modello di osservatore, ci sono due entità principali: il soggetto e gli osservatori. Il soggetto mantiene un elenco di osservatori e li notifica automaticamente quando il suo stato cambia. Questo modello promuove l’accoppiamento sciolto tra gli oggetti e consente un sistema altamente interattivo e dinamico. In QT, il modello Observer può essere implementato utilizzando segnali e slot, in cui il soggetto emette segnali e gli osservatori collegano i loro slot ai segnali per ricevere aggiornamenti.

14. Cosa sono segnali e slot?
Segnali e slot sono un meccanismo fornito da QT per la comunicazione tra gli oggetti. Un segnale è una funzione membro speciale di una classe derivata dal Qobject che può essere emessa per indicare che si è verificato un determinato evento o condizione. Uno slot è una funzione membro che può essere collegata a un segnale per riceverlo e gestirlo. Segnali e slot possono essere usati per stabilire un accoppiamento sciolto tra gli oggetti, permettendo loro di comunicare senza essere strettamente accoppiati tra loro. Ciò promuove la modularità e la flessibilità nella progettazione di applicazioni QT.

15. Come possono essere trasmesse le informazioni in QT?
In QT, le informazioni possono essere trasmesse tra diverse parti di un’applicazione utilizzando segnali e slot. Un segnale può trasportare informazioni definendo i parametri e uno slot può ricevere ed elaborare tali informazioni. Quando viene emesso un segnale, tutti gli slot collegati verranno chiamati con le informazioni fornite. Questo meccanismo consente agli oggetti di comunicare e scambiare dati senza riferirsi direttamente a vicenda, promuovendo accoppiamento allentato e flessibilità nella progettazione dell’applicazione.

Framework QT

Qt Essentials Definisci il fondamento di QT su tutte le piattaforme. Sono disponibili su tutte le piattaforme di sviluppo supportate e sulle piattaforme target testate.

Qt usa C++

Об этой сттце

Ыы зарегистрировали подозритеstituire. С помощю ээй ст р ы ыы сможем о imperceде quello. Почему ээо мо л поззти?

Эта страница отображается в тех с лччч, когда автоматическиtal систе quisi которые наршают условия иполззования. Страница перестан scegliere. До этого момента для иполззования сжж google необходимо пхоходить поверку по по по по по.

” ылку запросов. Если ы и ипоеете общий доступ в интернет, проmma. Обратитесь к с ое системому администратору. Подробнеi.

Проверка по слову может также появляться, если вы вводите сложные запросы, обычно распространяемые автоматизированными системами, или же вводите запросы очень часто.

Framework QT

Il framework QT contiene un insieme completo di classi di librerie C ++ altamente intuitive e modularizzate ed è caricato con API per semplificare lo sviluppo dell’applicazione. QT produce codice altamente leggibile, facilmente mantenebile e riutilizzabile con prestazioni di runtime elevate e impronte ridotte-ed è una piattaforma incrociata.

Qt Essentials

Rendere possibile il vero piattaforma multipla

Qt Essentials Definisci il fondamento di QT su tutte le piattaforme. Sono disponibili su tutte le piattaforme di sviluppo supportate e sulle piattaforme target testate.

Qt Core

Classi non grafiche core utilizzate da altri moduli.

QT GUI

Classi di base per i componenti dell’interfaccia utente grafica. Include OpenGL.

Qt Multimedia

Classi per funzionalità audio, video, radio e fotocamera.

Rete QT

Classi per rendere la programmazione di rete più semplice e più portatile.

Qt veloce

Un framework dichiarativo per la creazione di applicazioni altamente dinamiche con interfacce utente personalizzate.

Qt SQL

Classi per l’integrazione del database utilizzando SQL.

Qt ADD-ONS

I componenti aggiuntivi giusti
Per il compito giusto

Qt Essentials Definisci il fondamento di QT su tutte le piattaforme. Sono disponibili su tutte le piattaforme di sviluppo supportate e sulle piattaforme target testate.

Qt OpenGL

Classi di supporto OpenGL. Dutorate a favore delle classi Qopengl nel modulo GUI QT.

Compositore Qt Wayland

Fornisce un framework per sviluppare un compositore Wayland.

Sensori QT

Fornisce l’accesso all’hardware del sensore e al riconoscimento dei gesti di movimento.

QT WebView

Visualizza i contenuti Web in un’applicazione QML utilizzando API nativa della piattaforma, senza la necessità di includere uno stack del browser Web completo.

QT SAFE RANDER

Fornisce un componente di rendering dell’interfaccia utente che può essere utilizzato per rendere oggetti critici per la sicurezza, come gli indicatori di avvertimento, nei sistemi di sicurezza funzionale.

Qt SCXML

Fornisce classi e strumenti per la creazione di macchine a stato da file SCXML e incorporarle nelle applicazioni.

Pratiche del quadro QT per la gestione dei problemi di sicurezza

Il gruppo QT dà la priorità alla risoluzione delle potenziali minacce di vulnerabilità e alle preoccupazioni di sicurezza nei suoi prodotti. Con la sua ampia applicabilità multipiattaforma e un’ampia API, il quadro QT è suscettibile ai rischi informatici su diversi fronti. Inoltre, QT è sviluppato come progetto open source, che richiede un’analisi del rapporto di vulnerabilità da membri del personale designato e collaboratori esterni. Fin dalla sua istituzione, il gruppo QT partecipa attivamente ai gruppi diretti pertinenti e intraprende rapporti rapidi sui rapporti di vulnerabilità. I rapporti di vulnerabilità sono regolati da procedure specifiche delineate nella politica di sicurezza del progetto QT.

Qt per i principianti

Avvertimento : Assicurati di avere una certa conoscenza di C ++ prima di iniziare!

Osservazione : Questo obiettivo della serie di tutorial principalmente QT4. Anche se la maggior parte di questi tutorial è valida anche per QT5, il caso di QT5 è discusso in una parte separata.

Contenuti

• 1 promemoria C ++
• 2 Introduzione a QT
• 3 Installazione di QT SDK
• 4 caratteristiche del creatore QT
• 5 La nostra prima finestra
• 6 Come viene compilato un programma QT
• 7 Un bel pulsante
• 8 Gerarchia di classe Qt
• 9 Sistema genitoriale
• 10 Qwidget sottoclasse
• 11 Ulteriori letture
• 12 Il modello di osservatore
• 13 segnali e slot
• 14 Informazioni di trasmissione
• 15 caratteristiche di segnali e slot
• 16 esempi
  • 16.1 Rispondere a un evento
  • 21.1 Creazione di slot personalizzati
  • 21.2 Creazione di segnali
  • 21.3 Esempio

  Promemoria C ++

  IL firma di un metodo o funzione è semplicemente il suo prototipo. Descrive completamente un metodo o una funzione. Contiene il tipo restituito, il nome del metodo/funzione (incluso il nome della classe) e i parametri, inclusi i tipi.

  Tipo Myobject:::myfunction( Tipo 1 param1, Tipo2 *param2, const Tipo3 Eparam3 ); 

  Nuovo a Qt? Non so come iniziare? Quindi questa pagina wiki è per te! È un tutorial passo passo che presenta tutte le specificità e le caratteristiche di QT. Voglio saperne di più? Dai un’occhiata alle nostre classi C ++ GUI per le classi Qt 5 e C ++ per Qt 6.

  Introduzione a Qt

  Qt (pronunciato come “carino”, non “cu-tee”) è un framework multipiattaforma che di solito viene utilizzato come kit di strumenti grafici, sebbene sia anche molto utile per creare applicazioni CLI. Funziona sui tre principali sistemi di desktop, nonché sui sistemi operai mobili, come Symbian, Nokia Belle, Meego Harmattan, Meego o BB10 e su dispositivi incorporati. Anche i porti per Android (necessari) e iOS sono in fase di sviluppo.

  Qt ha un’impressionante raccolta di moduli, tra cui

  • Qtcore, una libreria di base che fornisce contenitori, gestione dei thread, gestione degli eventi e molto altro
  • Qtgui E Qtwidgets, Un toolkit GUI per desktop, che fornisce molti componenti grafici per progettare applicazioni.
  • Qtnetwork, che fornisce un utile set di classi per gestire le comunicazioni di rete
  • Qtwebkit, Il motore WebKit, che consente l’uso di pagine Web e app Web in un’applicazione QT.
  • QTSQL, Un livello di astrazione SQL RDBM in primo piano è estesibile con i propri driver, supporto per ODBC, SQLite, MySQL e PostgreSQL è disponibile fuori dalla scatola
  • Qtxml, Supporto per l’analisi XML semplice (SAX) e DOM
  • Qtxmlpatterns, Supporto per la convalida XSLT, XPath, XQuery e Schema

  Installazione di QT SDK

  Per iniziare a scrivere applicazioni QT, devi ottenere librerie QT e, se vuoi, un IDE. Possono essere costruiti da fonte o meglio, essere scaricati come SDK dalla pagina di download.

  Questo SDK include molte caratteristiche, come i compilatori incrociati per Symbian e Nokia N9. Potresti scegliere di non installarli selezionando “Installazione personalizzata”. Assicurati di mantenere questi pacchetti

  • Documentazione Qmake
  • Documentazione QT
  • Qt 4.8.1 (desktop), Supponendo che Qt 4.8.1 è l’ultima versione.
  • Creatore QT

  Questi pacchetti possono anche essere utili

  • Esempi QT
  • Linguista QT

  Puoi selezionare altri pacchetti se si desidera sviluppare per Symbian / Maemo / Meego o con la versione precedente di QT.

  Nb : Su Linux, è meglio utilizzare i pacchetti forniti dalla distribuzione. Il creatore QT dovrebbe essere disponibile in quasi tutte le distribuzioni e l’installazione dovrebbe installare tutte le dipendenze, come librerie, compilatori e intestazioni di sviluppo.

  Nota: Vedi il funzionario Guida con la pagina dei widget QT per un tutorial alternativo.

  Ora siamo pronti a creare la nostra prima finestra. E sarà come al solito, a Ciao mondo.

  Caratteristiche del Creatore QT

  Prima di scrivere la nostra prima app GUI, scopriamo QT Creator.

  QT Creator è un altro IDE per C ++, ma è molto adatto per codificare le applicazioni QT. Fornisce un browser DOC e il “designer”, che semplifica la creazione di Windows, tutto avvolto in un’interfaccia utente ben progettata. È anche uno dei più veloci disponibili.

  La nostra prima finestra

  Cominciamo creando il nostro primo progetto. Sarà un progetto vuoto, quindi dobbiamo procedere con: file> nuovo file o progetto> altri progetti> Project QT vuoto

  

  Segui la procedura guidata e dopo aver selezionato la cartella e il nome del progetto e selezionare la versione di QT da utilizzare, è necessario atterrare in questa pagina

  

  Questo è il file di progetto (estensione .professionista. QT utilizza uno strumento di riga di comando che analizza questi file di progetto per generare “makefiles”, file utilizzati dai compilatori per creare un’applicazione. Questo strumento si chiama Qmake. Ma non dovremmo preoccuparci troppo di Qmake, poiché il Creatore di QT farà il lavoro per noi.

  In un file di progetto, esiste un codice minimo che dovrebbe sempre essere scritto:

  Template = app target = name_of_the_app qt = core gui Greaterthan (qt_major_version, 4): qt += widgets

  • MODELLO descrive il tipo da costruire. Può essere un’applicazione, una libreria o semplicemente sottodirectory.
  • BERSAGLIO è il nome dell’app o della libreria.
  • Qt è usato per indicare quali librerie (moduli QT) vengono utilizzati in questo progetto. Poiché la nostra prima app è una piccola GUI, avremo bisogno di Qtcore e Qtgui.

  Aggiungiamo ora il punto di ingresso della nostra applicazione. Utilizzo del file> nuovo file o progetto> C ++> Il file sorgente C ++ dovrebbe svolgere il lavoro.

  

  Segui ancora una volta il mago, nominando il file “principale” e hai finito. Noterai che nel file di progetto, una nuova riga è stata aggiunta automaticamente da QT Creator:

  Template = app target = name_of_the_app qt = core gui greaterthan (qt_major_version, 4): qt += widgets sorgenti += main.CPP

  I file di intestazioni e fonti possono essere aggiunti manualmente con

  Intestazioni += first_file.H secondi_file.H Sources += First_file.CPP Second_file.CPP

  Intestazioni += first_file.H secondi_file.H Sources += First_file.CPP Second_file.CPP

  Se usi i maghi di Qt Creator, questo viene fatto automaticamente.

  Il codice sorgente minimo di un’applicazione QT è

  #includere int principale(int argc, CHAR **argv)  Qapplicazione app (argc, argv); ritorno app.Exec(); > 

  Qapplicazione è una classe molto importante. Si prende cura degli argomenti di input, ma anche di molte altre cose, e in particolare, il Loop di eventi. Il ciclo di eventi è un ciclo che attende l’input dell’utente nelle applicazioni GUI.

  Quando si chiama l’app.Exec () Il ciclo di eventi è stato lanciato.

  Compiliamo questa applicazione. Facendo clic sulla freccia verde in basso a sinistra, QT Creator la compilerà ed eseguirà. E cosa è successo? L’applicazione sembra essere lanciata e non risponde. Questo è in realtà normale. Il ciclo dell’evento è in esecuzione e in attesa di eventi, come i clic del mouse su una GUI, ma non abbiamo fornito alcun evento da elaborare, quindi funzionerà indefinitamente.

  Aggiungiamo qualcosa da visualizzare.

  #includere #includere int principale(int argc, CHAR **argv)  Qapplicazione app (argc, argv); Qpushbutton pulsante ("Ciao mondo !"); pulsante.spettacolo(); ritorno app.Exec(); > 

  Compilalo e … eccolo ! La nostra prima finestra !

  

  Come viene compilato un programma QT

  QT Creator fa il compito di invocare il sistema di build per noi, ma potrebbe essere interessante sapere come vengono compilati i programmi QT.

  Per piccoli programmi, è facile compilare tutto a mano, creando file di oggetti, quindi collegarli. Ma per progetti più grandi, la riga di comando diventa facilmente difficile da scrivere. Se hai familiarità con Linux, potresti sapere che tutti i programmi sono compilati usando un makefile che descrive tutte queste righe di comando da eseguire. Ma per alcuni progetti, anche scrivere un makefile può diventare noioso.

  Qmake è il sistema di costruzione che viene fornito con QT e genera quei makefile per te (ci sono altri sistemi di build che possono essere utilizzati, ma qui diamo un esempio con Qmake). Con una semplice sintassi, produce il makefile utilizzato per compilare un programma QT. Ma questo non è il suo unico scopo. QT utilizza i meta-oggetti per estendere le funzionalità C ++ e Qmake è responsabile della preparazione di un makefile che contiene questa fase di estrazione dei meta-oggetti. Lo vedrai in un altro capitolo.

  Quindi, le app QT sono compilate in 3 passaggi

  1. UN .pro Il file è scritto per descrivere il progetto per compilare
  2. Un makefile viene generato utilizzando Qmake
  3. Il programma è creato utilizzando Fare (O nmake O Jom Su Windows)

  Un bel pulsante

  Questo capitolo fornisce una panoramica dei moduli widgets. Coprirà le proprietà dei widget, lo schema di eredità utilizzato nei widget e anche il sistema genitoriale.

  Ora che abbiamo il nostro pulsante, potremmo voler personalizzarlo un po ‘.

  

  Gli oggetti QT hanno molti attributi che possono essere modificati usando getter e setter. In Qt, se viene chiamato un attributo foo, Il getter e il setter associati avranno queste firme

  T foo() const; vuoto Setfoo(const T); 

  In effetti, QT estende questo sistema di attributi e getter e setter a qualcosa chiamato proprietà. Una proprietà è un valore di qualsiasi tipo a cui è possibile accedere, essere modificato o costante e può avvisare una modifica. Il sistema immobiliare è utile, specialmente nella terza parte (QML). Per ora, useremo “attributo” o “proprietà” per fare la stessa cosa.

  Un qpushbutton ha molte proprietà:

  Quindi possiamo usarli per personalizzare il pulsante.

  Per prima cosa cambiamo il testo e aggiungiamo una descrizione di strumenti

  #includere #includere int principale(int argc, CHAR **argv)  Qapplicazione app (argc, argv); Qpushbutton pulsante; pulsante.SetText("Il mio testo"); pulsante.Setchooltip("Una descrizione di strumenti"); pulsante.spettacolo(); ritorno app.Exec(); > 

  Ecco il risultato:

  

  Possiamo anche cambiare il carattere. In QT, un carattere è rappresentato con la classe QFont. La documentazione fornisce molte informazioni. Siamo particolarmente preoccupati qui con uno dei costruttori di Qfont.

  Qfont(const Qstring E famiglia, int punta = -1, int peso = -1, bool corsivo = falso) 

  Per cambiare il carattere, dobbiamo istanziare una classe QFont e passarla al QpushButton usando SetFont . Il seguente snippet cambierà il carattere in corriere.

  Qfont font ("Corriere"); pulsante.setfont(font); 

  Puoi provare altri parametri del costruttore di Qfont per riprodurre il pulsante rappresentato nella prima immagine in questo capitolo.

  L’impostazione di un’icona non è neanche molto difficile. Un’icona è rappresentata con la classe Qicon. E puoi creare un’icona a condizione che abbia un percorso assoluto (o relativo) nel filesystem. Consiglio di fornire il percorso assoluto in questo esempio. Ma per le considerazioni di distribuzione, è possibile utilizzare il percorso relativo o, meglio, il sistema delle risorse.

  Qicon icona ("/Path/to/my/icona/icona.png "); pulsante.Seticon(icona); 

  Su Linux e alcuni altri sistemi operativi, esiste un modo conveniente per impostare un’icona da un tema icona. Può essere fatto usando il metodo statico:

  Qicon Qicon:::Fromtheme ( const Qstring Enome, const Qicon Ericaderci = Qicon()); 

  Ad esempio, nello screenshot all’inizio di questo capitolo, la faccina deriva dal tema dell’icona di Oxygen KDE ed è stata impostata da:

  pulsante.Seticon(Qicon:::Fromtheme("Face-Smile")); 

  Gerarchia di classe Qt

  Qt usa ampiamente l’eredità, specialmente nel modulo widgets. Il grafico seguente mostra alcune di queste eredità:

  

  Qobject è la classe più elementare in QT. La maggior parte delle classi in QT eredita da questa classe. Qobject offre alcune capacità molto potenti come:

  • Nome oggetto : puoi impostare un nome, come stringa, su un oggetto e cercare oggetti con nomi.
  • Sistema genitoriale (descritto nella sezione seguente)
  • Segnali e slot (descritto nel prossimo capitolo)
  • gestione di eventi

  I widget sono in grado di rispondere agli eventi e utilizzare il sistema genitoriale e i segnali e il meccanismo di slot. Tutti i widget ereditano da Qobject. Il widget più elementare è il qwidget . Qwidget contiene la maggior parte delle proprietà che vengono utilizzate per descrivere una finestra o un widget, posizione e dimensione come.

  Osservazione : in Qt, un widget può anche essere una finestra. Nella sezione precedente, abbiamo visualizzato un pulsante che è un widget, ma appare direttamente come una finestra. Non è necessario una classe “Qwindow”.

  Quasi tutti gli elementi grafici ereditano da Qwidget. Possiamo elencare ad esempio:

  QabstractButton, una classe di base per tutti i tipi di pulsanti qpushbutton qcheckbox qradiobutton qframe, che visualizza un frame qlabel, che visualizza testo o immagine

  Questa eredità viene eseguita al fine di facilitare la gestione delle proprietà. Proprietà condivise come dimensioni e cursori possono essere utilizzate su altri componenti grafici e QabstractButton fornisce proprietà di base che sono condivise da tutti i pulsanti.

  Sistema genitoriale

  Il sistema genitoriale è un modo conveniente per gestire gli oggetti in QT, in particolare i widget. Qualsiasi oggetto che eredita da Qobject può avere un genitore e figli. Questo albero della gerarchia rende molte cose convenienti:

  • Quando un oggetto viene distrutto, anche tutti i suoi figli vengono distrutti. Quindi, chiamando eliminare diventa facoltativo in alcuni casi.
  • Tutti i Qobjects hanno FindChild E FindChildren metodi che possono essere utilizzati per cercare bambini di un determinato oggetto.
  • I widget di figli in un Qwidget compaiono automaticamente all’interno del widget genitore.

  Il seguente frammento che crea un Qpushbutton all’interno di un QpushButton:

  #includere #includere int principale(int argc, CHAR **argv)  Qapplicazione app (argc, argv); Qpushbutton Button1 ("test"); Qpushbutton Button2 ("altro", EButton1); Button1.spettacolo(); ritorno app.Exec(); > 

  

  Puoi anche notare che quando l’applicazione è chiusa, Button1, che viene assegnato sullo stack, è deallocato. Poiché Button2 ha Button1 come genitore, viene anche eliminato. Puoi persino testarlo in QT Creator nella sezione Analisi, cercando una perdita di memoria: non ce ne sarà nessuno.

  Non c’è chiaramente alcun vantaggio nel mettere un pulsante all’interno di un pulsante, ma in base a questa idea, potremmo voler mettere i pulsanti all’interno di un contenitore, che non visualizza nulla. Questo contenitore è semplicemente il qwidget .

  Il seguente codice viene utilizzato per visualizzare un pulsante all’interno di un widget:

  #includere #includere int principale(int argc, CHAR **argv)  Qapplicazione app (argc, argv); Qwidget finestra; finestra.SetFixEdSize(100, 50); Qpushbutton *pulsante = nuovo Qpushbutton("Ciao mondo", Efinestra); pulsante->setgeometria(10, 10, 80, 30); finestra.spettacolo(); ritorno app.Exec(); > 

  Si noti che creiamo un widget a dimensioni fisse (che funge da finestra) utilizzando SetFixEdSize. Questo metodo ha la seguente firma:

  vuoto Qwidget:::SetFixEdSize(int larghezza, int altezza); 

  Abbiamo anche posizionato il pulsante usando setgeometria. Questo metodo ha la seguente firma:

  vuoto Qwidget:::setgeometria(int X, int y, int larghezza, int altezza); 

  Sottoclasse qwidget

  Fino ad ora, abbiamo messo tutto il nostro codice in principale funzione. Questo non è stato un problema per i nostri semplici esempi, ma per applicazioni sempre più complesse potremmo voler dividere il nostro codice in classi diverse. Ciò che viene spesso fatto è creare una classe utilizzata per visualizzare una finestra e implementare tutti i widget contenuti in questa finestra come attributi di questa classe.

  All’interno di QT Creator, è possibile creare automaticamente una nuova classe con file> nuovo file o progetto> C ++> C ++ Classe

  

  Fai ereditare la classe da Qwidget e dovresti ottenere un codice simile a quello di seguito

  #ifndef window_h #define window_h #includere classe Finestra : pubblico Qwidget  Q_Object pubblico: esplicito Finestra(Qwidget *genitore = 0); Segnali: pubblico slot: >; #finisci se // window_h 

  #includere "finestra.H" Finestra:::Finestra(Qwidget *genitore) : Qwidget(genitore) <> 

  Puoi vedere che Qt Creator genera automaticamente un modello di classe. Si noti che ci sono alcuni nuovi elementi nell’intestazione:

  • IL Q_Object macro.
  • Una nuova categoria di metodi: Segnali
  • Una nuova categoria di metodi: slot pubblici

  Tutti questi elementi saranno spiegati nel prossimo capitolo e nessuno di loro è necessario ora. L’implementazione della finestra viene eseguita nel costruttore. Possiamo dichiarare le dimensioni della finestra, così come i widget che questa finestra contiene e le loro posizioni. Ad esempio, l’implementazione della finestra precedente che contiene un pulsante può essere eseguita in questo modo:

  #includere #includere "finestra.H" int principale(int argc, CHAR **argv)  Qapplicazione app (argc, argv); Finestra finestra; finestra.spettacolo(); ritorno app.Exec(); > 

  #ifndef window_h #define window_h #includere classe Qpushbutton; classe Finestra : pubblico Qwidget  pubblico: esplicito Finestra(Qwidget *genitore = 0); privato: Qpushbutton *M_Button; >; #finisci se // window_h 

  #includere "finestra.H" #includere Finestra:::Finestra(Qwidget *genitore) : Qwidget(genitore)  // Imposta dimensione della finestra SetFixEdSize(100, 50); // Crea e posiziona il pulsante M_Button = nuovo Qpushbutton("Ciao mondo", Questo); M_Button->setgeometria(10, 10, 80, 30); > 

  Si prega di notare che non è necessario scrivere un distruttore per eliminare M_Button . Con il sistema genitoriale, quando l’istanza della finestra è fuori dallo stack, il M_Button viene eliminato automaticamente.

  Ulteriori letture

  Una migliore panoramica di QpushButton è riportata in questa pagina wiki come usare qpushbutton

  Il modello di osservatore

  Quasi tutti gli strumenti dell’interfaccia utente hanno un meccanismo per rilevare un’azione dell’utente e rispondere a questa azione. Alcuni di loro usano callbacks, altri usano ascoltatori, Ma fondamentalmente, tutti sono ispirati dallo modello di osservatore.

  Il motivo dell’osservatore viene utilizzato quando un osservabile L’oggetto vuole avvisare gli altri osservatore oggetti su un cambiamento di stato. Ecco alcuni esempi concreti:

  • Un utente ha fatto clic su un pulsante e dovrebbe essere visualizzato un menu.
  • Una pagina Web ha appena finito di caricare e un processo dovrebbe estrarre alcune informazioni da questa pagina caricata.
  • Un utente scorre attraverso un elenco di elementi (in un app store, ad esempio) e ha raggiunto la fine, quindi devono essere caricati più articoli.

  Il modello Observer viene utilizzato ovunque nelle applicazioni GUI e spesso porta ad un codice a placca caldaia. QT è stato creato con l’idea di rimuovere questo codice a calcia e fornire una bella sintassi pulita. Il meccanismo di segnale e slot lo rende possibile.

  Segnali e slot

  Invece di avere oggetti e osservatori osservabili e registrarli, QT fornisce due concetti di alto livello: Segnali E slot.

  • UN segnale è un messaggio che un oggetto può inviare, di solito per segnalare una modifica dello stato.
  • UN fessura è una funzione che accetta e risponde a un segnale.

  Ecco alcuni esempi di segnali e slot della nostra famosa classe Qpushbutton.

  Come puoi vedere, i loro nomi sono abbastanza espliciti. Questi segnali vengono inviati quando l’utente fa clic (preme, quindi rilascia), preme o rilascia il pulsante.

  Ecco alcuni slot, da classi diverse.

  • Qapplication :: smetti
  • Qwidget :: setabled
  • Qpushbutton :: setText

  Per rispondere a un segnale, uno slot deve essere collegato a un segnale. Qt fornisce il metodo Qobject ::Collegare. È usato in questo modo, con le due macro SEGNALE E FESSURA .

  Fooobjecta *fooa = nuovo Fooobjecta(); Fooobjectb *Foob = nuovo Fooobjectb(); Qobject:::Collegare(fooa, SEGNALE (scoperto()), Foob, FESSURA (Baz())); 

  Questo esempio presuppone che FooObjecta abbia un segnale scoperto e fooobjectB ha uno slot Baz.

  Devi scrivere la firma del segnale e lo slot all’interno delle due macro SEGNALE E FESSURA. Se vuoi maggiori informazioni su ciò che fanno queste macro, leggi l’ultima sezione di questo capitolo.

  Osservazione : Fondamentalmente, i segnali e le slot sono metodi, che potrebbero o non potrebbero avere argomenti, ma che non restituiscono mai nulla. Mentre la nozione di un segnale come metodo è insolita, uno slot è in realtà un metodo reale e può essere chiamata come al solito con altri metodi o mentre risponde a un segnale.

  Trasmissione di informazioni

  I segnali e il meccanismo delle slot sono utili per rispondere ai clic dei pulsanti, ma può fare molto di più. Ad esempio, può anche essere utilizzato per comunicare informazioni. Diciamo che suonando una canzone, è necessario una barra di avanzamento per mostrare quanto tempo rimane prima che la canzone sia finita. Un lettore multimediale potrebbe avere una classe utilizzata per verificare l’avanzamento dei media. Un’istanza di questa classe potrebbe periodicamente inviare un tic tac segnale, con il valore di avanzamento. Questo segnale può essere collegato a un Qprogressbar, che può essere utilizzato per visualizzare i progressi.

  L’ipotetica classe utilizzata per verificare i progressi potrebbe avere un segnale che ha questa firma:

  vuoto MediaProgressManager:::tic tac(int milisecondi); 

  E sappiamo dalla documentazione che il Qprogressbar ha questo slot:

  vuoto Qprogressbar:::valore impostato(int valore); 

  Puoi vedere che il segnale e lo slot hanno lo stesso tipo di parametri, in particolare il tipo. Se si collega un segnale a uno slot che non condivide lo stesso tipo di parametri, quando la connessione viene eseguita (a tempo di esecuzione) riceverai un avviso come:

  Qobject:::Collegare: Incompatibile mittente/ricevitore argomenti 

  Questo perché il segnale trasmette le informazioni sullo slot usando i parametri. Il primo parametro del segnale viene passato al primo dello slot, e lo stesso per il secondo, il terzo e così via.

  Il codice per la connessione sembrerà così:

  MediaProgressManager *manager = nuovo MediaProgressManager(); Qprogressbar *progresso = nuovo Qprogressbar(finestra); Qobject:::Collegare(manager, SEGNALE (tic tac(int), progresso, FESSURA (valore impostato(int))); 

  Puoi vedere che devi fornire una firma all’interno del SEGNALE E FESSURA macro, fornendo il tipo di valori che vengono passati attraverso i segnali. Puoi anche fornire il nome della variabile se lo si desidera. (In realtà è ancora meglio).

  Caratteristiche di segnali e slot

  • Un segnale può essere collegato a più slot
  • Molti segnali possono essere collegati a uno slot
  • Un segnale può essere collegato a un segnale: è inoltrata il segnale. Il secondo segnale viene inviato se viene inviato il primo segnale.

  Esempi

  Rispondere a un evento

  Ricorda la nostra app Button? Proviamo a fare davvero qualcosa con questa app, come essere in grado di chiuderla facendo clic sul pulsante. Sappiamo già che QpushButton fornisce il Clicato segnale. Dobbiamo anche sapere che la Qapplication fornisce il esentato slot, che chiude l’applicazione.

  Per fare un clic su un pulsante Chiudi l’app, dobbiamo collegare il segnale Clicato emesso dal pulsante al esentato slot di questa istanza di qapplicazione. Possiamo modificare il codice dalla sezione precedente per farlo, ma prima di farlo, potresti chiederti come accedere all’istanza di Qapplication mentre sei in un’altra classe. In realtà, è piuttosto semplice, poiché esiste una funzione statica nella Qapplication, con la seguente firma, che viene utilizzata per ottenerla:

  Qapplicazione * Qapplicazione:::esempio() 

  Questo porta alla seguente modifica del nostro codice precedente:

  #includere "finestra.H" #includere #includere Finestra:::Finestra(Qwidget *genitore) : Qwidget(genitore)  // Imposta dimensione della finestra SetFixEdSize(100, 50); // Crea e posiziona il pulsante M_Button = nuovo Qpushbutton("Ciao mondo", Questo); M_Button->setgeometria(10, 10, 80, 30); // nuovo: crea la connessione Collegare(M_Button, SEGNALE (Clicato()), Qapplicazione:::esempio(), FESSURA (esentato())); > 

  Quando si fa clic sul pulsante all’interno della finestra, l’applicazione smetterà.

  Trasmettere informazioni con segnali e slot

  Ecco un esempio più semplice per la trasmissione delle informazioni. Visualizza solo una barra di avanzamento e un cursore (creato da Qslider) all’interno di una finestra e mentre il cursore viene spostato, il valore della barra di avanzamento è sincronizzato con una connessione molto semplice.

  I segnali e le slot interessanti sono:

  vuoto Qslider:::valutato(int valore); vuoto Qprogressbar:::valore impostato(int valore); 

  QSlider emette automaticamente il segnale valutato con il nuovo valore passato come parametro quando il valore viene modificato e il metodo setvalue di Qprogressbar viene utilizzato, come abbiamo visto, per impostare il valore della barra di avanzamento.

  Questo porta al seguente codice:

  #includere #includere #includere int principale(int argc, CHAR **argv)  Qapplicazione app (argc, argv); // Crea una finestra del contenitore Qwidget finestra; finestra.SetFixEdSize(200, 80); // Crea una barra di avanzamento // con l'intervallo tra 0 e 100 e un valore iniziale di 0 Qprogressbar *barra di avanzamento = nuovo Qprogressbar(Efinestra); barra di avanzamento->SetRange(0, 100); barra di avanzamento->valore impostato(0); barra di avanzamento->setgeometria(10, 10, 180, 30); // Crea un cursore orizzontale // con l'intervallo tra 0 e 100 e un valore iniziale di 0 Qslider *Slider = nuovo Qslider(Efinestra); Slider->setorientamento(Qt:::Orizzontale); Slider->SetRange(0, 100); Slider->valore impostato(0); Slider->setgeometria(10, 40, 180, 30); finestra.spettacolo(); // connessione // Questa connessione imposta il valore della barra di avanzamento // mentre il valore del cursore cambia Qobject:::Collegare(Slider, SEGNALE (valutato(int), barra di avanzamento, FESSURA (valore impostato(int))); ritorno app.Exec(); > 

  Aspetto tecnico

  Questa sezione può essere saltata per ora se vuoi programmare solo con QT. Sappi solo che devi mettere SEGNALE E FESSURA intorno ai segnali e alle slot mentre chiama Connect . Se vuoi sapere come funziona QT, è meglio leggere questo.

  Il meta oggetto

  Qt fornisce a Meta-oggetto sistema. Meta-oggetto (letteralmente “sull’oggetto”) è un modo per ottenere alcuni paradigmi di programmazione che sono normalmente impossibili da ottenere con C ++ puro come:

  • Introspezione : capacità di esaminare un tipo a tempo di esecuzione
  • Chiamate di funzione asincrona

  Per utilizzare tali funzionalità di meta-oggetto in un’applicazione, è possibile sottoclasse Qobject e contrassegnarlo in modo che il compilatore Meta-Object (MOC) possa interpretarlo e tradurlo.

  Il codice prodotto dal MOC include segnali e firme delle slot, metodi utilizzati per recuperare le meta-informazioni da quelle classi contrassegnate, gestire le proprietà. È possibile accedere a tutte queste informazioni utilizzando il seguente metodo:

  const QmetaObject * Qobject:::Metaobject () const 

  La classe QmetaObject contiene tutti i metodi che si occupano di meta-oggetti.

  Macro importanti

  La macro più importante è Q_Object. Le connessioni del segnale e la loro sintassi non possono essere interpretate da un normale compilatore C ++. Il MOC viene fornito per tradurre la sintassi QT come “Connect”, “Segnali”, “Slot”, ecc. In una normale sintassi C ++. Questo viene fatto specificando il Q_Object macro nell’intestazione contenente definizioni di classe che utilizzano tale sintassi.

  classe Mywidget : pubblico Qwidget  Q_Object pubblico: Mywidget(Qwidget *genitore = 0); > 

  Altre macro marker per MOC sono

  • Segnali
  • pubblico / protetto / privato slot

  che segnano i diversi metodi che devono essere estesi.

  SEGNALE E FESSURA sono anche due macro molto importanti e utili. Quando viene emesso un segnale, il sistema meta-oggetto viene utilizzato per confrontare la firma del segnale, per controllare la connessione e trovare lo slot usando la sua firma. Queste macro vengono effettivamente utilizzate per convertire la firma del metodo fornito in una stringa che corrisponde a quella memorizzata nel meta-oggetto.

  Creazione di segnali e slot personalizzati

  Questo capitolo copre la seconda parte di segnali e slot: implementazione di segnali e slot personalizzati.

  Creare slot e segnali personalizzati è davvero semplice. Gli slot sono come metodi normali, ma con piccole decorazioni in circolazione, mentre i segnali richiedono poca o nessuna implementazione.

  Creare segnali e slot personalizzati è molto semplice. È descritto dalla seguente lista di controllo:

  • aggiungere Q_Object macro
  • aggiungere Segnali sezione e prototipi di segnali di scrittura
  • aggiungere slot pubblici O slot protetti O slot privati sezioni e prototipi di slot di scrittura
  • Implementa gli slot come metodi normali
  • stabilire connessioni

  Creazione di slot personalizzati

  Per implementare uno slot, dobbiamo prima fare in modo che la classe sia in grado di inviare segnali e avere slot (vedi il capitolo precedente). Questo viene fatto impostando il Q_Object Macro nella dichiarazione di classe (spesso nell’intestazione).

  Successivamente, uno slot dovrebbe essere dichiarato nella sezione corrispondente e implementato come metodo normale.

  Infine, gli slot sono collegati ai segnali.

  Creazione di segnali

  Per quanto riguarda le slot, dobbiamo prima aggiungere il Q_Object macro.

  I segnali dovrebbero anche essere dichiarati nel Segnali sezione e non è necessario implementare.

  Vengono emessi usando il emettere parola chiave:

  emettere Mysignal(); 

  Si noti che per inviare segnali con parametri, è necessario passarli nell’emissione del segnale:

  emettere Mysignal(Primo Parametro, Secondo parametro ..); 

  Esempio

  Creazione di slot personalizzati

  Cominciamo con la nostra finestra con il pulsante:

  #ifndef window_h #define window_h #includere classe Qpushbutton; classe Finestra : pubblico Qwidget  pubblico: esplicito Finestra(Qwidget *genitore = 0); privato: Qpushbutton *M_Button; >; #finisci se // window_h 

  #includere "finestra.H" #includere Finestra:::Finestra(Qwidget *genitore) : Qwidget(genitore)  // Imposta dimensione della finestra SetFixEdSize(100, 50); // Crea e posiziona il pulsante M_Button = nuovo Qpushbutton("Ciao mondo", Questo); M_Button->setgeometria(10, 10, 80, 30); > 

  Potremmo voler rimuovere la nostra connessione precedente che fa uscire dall’applicazione mentre facciamo clic sul pulsante. Ora, lo vogliamo, quando fai clic sul pulsante, il testo viene modificato. Più precisamente, vogliamo che il pulsante possa essere controllato, E che, quando controllato, mostra “controllato” e quando non controllato, ripristina “Hello World”.

  Qpushbutton non implementa uno slot così specifico, quindi dobbiamo implementarlo da soli. Come affermato in precedenza, dobbiamo aggiungere il Q_Object macro.

  classe Finestra : pubblico Qwidget  Q_Object pubblico: esplicito Finestra(Qwidget *genitore = 0); privato: Qpushbutton *M_Button; >; 

  Aggiungiamo anche il nostro slot personalizzato. Dal momento che stiamo cercando di reagire dal pulsante controllato e poiché il segnale corrispondente è

  vuoto Qpushbutton:::Clicato(bool controllato) 

  Potremmo implementare uno slot che ha questa firma:

  vuoto Finestra:::slotbuttonclicking(bool controllato); 

  Il più delle volte, per convenzione, implementiamo slot privati ​​e protetti prefisandoli con “slot”. Qui, non siamo interessati a esporre questo slot come funzione pubblica, possiamo renderlo privato. La nuova intestazione è allora

  #ifndef window_h #define window_h #includere classe Qpushbutton; classe Finestra : pubblico Qwidget  Q_Object pubblico: esplicito Finestra(Qwidget *genitore = 0); privato slot: vuoto slotbuttonclicking(bool controllato); privato: Qpushbutton *M_Button; >; #finisci se // window_h 

  L’implementazione di questo slot è

  vuoto Finestra:::slotbuttonclicking(bool controllato)  Se (controllato)  M_Button->SetText("Controllato"); > altro  M_Button->SetText("Ciao mondo"); > > 

  Dobbiamo rendere il pulsante controllare e stabilire la connessione, dobbiamo aggiungere questo codice nel costruttore:

  M_Button->Setcheckable(VERO); Collegare(M_Button, SEGNALE (Clicato(bool), Questo, FESSURA (slotbuttonclicking(bool))); 

  Il codice risultante è quindi:

  #includere "finestra.H" #includere Finestra:::Finestra(Qwidget *genitore) : Qwidget(genitore)  // Imposta dimensione della finestra SetFixEdSize(100, 50); // Crea e posiziona il pulsante M_Button = nuovo Qpushbutton("Ciao mondo", Questo); M_Button->setgeometria(10, 10, 80, 30); M_Button->Setcheckable(VERO); Collegare(M_Button, SEGNALE (Clicato(bool), Questo, FESSURA (slotbuttonclicking(bool))); > vuoto Finestra:::slotbuttonclicking(bool controllato)  Se (controllato)  M_Button->SetText("Controllato"); > altro  M_Button->SetText("Ciao mondo"); > > 

  Emettendo segnali personalizzati

  Sulla base dell’esempio precedente, vogliamo chiudere l’applicazione se il pulsante viene cliccato (selezionato o incontrollato) 10 volte. Dobbiamo prima implementare un contatore che conterà il numero di clic. Queste modifiche lo implementano:

  classe Finestra : pubblico Qwidget  Q_Object pubblico: esplicito Finestra(Qwidget *genitore = 0); privato slot: vuoto slotbuttonclicking(bool controllato); privato: int m_counter; Qpushbutton *M_Button; >; 

  Finestra:::Finestra(Qwidget *genitore) : Qwidget(genitore)  // Imposta dimensione della finestra SetFixEdSize(100, 50); // Crea e posiziona il pulsante M_Button = nuovo Qpushbutton("Ciao mondo", Questo); M_Button->setgeometria(10, 10, 80, 30); M_Button->Setcheckable(VERO); m_counter = 0; Collegare(M_Button, SEGNALE (Clicato(bool), Questo, FESSURA (slotbuttonclicking(bool))); > vuoto Finestra:::slotbuttonclicking(bool controllato)  Se (controllato)  M_Button->SetText("Controllato"); > altro  M_Button->SetText("Ciao mondo"); > m_counter ++; > 

  Ora, dobbiamo creare un segnale personalizzato utilizzato per avvisare altri componenti, che il contatore ha raggiunto 10. Per dichiarare un segnale, dobbiamo aggiungere un

  Segnali 

  sezione nell’intestazione. Potremmo anche dichiarare un segnale con la seguente firma:

  vuoto Finestra:::controllato() 

  La classe di intestazione viene quindi dichiarata come seguita:

  classe Finestra : pubblico Qwidget  Q_Object pubblico: esplicito Finestra(Qwidget *genitore = 0); Segnali: vuoto controllato(); privato slot: vuoto slotbuttonclicking(bool controllato); privato: int m_counter; Qpushbutton *M_Button; >; 

  Anche se il segnale viene dichiarato come metodo, non è necessario implementarlo. Il compilatore meta-oggetto viene utilizzato per farlo.

  Ora dobbiamo emettere il segnale quando il contatore raggiunge 10. È semplicemente fatto nello slot:

  vuoto Finestra:::slotbuttonclicking(bool controllato)  Se (controllato)  M_Button->SetText("Controllato"); > altro  M_Button->SetText("Ciao mondo"); > m_counter ++; Se (m_counter == 10)  emettere controllato(); > > 

  Dobbiamo scrivere la parola chiave emettere Per inviare il segnale.

  Collegamento del segnale appena creato allo slot smettere viene eseguito come al solito:

  Collegare(Questo, SEGNALE (controllato()), Qapplicazione:::esempio(), FESSURA (esentato())); 

  Il codice finale è:

  #ifndef window_h #define window_h #includere classe Qpushbutton; classe Finestra : pubblico Qwidget  Q_Object pubblico: esplicito Finestra(Qwidget *genitore = 0); Segnali: vuoto controllato(); privato slot: vuoto slotbuttonclicking(bool controllato); privato: int m_counter; Qpushbutton *M_Button; >; #finisci se // window_h 

  #includere "finestra.H" #includere #includere Finestra:::Finestra(Qwidget *genitore) : Qwidget(genitore)  // Imposta dimensione della finestra SetFixEdSize(100, 50); // Crea e posiziona il pulsante M_Button = nuovo Qpushbutton("Ciao mondo", Questo); M_Button->setgeometria(10, 10, 80, 30); M_Button->Setcheckable(VERO); m_counter = 0; Collegare(M_Button, SEGNALE (Clicato(bool), Questo, FESSURA (slotbuttonclicking(bool))); Collegare(Questo, SEGNALE (controllato()), Qapplicazione:::esempio(), FESSURA (esentato())); > vuoto Finestra:::slotbuttonclicking(bool controllato)  Se (controllato)  M_Button->SetText("Controllato"); > altro  M_Button->SetText("Ciao mondo"); > m_counter ++; Se (m_counter == 10)  emettere controllato(); > > 

  E puoi provare a verificarlo dopo aver fatto clic sul pulsante dieci volte, l’applicazione smetterà.

  Risoluzione dei problemi

  Durante la compilazione del programma, soprattutto quando si aggiunge la macro Q_Object, potresti avere questo errore di compilazione.

  principale.CPP:(.testo._Zn6windowd2ev[_Zn6windowd5ev"+0x3): non definito riferimento A `vtable per Finestra' 

  Ciò è dovuto al compilatore meta-oggetto che non viene eseguito su una classe che dovrebbe avere meta-oggetto. Dovresti RERUN QMAKE, facendo build> esegui qmake.

  Widget

  Il pulsante di opzione è un componente GUI standard. È spesso usato per fare una scelta unica da un elenco. In QT, il Qradiobutton viene utilizzato per creare pulsanti di opzione.

  Grazie a una bella eredità, un qradiciobutton si comporta proprio come un qpushbutton. Tutte le proprietà del Qpushbutton sono anche le stesse nel Qradiobutton e tutto ciò che è stato appreso nel secondo capitolo può essere riutilizzato qui.

  Per impostazione predefinita, i qradibutton non sono raggruppati, quindi molti di essi possono essere controllati contemporaneamente. Per avere il comportamento “esclusivo” di molti pulsanti di radio, dobbiamo usare QButtongRoupup . Questa classe può essere usata in questo modo: allochiamo un nuovo gruppo di pulsanti e lo allegiamo all’oggetto genitore. Si noti che l’oggetto genitore potrebbe essere il mainwindow o “questo”:

  QButtongRoup *buttongroup = nuovo QButtongRoup(oggetto); // Aggiungi pulsanti nel gruppo pulsanti buttongroup->addButton(Button1); buttongroup->addButton(Button2); buttongroup->addButton(Button3); . 

  Quello che vogliamo è creare un raccoglitore di menu. In una finestra, è necessario visualizzare un elenco di piastre deliziose con pulsanti di opzione e un pulsante utilizzato per selezionare la piastra scelta deve essere visualizzato.

  Ovviamente, non succederà nulla (ora) quando vengono cliccati i pulsanti.

  Segnali e slot

  Ecco un esempio su segnali e slot. Scriveremo un’applicazione con due pulsanti. Il primo pulsante dovrebbe visualizzare informazioni su QT.

  Ti forniamo il seguente codice da completare:

  #includere #includere int principale(int argc, CHAR **argv)  Qapplicazione app (argc, argv); Qwidget finestra; finestra.SetFixEdSize(100, 80); Qpushbutton *ButtonInfo = nuovo Qpushbutton("Informazioni", Efinestra); ButtonInfo->setgeometria(10, 10, 80, 30); Qpushbutton *ButtonQuit = nuovo Qpushbutton("Esentato", Efinestra); ButtonQuit->setgeometria(10, 40, 80, 30); finestra.spettacolo(); // Aggiungi il tuo codice qui ritorno app.Exec(); > 

  Per visualizzare le informazioni su QT, è necessario utilizzare il seguente metodo

  vuoto Qapplicazione:::AboutQt(); 

  Puoi anche aggiungere icone sui pulsanti o ridimensionarli. Ovviamente, il pulsante “smettila” dovrebbe essere più importante, quindi perché non renderlo più grande?

  Ma ti consigliamo davvero di provare a capirlo da solo come risolvere questi esercizi.

  QT per principianti: trovare informazioni nella documentazione

  La documentazione di QT è un’informazione molto preziosa. È il posto dove trovare qualunque cosa correlato a Qt. Ma la documentazione di QT non è un tutorial su come usare QT. È una raccolta di tutte le informazioni relative alle classi, nonché ad alcuni esempi. L’obiettivo di questo capitolo è di presentarti alla documentazione come base per la programmazione con QT.

  Dove trovare la documentazione

  La migliore fonte di documentazione è su Internet, in questa rete di sviluppatori:

  Fornisce il documento completo, così come alcuni dottori, che gli utenti possono aggiungere. Questi dottori danno più esempi ed evidenziano alcuni punti difficili. La documentazione online ha anche un motore di ricerca piuttosto potente e contiene anche tutta la documentazione per tutte le versioni di QT.

  Mentre la versione online richiede una connessione Internet, i dottori sono ancora disponibili. Se il QTSDK è stato installato correttamente, la documentazione che corrisponde alla versione corrente di QT avrebbe dovuto essere installata e il Aiuto La sezione di Qtcreator non deve essere vuota. Puoi anche usare Assistente QT, Questo è un browser DOC autonomo.

  Sezioni importanti della documentazione

  Se stai eseguendo il visualizzatore di documentazione offline, in QT Creator o QT Assistant, troverai nel riassunto che ci sono documentazioni per diversi componenti dell’SDK QT.

  • Documentazione di Qt Assistant
  • Documentazione di Designer Qt
  • Documentazione linguista QT
  • Documentazione Qmake
  • Documentazione di riferimento QT

  Il componente più importante è, ovviamente, la documentazione di riferimento QT.

  La documentazione QT fornisce una bella introduzione di molti componenti e anche la documentazione per tutte le classi in QT. Questo elenco è elencato nella pagina tutte le classi. Un’altra pagina interessante è la pagina che elenca tutti i moduli. Questa pagina fornisce informazioni sui diversi componenti in QT.

  In questo tutorial, useremo principalmente questi moduli

  Anche la funzione di ricerca è abbastanza importante. Se conosci la classe da utilizzare e desideri trovare la documentazione, puoi digitare il nome di questa classe nel campo di ricerca (online) o nel filtro nell’indice (offline). Puoi anche cercare metodi e elenchi in questi campi.

  Sfoglia la documentazione di una classe

  La documentazione delle classi è sempre organizzata allo stesso modo:

  • Nome e breve descrizione della classe
  • Eredità
  • Enumerazioni
  • Proprietà
  • Metodi pubblici
  • Slot pubblici
  • Segnali
  • Metodi protetti

  Prendiamo la classe QtextEdit come esempio.

  Qt ha un’interfaccia C?

  Ho trovato risposte contrastanti sul web – alcuni lo dicono, alcuni dicono che non lo fa. Non sono stato in grado di trovare alcun dettaglio nella documentazione QT ufficiale. Così Qt ha attacchi C o no?

  ha chiesto il 13 novembre 2009 alle 10:53

  6.041 11 11 badge d’oro 48 48 badge d’argento 50 50 badge di bronzo

  7 Risposte 7

  Risposta breve: no.

  Se hai bisogno di un toolkit completo GUI per C, puoi usare GTK+.

  Per usare Qt, tu dovere avere un compilatore C ++. Ma ciò non significa che la “logica dell’applicazione” non possa essere scritta in C, compilata con un compilatore C e attentamente collegata alla parte C ++ (la GUI con QT). Questa logica dell’applicazione può essere generica, collegabile ad altri eseguibili (Pure-C, C/C ++ misto, ecc.) Tutto dipende da ciò di cui hai bisogno.

  QT è ottimo per C ++, tuttavia, ed è una buona ragione per decidere di usare C ++ per un particolare progetto, anche se si desidera ancora tenere parti in C.