QT Creator tutoriál

  • Na tvorbě tohoto tutoriálu se podíleli (díky moc všem):
    • Michal Toth
    • Martin Vlach
    • Petr Švenda

Prosíme o shovívavost: vlastníci Qt a jednotlivé verze Qt Creatoru a Qt se mění rychleji než dokážeme tento návod aktualizovat. Pokud se zase změní a při troše dobré vůle, kterou předpokládáme, si potřebné informace najdete sami, případně dáte vědět Dr. Petrovi Švendovi.

Windows

  • Aktuální verzi QT Creator si spolu s SDK stáhnete zde: http://www.qt.io/download-open-source/
    • původní verze dostupné na nokia.com nyní odkazují na placenou varinatu na qt.digia.com/, open-source a zdarma varianta je dostupná na qt-project.org
  • Po instalaci QT Creator je potřeba nahradit verzi MinGW (nutné jen pro C++, v PB071 není třeba řešit), ktera se s QT defaultně nainstaluje za verzi TDM-MinGW dostupnou zde: http://tdm-gcc.tdragon.net/
    • Jde o kompletni vymenu podadresare c:\Qt\2010.04\MinGW\ (resp. mista, kde bude QT nainstalovano) resp. nastavení cesty k MinGW\bin do proměnné PATH
    • MinGW verze 4.4.0 a nižší hlásí při překladu korektního programu s přepínačem -ansi chybu '::swprintf' has not been declared

Linux a ostatní

  • Většina distribucí obsahuje qtcreator v repozitářích
  • Aktuální verzi QT Creator si stáhnete (společná stránka pro „downloady” do všech OS) zde: http://qt-project.org/downloads

CMake v učebnách na FI

Od semestru Jaro 2016 se v PB071 používají projekty CMake. Návod k spuštění projektu:

Windows

  • ujistěte se, že máte spuštěné QtCreator (Community Edition),
    • StartAll ProgramsIDEQt 5.4.0QtCreator (Community)
    • NE … → IDE → QtCreator 3.0.1, tato verze nefunguje!
  • FileOpen file or project,
  • v adresáři s projektem otevřete CMakeLists.txt,
  • v okně Build Location klikněte Next,
  • v okně Run CMake v poli Generator vyberte MinGW Generator (Desktop Qt 5.4.0 MinGW 32bit), pak stistkěte Run CMake
  • pokud skončí, povolí se Finish, tato operace může bohužel na Windows trvat i 1-2 minuty

Linux

Nepoužívejte QtCreator v distribuční verzi, ale QtCreator z modulů. Do terminálu napište:

module add qtsdk
qtcreator

Pak postupujte stejně jako pro Windows, ale místo MinGW generátoru vyberte Unix Generator.

Konfigurace a výběr cíle (Linux, Windows)

Může se stát, že po spuštění projektu se neotevře terminál, případně se výstup objevuje na panelu Application Output. Povolte výstup do terminálu:

  • na levém panelu vyberte Projects,
  • na horním panelu tesně nad Build Settings vyberte místo Build kartu Run,
  • pod Run je „zaškrtávátko“ Run in terminal, které zaškrtněte

Pokud CMake obsahuje více cílů, na stejné obrazovce můžete cíl změnit pod Run configuration. POZOR, tato změna může odšrktnout Run in terminal, nezapoměnte ji povolit zpět.

Otázky a odpovědi

  • Problém: Qt Creator nějakým způsobem nefunguje
    • Zkontrolujte, že máte spuštěnou správnou verzi (2015 – Community verze)
  • Problém: Qt Creator nezobrazuje menu
    • Zrušte proměnnou prostředí QT_QPA_PLATFORMTHEME pomocí unset QT_QPA_PLATFORMTHEME a poté spusťte qtcreator
  • Problém: přeložený program nezobrazuje žádný výstup v zobrazeném terminálu
    • Nastavte jako terminál „xterm -e“ (Tools → Options → Environment → General → Terminal)
  • Problém: nelze ladit
    • Ověřte, že překládáte a spouštíte cíl Debug
    • Jako rychlý hotfix můžete přidat -g do QMAKE_CFLAGS
  • Problém: nelze překládat (chyba typu používejte -std=c99)
    • Nastavte QMAKE_CFLAGS podle návodu
  • Problém: Po kompilaci a spuštění vytvořené binárky mimo prostředí QT je zobrazena hláška „The program can't start because libgcc_s_dw2-1.dll is missing…“
    • Řešení: V Projects → Build Settings → General odškrtnout „Shadow Building“. Do *.pro souboru projektu přidat řádek „QMAKE_LFLAGS += -static-libgcc -static-libstdc++“. Řěšení pro zapnutý shadow build zatím není známé.
  • Problém: Po nastavení parametru překladače -ansi se objevuje při překladu korektního kódu chyba '::swprintf' has not been declared
    • Řešení: Problémem je chyba v g++ MinGW verze 4.4.0 a nižší. Přechodem na verzi g++ 4.4.1 a vyšší je problém odstraněn. Návod.

