COMP282代做、代写C++编程设计

日期：2024-05-11 08:37

University Of Liverpool Department of Computer Science

COMP282 – The C++ Programming Language

GUIDE TO Qt APPLICATION DEPLOYMENT

Document Version 1.1

For submission of your C++ / Qt programming assignment, we require two things:

(1) The source code (your cpp and h files)

(2) The application, packaged for deployment.

The above two items need to be in a ZIP file, with two zip files inside:

source.zip for the source code files, and

application.zip for the application package.

We will be using a Windows PC to test the application, so your solution should be packaged for

Windows deployment. The easiest way to do this is to make sure your project runs from Qt

Creator on a Windows PC, and follow the deployment steps (below) on that Windows machine.

Note: If you have not been able to use Qt, and have opted to submit a console-based application

(you will lose marks for this but at least you will be able to submit a C++ application) then you

should zip up the Visual Studio project folder, as was done for Assignment1. Make sure that

source files are included.

1. Packaging your Qt application for Windows Deployment:

The Windows deployment tool windeployqt automates creating a deployable folder

with the necessary Qt dependencies (libraries, QML imports, plugins, and translations) to

run an application. This folder forms an installation tree suitable for Windows desktop

applications, facilitating the packaging into an installer.

First lets establish where your QT directory is. Open a command window: hold down the

windows key and tap R, then type cmd and click OK:

On my laptop, I have a folder called QT on my c: drive and it looks like this:

You’ll see there is a folder called 6.3.1 (which is the version of Qt I am using – yours may

differ). Inside that is:

And now you can see the mingw_64 folder. This is the compiler folder. My installation uses

the MinGW_64 compiler (Minimalist GNU for Windows 64-bit). Yours will probably be the

same although it is possible yours may use MSVC or Clang. Either way, the folder name in

here is the last part of your Qt Directory (QTDIR).

So in my case, my QTDIR is C:\QT\6.3.1\mingw_64\

Make a note of yours and navigate to it in the command window.

(in my case I would type cd C:\QT\6.3.1\mingw_64\)

The deployment tool we need is called windeployqt and is in the QTDIR/bin/folder.

so when in your QTDIR folder, type:

cd bin

my folder looks like this (type dir /w or just dir to list the contents)

windeployqt requires either an .exe file or a directory containing an .exe file as an

argument, and examines the executable for dependencies.

It then copies any identified dependencies to the directory of the executable.

windeployqt modifies the hardcoded local paths in Qt6Core.dll to relative ones.

For Windows applications, essential compiler runtime files are also transferred to the

deployable folder by default.

The tool does not account for additional third-party libraries, such as database libraries, that

the application might need. But you are not likely to have used third party libraries so this

shouldn’t be an issue.

Further details on additional arguments can be found in the tool's help documentation. To see

that, type

windeployqt –help

[If this command doesn’t work, you may need to run the script QTDIR/bin/qtenv2.bat to set

it up. ]

2. Packaging resource files (e.g. image files)

You may be using image files (e.g. the playing card images). The executable needs to know

where to find them and you need to tell windeployqt to package them up. Your

pathname for the images probably won’t work on another computer so we have to use

relative pathnames and package the images folder in the correct place.

There are at least two ways to do this. I will describe both here.

How to choose the method?

If your project source code does not know the names of the image files in advance (e.g. it

extracts all files ending in *.png from a folder like the Memory Card Game did), then you

should use Method 1, which reproduces the images folder on the target system.

If your project source code knows the exact filename of all the images used and loads

them individually using the exact filename (i.e. no wildcards) then use Method2.

Method 1 – manually including the image folder

The simplest way is to put your images folder into the project output folder, and then make

the image filenames in the code refer to them with relative paths. We do this as follows:

Your project’s output folder will be generated by Qt Creator when you first build/run a

project. So in my case, with the memory card game, my output folder is:

build-example6-Desktop_Qt_6_3_1_MinGW_64_bit-Debug

If you want to find out what your project’s output folder is you can use this in your project

code :

qDebug() << "Executable directory:" << QCoreApplication::applicationDirPath();.

Here you can see I have copied my images folder into my project output folder.

Once the images folder is in the output folder, you need to change the image filenames in the

source code. E.g. in the memory card source code, this:

QDir directory(“C:/Users/andyrox/Documents/qt_examples/images/animal_images”);

becomes this:

QDir directory(QCoreApplication::applicationDirPath() + "/images/animal_images");

Check that this still works when you run the application from Qt Creator.

Now we come to packaging the application. For this we use windeployqt from the

command line.

From the command line, go to your compiler’s binary folder.

in my case (and in most cases) this is:

cd C:QT\6.3.1\mingw_64\bin

(The version number 6.3.1 may be different on your system)

Then we run windeployqt. The syntax is:

windeployqt <path_to_output_folder>

In my case I would type:

windeployqt C:\Users\andyrox\Documents\qt_examples\build-example6-

Desktop_Qt_6_3_1_MinGW_64_bit-Debug\debug

This will copy most of the required Qt dependencies into the project output folder.

So now my project output folder looks like this (you can see that there are extra folders and

dll files):

Now we need to make sure that required dlls from the compiler’s bin folder are included in

the application. You need to copy these files (highlighted in grey):

and put them in your output folder.

So now my output folder looks like this:

Now you should be able to zip up everything in the output folder to a zip file (call it

application.zip).

You can test if it has worked by unzipping the folder on another machine and running the

executable. If your game works, it’s been packaged and deployed correctly.

Method 2 – Using the Resource Collection File

There is a more sophisticated way to do it, which is to use a Resource Collection File

(resources.qrc), which specifies all the images used by the project and packages them up.

Then you change the filenames for the images to redirect them through the QRC file by using

a colon (:).

However this more sophisticated way only works if you are individually loading the images

using their specified filenames. Here are the steps:

(1) You need to make a file called a Resource Collection File with the filename

resources.qrc

In this file you need to list all the images you use in the project.

This is an example qrc file for the playing cards. Obviously my file paths will be different to yours, so

you will need to ‘search and replace’ my paths with yours, so that they are pointing to the files on

your computer