Příprava prostředí

Změnu jazyka prostředí IDE QT Creator je možné učinit v menu: Nástroje → Volby → Obecné → Jazyk a vybrat požadovaný jazyk. (resp. Tools → Options → Environment → Language) Preferujeme anglický jazyk. ;-)

QT IDE má vlastní sadu klávesových zkratek, která vám nemusí vyhovovat. Klávesové zkratky si můžete předefinovat v nabídce Tools→Options→Environment→Keyboard. Předefinování můžete provést pro každou zkratku zvlášť, nebo použít předpřipravenou sadu pro některá jiná IDE prostřednitvím tlačítka Import.

Jedním z možných mapování je rozšířené mapování používané v MS Visual Studiu ze souboru MS_Visual_C++.kms

Klávesové zkratky výrazně usnadňují práci a existují téměř pro všechny operace v rámci IDE. Pokud tedy nějakou volbu děláte často (alespoň jednou za hodinu), zjistěte si její zkratku a naučte se ji.

Nový projekt

Nový projekt založíme pomocí nabídky File → New File or Project. Bude nás zajímat projekt v C nebo C++. Zvolíme tedy Other Project → Plain C Project nebo Plain C++ Project podle zvoleného jazyka.

Zvolíme vhodné jméno nového projektu a jeho umístění. Zde projekt Test1 a umístění v adresáři D:\QtSDK\MyProjects. Tuhle lokaci můžeme použít jako výchozí pro všechny budoucí projekty po zakšrtnutí Use as default project location. Stiskneme Next.

V dalším kroku máme možnost provázat projekt přímo se systémem verzování zdrojových kódů (nyní nepoužijeme) a vidíme nově vznikající soubory. Zde se jedná o soubor main.c (resp. main.cpp) obsahující náš program a Test1.pro obsahující konfiguraci překladu projektu, která je později použita na generování Makefile. Obsah souboru *.pro přímo nesouvisí s jazykem C/C++ - jde o interní konfiguraci QT Creatoru. Každé IDE obsahuje nějaký podobný soubor (ale s jinou strukturou), aby se dalo určit, které zdrojové soubory mají být zahrnuty do překladu, jaké přepínače mají být použity apod.

Dalším krokem je výběr cílové platformy a cesty ku skompilovaným souborům projektu. Pro nás je zajímavá pouze platforma (Target) Desktop. Dle libosti si lze nastavit ukládaní vytvořených skompilovaných souborů do stejné složky jako jsou zdrojové soubory (odškrtnout Use Shadow Building) nebo do nových složek, které jde nastavit samostatne pro módy Debug i Release.

Po stisku tlačítka Finish je automaticky vygenerován ukázkový projekt Hello World!, který umí svůj výstup vypsat na konzoli. Vygenerovaný zdrojový kód je v jazyce C/C++. V levé části okna je seznam souborů zařazených v projektu, dvojklikem si je zobrazíme v editačním okně.

V nové verzi QT Creator 2.4.1 je už vytvářený kód čistě v jazyce C/C++ programů a tedy vygenerovaný zdrojový kód už nepoužíva QT knihovny. Všimněte si, že během psaní kódu (např. zde změna hlavičkového souboru se automaticky nabízí doplňování možných variant - tzv. Code Completition (má dnes většina moderních IDE), který se dá vyvolat i manuálně (ctrl + space). Automaticky se nabízí možné hlavičkové soubory začínající na již napsanou část řetězce nebo například metody objektu po napsání . resp. → . Toto je velice příjemná věc, neboť není třeba neustále skákat do deklarace třídy pro zjištění přesného jména metody, kterou potřebujeme.

Editace

V průběhu psaní kódu dochází nejen k nabízení doplnění psaného textu (Code Completition), ale i k upozorňování na chybné konstrukce (zde viditelný chybějící středník). QT IDE provádí na pozadí průběžně pokus o kompilaci a mezi výsledky přímo promítá do editačního okna a červeně podtrhuje problematické části kódu. Spoustu chyb syntaxe tak lze odhalit ještě předtím, než sami vyvoláte kompilaci. Pokud je kód podtržen a je upozorněno na chybu, tak problém bývá typicky o řádek výše - jako zde chybějící středník na předchozím řádku.

Klávesové zkratky: v QT Creatoru klikněte na volbu Tools v menu vyberte položku Options, po té v levém sloupci zvolte Environment a v něm možnost Keyboard. Z nich upozorňujeme na |F1| kontextový help, |F5| pro start a pokračování ladění (debuggingu) |F10| pro provedení dalšího kroku ladění (traceování).

Kompilace

Vytvořený program nyní zkompilujeme volbou Build→Build Project. Tato volba způsobí překlad pouze těch souborů, ve kterých došlo od poslední modifikace ke změně. Volba Clean project smaže všechny výsledky překladu, takže následná volba Build project způsobí přeložení všeho úplně odznova. Volba Rebuild project spojuje předchozí dvě volby dohromady. Pokud máte podezření, že se vám práve provedené změny v kódu nepromítly do chování výsledné aplikace, tak zkuste volbu Rebuild.

Po spuštění překladu dojde k animaci jeho průběhu v levé dolní části. Tlačítka pro spuštění a debugging programu jsou nektivní (zašedlá), dokud překlad úspěšně neskončí.

Po úspěšném překladu lze program spustit nebo ladit. Spuštění provedeme nabídkou Build→Run nebo lépe příslušnou klávesovou zkratkou.

Pokud máme v kódu chybu, překlad skončí s výpisem nalezených chyb, které se zobrazí v okně Build issues v pravo dole. Dvojklikem na chybu nebo varování se přímo dostaneme v editačním okně na místo, kde byla chyba nalezena. Původce chyby je často hned o řádek výše. Kompilujte bez chyb (to je nutné, jinak spustitelný program není vůbec vytvořen) a teké bez varování (warnings). Warnings obsahují často upozornění na místo, které není přímo syntaktickou chybou, ale ve skutečnosti se jedná o chybu logickou (např. neúmyslná záměna = za == apod.) nebo jde o nevhodné a potenciálně nebezpečné konstrukce (např. použití funkcí se známýmy bezpečnostními problémy, implicitní přetypování, které může způsobit přetečení proměnné a mnoho dalších). Pokud si zvyknete kompilovat bez warnings, tak ihned zjistíte a opravíte ten, který nově přibude. Pokud naopak máte už 20 warnings ve výpisu (o kterých si myslíte, že nejsou podstatné), nového si nevšimnete. Kompilace bez warnings je při odevzdání úkolů vyžadována!

Základním režimem pro vývoj programu je tzv. Debug mód. Jde o režim, při němž jsou do zkompilované binárky vloženy dodatečné informace umožňující ladění programu (krokování apod.) a dodatečné kontroly (např. zápis mimo meze polí). Tyto informace a kontroly samozřejmě zpomalují běh programu a zvětšují jeho velikost, to ale není během vývoje podstatné. Teprve ve chvíly, kdy máte program odladěn a předáváte jej zákazníkovi (nebo odevzdáváte úkol), přepínáte se do tzv. Release režimu způsobem uvedeným níže (je váce míst, kde můžete režim přepnout).

Důležité: program může fungovat v Debug režimu a přitom nebýt funkční v Release režimu. Důvodem jsou právě dodatečné informace vkládáné do binárky v Debug režimu. Pokud například zapisujete za konec pole, tak díky dodatečným datům nemusí v Debug režimu dojít k přepsání např. dalších proměnných programu, zatímco v Release k tomu dochází. Je proto nutné program otestovat i v Release režimu a před odevzdáním i na Aise!

Přepínače kompilace

U nově vytvořeného projektu si nastavíme přepínače překladače tak, aby to odpovídalo požadovanému překladu na Aise (který musíte dělat během odevzdávání příkladu). Na Aise překládáme s přepínači -ansi -pedantic -Wall -Wextra (předmět PB161) nebo -std=c99 -pedantic -Wall -Wextra (předmět PB071).

Přepneme se do okna File a zvolíme buď Open File or Project anebo Open File With… a otevřeme v adresáři projektu soubor jméno_projektu.pro (zde Test1.pro). Přidáme do něj řádek QMAKE_CXXFLAGS += -ansi -pedantic -Wall -Wextra (předmět PB161) nebo QMAKE_CFLAGS += -std=c99 -pedantic -Wall -Wextra (předmět PB071). Tímto instruujeme QT IDE, že během překladu projektu má do g++ přepínačů (QMAKE_CXXFLAGS) resp. gcc (QMAKE_CFLAGS) přidat dodatečné přepínače (zde -ansi -pedantic -Wall -Wextra resp. -std=c99 -pedantic -Wall -Wextra).

Pokud často vytváříte C nebo C++ projekt a potřebujete nastavit toto nastavení, lze jeho defaultní podobu pro nový projekt ovlivnit v souboru Qt\Tools\QtCreator\share\qtcreator\templates\wizards\projects\plainc\file.pro.

V pravém dolním okně lze vybrat volbu Compile Output (viz obrázek), která nám zobrazí celý průběh překladu včetně použitých přepínačů (zde g++ -c -ansi -pedantic -Wall -g -frtti -fexceptions -mthreads -Wall -DUNICODE -DQT_L …..). Můžeme si tedy ověřit, že jsme změnu .pro souboru provedli správně.

Pro jazyk C může vypadat konfigurační soubor jmeno_projektu.pro následovně:

QMAKE_CFLAGS += -std=c99 -pedantic -Wall -Wextra
TEMPLATE = app
CONFIG += console
CONFIG -= qt
SOURCES += main.c

Spuštění

Po úspěšném překladu můžeme program spustit. V defaultní variantě se výstup konzolového programu zobrazuje do okna Application output (je součástí okna v pravo dole ve stejném místě, jako Build issues z překladu. Mělo by se po spuštění aplikace automaticky přepnout, ale pokud se tak nestaně, vyberte z nabídky volbu Application output manuálně). Také si všimněte volbu Arguments, do které se přidávají argumenty pro spouštecí soubor.

Výstup v okně Application output ale trpí obdobnými problémy, jako obdobné okno v Eclipse - při ladění se ihned nezobrazuje výstup (flush bufferu), obtížně se vepisuje text apod. Výhodnější je tedy pro výstup programu nastartovat vlastní konzoli tak, jak to dělá automaticky např. Visual Studio. Toto chování nastavíme pomocí volby „Run in Terminal“ v nabídce Projects (v levém svislém panelu), Run settings → Run in Terminal.

Po změně tohoto nastavení je program spuštěn v samostatné konzoli.

Debugging

Několik poznámek k ladění:

  • Debugging je schopnost nalézt a odstranit chybu v programu. Přestože se to nemusí na první pohled zdát, tak nalezení chyby bývá většinou ta náročnější část.
  • Při hledání chyby většinou nelze krokovat každý řádek programu od jeho začátku. S výjimkou triviálních programů to není časově možné a je to hlavně zbytečné. Klíčovou schopností je rychlá lokalizace místa poblíž chyby, do kterého se umístí breakpoint a kde začínáme vlastní ladění.
  • Moderní vývojové nástroje nabízí pro debugging širokou podporu. Je velice užitečné ovládat alespoň základní krokování programu, zjištění aktuálních hodnot proměnných, schopnost je za běhu změnit a umět vkládat podmíněné breakpointy, na kterých se program zastaví pouze tehdy, když je splněna jejich definovaná podmínka (např. už proběhlo 1000 iterací cyklu for - krokování iterací pokaždé od 0 je nesmyslné).
  • V případě, že pracujete s cizím rozsáhlým kódem (nebo vlastním, ale už si jej příliš nepamatujete), může být debugging nejrychlejším způsobem jak zjistit, které funkce jsou důležité pro dannou činnost - jednoduše program spustíte se zvolenými daty a podiváte se do kterých metod při jejich zpracování program vstoupí. Dokumentace, která by vám jinak mohla tuto informaci sdělit může být neúplná nebo zastaralá.
  • Dostupnost debuggeru může svádět k tomu, že namísto přemýšlení o dopadu změny ji uděláme a podíváme se v debuggeru na výsledek. Přestože je debugger mocný nástroj a doporučuji jej umět ovládat a často používat, tak přílišná závislost na něm může být i na škodu.
  • Oficiální tutoriál k debuggingu v QT: http://qt-project.org/doc/qtcreator-2.7/creator-debugging.html

a detaily: http://qt-project.org/doc/qtcreator-2.7/creator-debug-mode.html

Pro možnost ladění je nutné program přeložit v Debug režimu (možnost vlevo dole, popsáno výše). Aby došlo k zastavení běhu programu a možnosti ladění, je nutné umístit na konkrétní řádek kódu tzv. break point (Debug→Toggle breakpoint). V případě, že běh programu dorazí na řádek označený break pointem, program se zastaví a je možné začít v ladění programu (viz. níže). Breakpointů můžete mít v kódu libovolné množství a lze je samozřejmně zase odebírat.

Po překladu v Debug režimu je nutné program v Debug režimu i spustit. Provádíme pomocí nabídky Debug→Start Debugging→Start debugging. Ostatní varianty ladění dostupné pod nabídkou Debug→Start Debugging umožňují se například připojit a ladit běžící aplikaci, aplikaci na vzdáleném serveru, výpis jádra apod. - tyto možnosti nebudeme používat, ladit budeme přímo tu aplikaci, kterou jsme přeložili a kterou pro potřeby ladění QT IDE rovnou spustí.

Po spuštění aplikace v Debug režimu se běh programu zastaví na prvním breakpointu, na který se narazí. Tj. aplikace dorazí na řádek, na kterém jsme předtím breakpoint umístili (určitě se nemusí jednat o první breakpoint od začátku souboru). Vedle čísla řádku se zobrazí žlutá šipka a program v tuto chvíli kompletně stojí a čeká na náš povel. V okně vpravo dole můžeme navíc vidět hodnoty vybraných proměnných v okolí laděného řádku (tzv. Locals) a proměnné, které jsme si sami explicitně poznačili (tzv. Watch). Proměnné, které se během posledního ladícího kroku (viz. dále) změnili jsou zvýrazněny červenou barvou.

Proměnnou do okna Watch můžeme přidat několika způsoby. Např. Pravým myšítkem a výběrem Insert new watch item na založce Locals and watches nebo kliknutím pravým myšítkem na proměnnou v kódu a výběrem možnosti Add to watch window. Takto vložená proměnná zůstane v okně Locals and Watches trvale, zatimco automaticky vkládané proměnné z okolí kódu se mění. Vkládat můžeme i celé výrazy (např. a + 5, a * b nebo třeba mojePole[index]).

Základním povelem je posun na další viditelný řádek, tzv. Step Over (rozhodně si zjistěte jeho klávesovou zkratku, budete ho mačkat opakovaně - Debug→Step over). I v případě, že se na řádku nachází volání funkce, Step over nechá celou funkci vykonat, ale nevstupuje do ní (proto Step over - překračuje se).

Pokud naopak chceme do funkce vstoupit, tak použijeme příkaz Step into. V ladění tak skočíme na první řádek uvnitř funkce. Lze takto vstupovat do metod tříd i například STL šablon (která však mohou být na první pohled poněkud nepřehledné). Vevnitř funkce používáme zase Step over případně Step into, pokud chceme vstoupit do další vnořené funkce. Po vykonání posledního řádku dané funkce se vracíme o úroveň výše. Pokud se chceme vrátit přímo, použijeme příkaz Step out, který nás v ladění přímo vrátí do funkce o úroveň výš (zbytek funkce se normálně vykoná, jen nemusíme jeho řádky proskákat příkazem Step over).

Pokud chceme postoupit na další breakpoint v kódu, aniž bychom na něho proskákali pomocí Step over (tj. nechat program běžet, dokud nenarazí na další breakpoint), použijeme příkaz Continue (Debug→Start debugging→Continue).

Během ladění postupně vstupujeme do funkcí a vnořených funkcí a potřebujeme se zorientovat, kde zrovna jsme (tj. přes jaké funkce jsme se sem vnořili). Speciálně v případě, že máme nastaven breakpoint na místo ve funkci, která mohla být zavolána z 10 různých míst v programu se hodí vědět, která metoda tuto funkci zavolala. Na to slouží zásobník volání, tzv. Call stack. Při ladění se automaticky zobrazuje v ladícím okně. Aktuální funkce je funkce s úrovní (Level) 0. Bezprostředně nadřazená funkce má Level 1 atd. Např. zde vidíme funkci foo(), do které jsme se zanořili a funkci main(), ze které byla funkce foo() zavolána. Dvoklikem na název funkce v Call stacku nás editor přímo posune do místa, které mu odpovídá (tj. ne na začátek funkce main, ale na místo, kde je zavolána funkce foo()). To je velice užitečné a často užívané chování.

V některých situacích je časově náročné procházet kód pomocí Step over až do místa, které nás zajímá. Například pokud máme cyklus for a ladit chceme až od jeho 1000té iterace. V takovém případě použijeme podmíněné breakpointy. Vložíme obyčejný breakpoint na místo v kódu, které nás zajímá (např. vnitřek cyklu). Přepneme se do záložky Breakpoints a nalezeneme tento breakpoint ve výpisu. Z nabídky pod pravým myšítkem zvolíme možnost Edit condition a uvedeme v ní logický výraz, který musí být splněn, aby se běh kódu na daném breakpointu zastavil. Např. i == 1000. Poté spustíme program v Debug režimu a čekáme, dokud není podmínka splněna. Pozor, zavedením podmínky se program zpomalí (jen v průběhu ladění, breakpoint je při běžném překladu odstraněn), neboť se musí podmínka pokaždé vyhodnocovat. Podmínku nemusíme mít pouze v cyklu, můžeme ji např. nastavit na hodnotu vstupního parametru často volané funkce apod (např. funkce foo(int a) nás zajímá pouze tehdy, pokud je vstupní parametr a roven 56).

Zajímavou možností je zobrazí kódu assembleru odpovídajícího vašemu programu. V rámci PB161 tuto možnost využívat nebudeme, jde však o snadný způsob, jak nahlédnout do mapování zdrojového kódu na instrukce procesoru. Je dobře viditelné, že ne všechny řádky C++ se přeloží na jedinou instrukci assembleru, zároveň však není výsledný kód zcela nepochopitelný.

Kompilace samostatně spustitelné binárky

  • Vytvoření samostatně spustitelné binárky je od verze QT Creatoru 2.4.1 automatické a záležitosti jenom na pár kliknutí. Vo vytvořeném projektu jsi můžeme nastavit zložku, do které se bude kompilovat spustitelný soubor v Project → Build Settings → General (po zaškrtnutí Shadow build se spřístupní možnost ukládat binárky do jiné složky než jenom do složky projektu.).
  • Při vytváření nového projektu si tyto volby nastavíme v ponuce Targets → Desktop → Create Build Configurations. Zvolíme si z dostupných možností a také používaní kompilování do rozličných složek (Use Shadow Building).

Kompilace v starších verzích

  • Kompilace programu s využitím defaultního nastavení QT Creatoru vede k vytvoření spustitelného souboru, který vyžaduje ke svému spuštění dynamické knihovny QT API
  • Jedním ze způsobů obejití této podmínky je vytvoření vlastního souboru Makefile, pomocí kterého přeložíme zdrojové soubory přímo pomocí g++ namísto využití QT qmake

Nejprve vytvoříme jednoduchý makefile pojmenovaný MyMakefile pro náš projekt:

CCC=g++
CFLAGS=-ansi -pedantic -Wall -Wextra
SOURCES= ..\Test1\main.cpp 
DESTDIR_TARGET = release\Test1_standalone.exe


all: 
    $(CCC) $(CFLAGS) -o $(DESTDIR_TARGET) $(SOURCES)
clean:
    rm $(DESTDIR_TARGET)

Následně vytvoříme v záložce Projects→Build settings→Builds steps nový 'Make' krok v kompilaci. V položce 'Make argument' nastavíme -f MyMakefile, čímž instruujeme make k použití našeho vlastního makefile se jménem MyMakefile. Soubor MyMakefile musí být v adresáři s kompilovanými soubory - zde Test1-build-desktop.

Po spuštění kompilace dojde i ke spuštění našeho MyMakefile a vytvoření spustitelného programu Test1_standalone.exe bez potřeby QT knihoven.

QR Code
QR Code public:qtcreator (generated for current page)