QT: use VS para construir el entorno qt

Language 2023-10-05 03:39:24 views: null

        En la plataforma Windows, el uso de Visual Studio para crear un entorno de desarrollo QT basado en CMake permite a los desarrolladores controlar y administrar de manera más flexible la construcción y configuración de proyectos QT. Este proceso requiere instalar y usar la herramienta CMake en Visual Studio y luego agregar la información de configuración de QT adecuada en el archivo CMakeLists.txt para compilar, vincular y compilar el proyecto QT.

        La creación de un proyecto CMake permite a los desarrolladores de QT administrar más fácilmente las dependencias del proyecto y los archivos de la biblioteca, y puede ejecutarse en múltiples plataformas y diferentes compiladores, lo que mejora en gran medida la portabilidad y el mantenimiento del código. Para crear un proyecto CMake para un proyecto QT en Visual Studio, primero debe instalar la herramienta CMake y la versión QT adecuada, luego crear un proyecto CMake en Visual Studio y configurar el archivo CMakeLists.txt.

        Puede utilizar el archivo CMakeLists.txt para agregar bibliotecas de componentes QT, personalizar las opciones de compilación, definir rutas del compilador, etc., para controlar y gestionar mejor el proceso de compilación de proyectos QT. El uso de Visual Studio para crear proyectos de CMake permite a los desarrolladores de QT centrarse más en el desarrollo de aplicaciones esenciales, para crear, probar y lanzar aplicaciones QT de forma más eficiente.

 

  • Cuando usa VS para crear un proyecto CMake por primera vez, aparecerá una carpeta de salida. Hay cuatro subdirectorios: CMakeLists.txt, CMakePresets.json, CMakeProject.cpp y CMakeProject.h. Para aprender  y comprender mejor cómo para usar VS para configurar CMake para el desarrollo de QT. Aquí elimino directamente los archivos CMakeProject.cpp y CMakeProject.h, vuelvo a crear un archivo main.cpp y luego borro todo el código en CMakeLists.txt y lo reescribo a mano. para profundizar la comprensión y mejorar la eficiencia del aprendizaje.
  • Después de reescribir, solo hay tres subdirectorios CMakeLists.txt, CMakePresets.json y main.cpp en la carpeta de salida del administrador de recursos. Entre ellos, CMakePresets.json no se mueve por el momento. Escribiendo el código a mano en CMakeLists. txt y main.cpp para profundizar la comprensión y el aprendizaje.
  •  La siguiente es una descripción detallada de mis CMakeLists.txt y main.cpp escritos a mano:

 

  • Detalles del código en el archivo CMakeLists.txt

         CMake es un sistema de compilación automatizado multiplataforma que utiliza un archivo de texto llamado CMakeLists.txt para describir el proceso de compilación del proyecto. Este archivo puede crear un proceso de compilación escribiendo instrucciones simples, y el mismo archivo CMakeLists.txt se puede usar para crear proyectos en diferentes plataformas.

cmake_minimum_required (VERSION 3.8)

project (QtPro)

#指定C++标准
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

if(MSVC)
	add_compile_options(/Zc:__cplusplus)
endif()

#指定头文件包含目录
include_directories("D:/Progm/QT/software/install/6.2.4/msvc2019_64/include")
#设置模块的cMake路径
set(CAMKE_PREFIX_PATH "D:/Progm/QT/software/install/6.2.4/msvc2019_64/lib/cmake")
#查找指定模块
find_package(Qt6 COMPONENTS Widgets REQUIRED)
#指定目标位置
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/bin)

# 将源代码添加到此项目的可执行文件。
add_executable (QtPro "main.cpp")

#将目标链接库文件
target_link_libraries(QtPro Qt6::Widgets)
message("My debug message:")

Un archivo CMakeLists.txt típico suele contener el siguiente contenido:

  1. Nombre del proyecto y número de versión.

    cmake_minimum_required(VERSION 3.8)
project(MyProject VERSION 1.0)

  2. Establecer opciones de compilación de proyectos

    set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED True)
#其中True可以用ON表示
#set(CMAKE_CXX_STANDARD_REQUIRED ON)

  3. Establezca el nivel de advertencia del compilador, habilite opciones de compilación específicas, establezca el nivel de optimización del compilador, etc.

    if(MSVC)
	add_compile_options(/Zc:__cplusplus)
endif()

#当编译器报错“/Zc:__cplusplus”时可以用这个方法来防止报错

  4. Agregar directorios de inclusión y directorios de bibliotecas de enlaces

    include_directories(include)
link_directories(lib)

  5. Establecer y encontrar módulos específicos

    #设置模块的cMake路径    PS：注意！目录的“\”符号在项目中应换成“/”否则会报错
set(CAMKE_PREFIX_PATH "D:/Progm/QT/software/install/6.2.4/msvc2019_64/lib/cmake")
#查找指定模块
find_package(Qt6 COMPONENTS Widgets REQUIRED)
#

  6. Especifique la ubicación de destino y especifique el directorio de salida del archivo ejecutable compilado.

    #指定目标位置 
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/bin)

  7. Agregar una biblioteca o ejecutable

    add_library(MyLibrary SHARED ${SOURCES})
add_executable(MyExecutable ${SOURCES})

  8. Vincular bibliotecas y archivos ejecutables

    target_link_libraries(MyLibrary MyOtherLibrary)
target_link_libraries(MyExecutable MyLibrary)

PD: ¡Presta atención al orden de las operaciones! ! ! La operación include_directories(include) debe colocarse antes de la operación add_executable(MyExecutable ${SOURCES}), y la operación de biblioteca de enlaces target_link_libraries(MyLibrary MyOtherLibrary) debe colocarse después de la operación add_executable(MyExecutable ${SOURCES}).

  • 1. Especifique el requisito de versión mínima de CMake: cmake_minimum_required (VERSIÓN 3.8)

  cmake_minimum_required (VERSION 3.8) Es una instrucción de script de CMake que se utiliza para especificar la versión mínima de CMake necesaria para construir el proyecto. Esto significa que solo se pueden usar versiones de CMake superiores o iguales a 3.8 para construir este proyecto.

VERSION 3.8El "en         " aquí 3.8se refiere al número de versión principal y al número de versión secundaria de CMake, lo que indica que la versión mínima de CMake requerida por el proyecto debe ser la versión 3.8 o superior.

        El uso de directivas en scripts de CMake cmake_minimum_requiredes una especificación básica que garantiza que esté instalada la versión mínima de CMake requerida para todo el proyecto y puede evitar fallas de compilación debido a versiones incompatibles de CMake. Además, este comando también se utilizará para indicarle al usuario qué versión de CMake debe usarse para construir este proyecto.

PD: Preste atención a las características del número de versión de CMake: ¡el número de versión 3.16 es mayor que el de 3.8!

        La regla de nomenclatura del número de versión de CMake generalmente adopta el formato "versión principal. Versión secundaria. Revisión", por ejemplo, CMake 3.10.2 significa que el número de versión principal es 3, el número de versión secundaria es 10 y el número de revisión es 2. .

Las características de nomenclatura del número de versión de CMake son las siguientes:

  1. Número de versión principal:

    El primer dígito indica el número de versión principal. Cuando las funciones principales, la arquitectura u otros cambios de CMake sean importantes, se aumentará el número de versión principal.

  2. Número de versión menor:

    El segundo dígito representa el número de versión menor. Cuando CMake agrega nuevas funciones o permite que cambien los parámetros de ciertas funciones, se incrementa el número de versión secundaria.

  3. Número de revisión:

    El tercer dígito indica el número de revisión. Los números de revisión indican cambios como correcciones de defectos, actualizaciones de documentación o casos de prueba. Pequeños ajustes, como corregir errores y agregar casos de prueba, aumentarán el número de revisión.

        CMake también tiene un número de versión preliminar (también llamado "versión preliminar" o "versión rc"), que se identifica como "rcX" o "betaX", donde X es un número. Por ejemplo, CMake 3.14.0-rc1 representa la versión preliminar 1, que es una versión de prueba que no se ha lanzado oficialmente. Los números de versión preliminar se utilizan principalmente para pruebas y comentarios públicos, lo que permite a los desarrolladores recopilar comentarios y mejorar el programa.

En resumen, el método de denominación del número de versión de CMake se ajusta a la convención de denominación de versiones digitales convencional y es claro y conciso. Al utilizar CMake, debe prestar atención al problema de compatibilidad del número de versión de CMake.

  • 2. El comando project() se utiliza para definir el nombre, el número de versión y otra información del proyecto C++.
  • comando proyecto () en qmake

        Al desarrollar programas usando QT, la herramienta qmake proporcionada por QT generalmente se usa para generar Makefiles y programas ejecutables. qmake usa project()comandos para definir proyectos.

project()El comando se utiliza para definir el nombre, el número de versión y otra información del proyecto C++. Su sintaxis básica es la siguiente:

project(project_name [VERSION major[.minor[.patch[.tweak]]]]
        [DESCRIPTION "description"]
        [LANGUAGES language_name ...])

en:

  • project_name:nombre del proyecto
  • VERSION: Opcional, número de versión del proyecto, en el formatomajor.minor.patch.tweak
    • major: Número de versión principal
    • minor:Número de versión menor
    • patch:número de revisión
    • tweak: número de versión de corrección de errores
  • DESCRIPTION: Opcional, descripción del proyecto
  • LANGUAGES: Opcional, el idioma utilizado por el proyecto.

Por ejemplo:

project(MyProject VERSION 1.0.0 DESCRIPTION "A sample project" LANGUAGES CXX)

        Esta línea de código define un proyecto llamado "MyProject", el número de versión es 1.0.0, la descripción es "Un proyecto de muestra" y el lenguaje de programación utilizado es C++.

Cuando se usa QT para desarrollar un programa, además de definir la información del proyecto, project()los módulos utilizados por QT generalmente se especifican en el comando, por ejemplo:

project(MyProject VERSION 1.0.0 DESCRIPTION "A sample project" LANGUAGES CXX)

find_package(Qt5Core REQUIRED)
find_package(Qt5Gui REQUIRED)
find_package(Qt5Widgets REQUIRED)

target_link_libraries(MyProject Qt5::Core Qt5::Gui Qt5::Widgets)

        Los comandos se utilizan aquí find_package()para encontrar los módulos Core, Gui y Widgets de QT y vincularlos al archivo ejecutable.

En resumen, cuando usamos QT para desarrollar programas, project()los comandos son un paso clave para definir el proyecto, pueden ayudarnos a organizar el código claramente y especificar los módulos y la información de versión que QT debe usar.

  • comando proyecto() en cmake

        Cuando usa CMake para construir un proyecto QT, también puede usar project()comandos para definir la información del proyecto. La diferencia es que project()el comando debe usarse junto con la búsqueda y vinculación de la biblioteca QT.

La sintaxis básica project()del comando es la siguiente:

project(project_name
    VERSION version
    DESCRIPTION description
    LANGUAGES CXX
)

        Entre ellos, project_namese encuentra el nombre del proyecto, versionel número de versión del proyecto y descriptionla descripción del proyecto. Tenga en cuenta que cuando utilice QT para desarrollar un programa, agregue CMakeLists.txtel siguiente código para localizar archivos QT y moc automáticos:

set(CMAKE_AUTOMOC ON)
find_package(Qt5 COMPONENTS Core Gui Widgets REQUIRED)

project()Puede configurar la versión QT en el comando de la siguiente manera         :

set(QT_VERSION_MAJOR 5)
set(QT_VERSION_MINOR 15)
set(QT_VERSION_PATCH 0)
set(QT_VERSION "${QT_VERSION_MAJOR}.${QT_VERSION_MINOR}.${QT_VERSION_PATCH}")

project(MyProject VERSION ${QT_VERSION} LANGUAGES CXX)

        Este código define un proyecto C++ llamado MyProject, que depende de la versión QT 5.15.0 y utiliza el lenguaje de programación C++. El número de versión del proyecto es coherente con el número de versión QT.

Cuando use target_link_libraries()un comando para especificar una biblioteca de enlaces, debe usar la biblioteca de enlaces proporcionada por QT, por ejemplo:

target_link_libraries(MyProject Qt5::Core Qt5::Gui Qt5::Widgets)

        Aquí se utilizan las bibliotecas de enlaces Core, Gui y Widgets de QT.

En resumen, cuando usa CMake para construir un proyecto QT, debe project()especificar la información del proyecto, el número de versión de QT y el lenguaje de programación en el comando, y usar find_package()el comando para encontrar la biblioteca QT y usar target_link_libraries()el comando para vincular la biblioteca QT.

  •  3. Establezca las opciones de compilación del proyecto y especifique el estándar C++.

        En CMake, set()los comandos se usan para establecer variables CMAKE_CXX_STANDARDy CMAKE_CXX_STANDARD_REQUIREDson variables que se usan para establecer el estándar de compilación de C++ y si se debe forzar el uso del estándar.

Específicamente, CMAKE_CXX_STANDARDpuede establecer el número de versión estándar de C++ utilizado por el compilador (como C++11, C++14, C++17, etc.). Por ejemplo:

set(CMAKE_CXX_STANDARD 17)

        Este código establece la versión estándar del compilador de C++ en C++17.

Configurarlo en significa que se debe usar la versión estándar de C ++ especificada para la compilación; de lo contrario, se producirá un error de compilación (True también se puede reemplazar con ON) CMAKE_CXX_STANDARD_REQUIRED. TruePor ejemplo:

set(CMAKE_CXX_STANDARD_REQUIRED True)
#set(CMAKE_CXX_STANDARD_REQUIRED ON)

        Este código indica que el compilador debe CMAKE_CXX_STANDARDcompilarse de acuerdo con los estándares establecidos.

En resumen, los comandos set(CMAKE_CXX_STANDARD 17)y set(CMAKE_CXX_STANDARD_REQUIRED True)se utilizan para establecer el estándar de compilación de C++ y si se debe forzar el uso del estándar. Durante el desarrollo de C++, puede utilizar estos dos comandos para especificar la versión estándar de C++ y, al mismo tiempo, solicitar que el compilador compile de acuerdo con el estándar especificado, mejorando así la portabilidad y seguridad del programa.

  • 4. add_compile_options()Comando para establecer el nivel de advertencia del compilador, habilitar opciones de compilación específicas, establecer el nivel de optimización del compilador, etc.

        En CMake, add_compile_options()los comandos se utilizan para pasar opciones de compilación específicas al compilador a nivel de archivo. Específicamente, se puede utilizar para establecer niveles de advertencia del compilador, habilitar opciones de compilación específicas, establecer niveles de optimización del compilador, etc. Este comando se puede utilizar en un único archivo fuente o en todo el destino.

Por ejemplo, el siguiente código agrega una opción de compilación -Werrora las opciones de compilación del archivo fuente para que cualquier advertencia del compilador se trate como error y provoque que la compilación falle:

add_executable(my_program my_program.cpp)
add_compile_options(-Werror)

        El siguiente ejemplo agregará opciones de optimización al compilador de C++ -O3y realizará la optimización del compilador en todo el destino:

add_executable(my_program my_program.cpp)
add_compile_options(-O3)

        Además de una única opción de compilación, se pueden agregar múltiples opciones usando:

set(SIMPLE_OPTS "-Wall" "-pedantic" "-Wextra")
add_compile_options("$<$<CONFIG:Debug>:${SIMPLE_OPTS}>" "$<$<CONFIG:Release>:${SIMPLE_OPTS} -O3>")

CONFIG:DebugEsto agrega las opciones de compilación y a         la versión de depuración ( ) del archivo fuente -Wally a la versión de lanzamiento ( ) y las opciones de optimización.-pedantic-WextraCONFIG:Release-O3

En resumen, add_compile_options()los comandos se pueden utilizar para agregar opciones del compilador a destinos, archivos y otros lugares. Al utilizar este comando, puede controlar de manera flexible las opciones del compilador y lograr la optimización del código y otros propósitos.

  • 5. Agregue bibliotecas y bibliotecas de enlaces, include_directories()y link_directories()se utilizan para establecer la ruta de búsqueda del compilador, y se utilizan para establecer la ruta de inclusión del archivo de encabezado y la ruta de enlace del archivo de biblioteca, respectivamente.

        En CMake, include_directories()y link_directories()se utilizan para establecer la ruta de búsqueda del compilador y para establecer la ruta de inclusión del archivo de encabezado y la ruta de enlace del archivo de biblioteca, respectivamente.

  • include_directories(): Este comando se utiliza para agregar la ruta de búsqueda de archivos de encabezado al compilador para que el compilador pueda encontrar correctamente los archivos de encabezado que se incluirán. include_directories()La ruta especificada en se agregará directamente a todas las opciones del compilador para todo el proyecto CMake. La sintaxis es la siguiente:
include_directories([AFTER|BEFORE] [SYSTEM] dir1 [dir2 ...])

        en:

- `AFTER`和`BEFORE`表示添加目录的位置，`AFTER`表示将目录放在原目录后面，`BEFORE`表示将目录放在原目录前面；
- `SYSTEM`表示添加系统目录，可以避免一些警告信息；
- `dir`表示你要添加的目录。

        Por ejemplo:

include_directories(include)

        Esto includeagrega el directorio a la ruta de búsqueda del archivo de encabezado del proyecto CMake.

  • link_directories(): Este comando se utiliza para agregar la ruta de búsqueda de archivos de biblioteca al vinculador. De manera similar a include_directories(), link_directories()la ruta especificada en se agregará directamente a todas las opciones del vinculador para todo el proyecto CMake. La sintaxis es la siguiente:
link_directories(directory1 [directory2 ...])

        en:

- `directory`表示要添加的库文件搜索路径。

        Por ejemplo:

link_directories(lib)

        Esto libagrega el directorio a las opciones del vinculador del proyecto CMake, y el vinculador puede buscar en el directorio los archivos de biblioteca requeridos por el programa.

En resumen, include_directories()estos link_directories()dos comandos se usan para establecer la ruta de búsqueda del compilador y para configurar la ruta de inclusión del archivo de encabezado y la ruta del enlace del archivo de la biblioteca, respectivamente. Al utilizar estos dos comandos, el compilador y el vinculador pueden encontrar correctamente los archivos necesarios y garantizar la compilación y vinculación correctas del programa.

  • 6.  Configure y busque el módulo especificado, set()y find_package()generalmente se usan junto con el comando para configurar y buscar el módulo especificado.

        En CMake, los comandos set()y find_package()generalmente se usan juntos para configurar y buscar módulos específicos.

  • set(CMAKE_PREFIX_PATH "path1" "path2" ...): Este comando se utiliza para establecer el directorio raíz donde CMake busca módulos de CMake. Se pueden especificar varias rutas. En estos directorios, CMake buscará módulos de CMake de cierta manera. La sintaxis es la siguiente:
set(CMAKE_PREFIX_PATH "path1" "path2" ...)
  • find_package(packageName [version] [EXACT] [QUIET] [REQUIRED] [COMPONENTS <component1> <component2> ...]): Este comando se utiliza para encontrar el módulo especificado y cargar la configuración correspondiente. Los módulos CMake se utilizan normalmente para buscar y cargar bibliotecas de terceros. La sintaxis es la siguiente:
find_package(packageName [version] [EXACT] [QUIET] [REQUIRED] [COMPONENTS <component1> <component2> ...])

        en,

  • packageName: El nombre del módulo que se va a encontrar;
  • version:Número de versión del módulo;
  • EXACT: Si se requiere que las versiones del paquete coincidan exactamente;
  • QUIET: si se deben desactivar los mensajes de error y advertencia;
  • REQUIRED: Si es necesario encontrar el módulo;
  • COMPONENTS: Se utiliza para especificar el componente que se va a encontrar.

        Por ejemplo:

set(CMAKE_PREFIX_PATH "D:/Progm/QT/software/install/6.2.4/msvc2019_64/lib/cmake")
find_package(Qt6 COMPONENTS Widgets REQUIRED)

        Esto especifica la ruta del módulo CMake de Qt6 y busca el componente Qt6 Widgets.

En resumen, los comandos set(CMAKE_PREFIX_PATH)y find_package()generalmente se usan juntos para configurar y encontrar el módulo especificado y cargar la configuración correspondiente. A través de estos dos comandos, puede importar fácilmente el módulo CMake de la biblioteca de terceros y utilizar los componentes que contiene.

  • 7. Especifique la ubicación de destino. Utilice set(CMAKE_RUNTIME_OUTPUT_DIRECTORY)el comando para especificar el directorio de salida del archivo ejecutable compilado. 

        En CMake, set(CMAKE_RUNTIME_OUTPUT_DIRECTORY)puede usar el comando para especificar el directorio de salida del archivo ejecutable generado por la compilación.

La sintaxis básica de este comando es la siguiente:

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY directory)

        Entre ellos, directoryse encuentra el directorio de salida del archivo ejecutable, que puede ser una ruta relativa o una ruta absoluta. Si el directorio especificado no existe, CMake creará el directorio automáticamente.

Por ejemplo, el siguiente código genera el archivo ejecutable generado en binun subdirectorio de la raíz del proyecto:

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/bin)

        De esta manera, el archivo ejecutable generado por la compilación se enviará al bindirectorio para facilitar su administración.

De forma predeterminada, si set(CMAKE_RUNTIME_OUTPUT_DIRECTORY)la ruta de salida del archivo ejecutable generado no se especifica mediante el comando, CMake lo enviará al directorio de compilación (ya sea el directorio de compilación o el subdirectorio Debug/Release). Al utilizar este comando, puede especificar fácilmente el directorio de salida del archivo ejecutable para una fácil personalización y administración.

En resumen, set(CMAKE_RUNTIME_OUTPUT_DIRECTORY)el comando se puede utilizar para especificar el directorio de salida del archivo ejecutable compilado, haciendo que la ubicación del archivo de salida sea controlable y facilitando la administración e implementación del programa.

  • 8. Agregue una biblioteca o un archivo ejecutable, add_library(MyLibrary SHARED ${SOURCES})
    add_executable(MyExecutable ${SOURCES})

        En CMake, add_library()puede usar el comando para agregar un archivo de biblioteca (biblioteca estática o biblioteca dinámica) y usar add_executable()el comando para agregar un archivo ejecutable.

  • add_library(): este comando se utiliza para compilar el código fuente en un archivo de biblioteca y agregarlo al proyecto CMake. Este comando puede crear una biblioteca estática o una biblioteca dinámica. La sintaxis es la siguiente:
add_library(libName [STATIC | SHARED | MODULE] source1 [source2 ...])

        Entre ellos, libNameestá el nombre de la biblioteca de destino, STATICque significa crear una biblioteca estática, SHAREDque significa crear una biblioteca dinámica, MODULEque significa crear un módulo cargable. source1y source2son los archivos de código fuente de la biblioteca.

Por ejemplo:

add_library(MyLibrary SHARED ${SOURCES})

        Esto crea una MyLibrarybiblioteca dinámica llamada y ${SOURCES}compila los archivos de código fuente en la biblioteca.

  • add_executable(): este comando se utiliza para compilar el código fuente en un archivo ejecutable y agregarlo al proyecto CMake. La sintaxis es la siguiente:
add_executable(execName source1 [source2 ...])

        donde es execNameel nombre del archivo ejecutable de destino source1y source2es el archivo de código fuente del archivo ejecutable.

Por ejemplo:

add_executable(MyExecutable ${SOURCES})

        Esto crea un MyExecutablearchivo ejecutable llamado y ${SOURCES}compila los archivos de código fuente en el archivo ejecutable.

En resumen, al utilizar add_library()los comandos y add_executable(), los archivos de código fuente se pueden compilar en archivos de biblioteca o archivos ejecutables y agregarlos a proyectos de CMake para su administración y compilación. Estos dos comandos son uno de los comandos básicos más importantes en CMake y cubren la parte central de la compilación y construcción del proyecto.

  •  9. Vincular bibliotecas y archivos ejecutables, target_link_libraries(MyLibrary MyOtherLibrary)
    target_link_libraries(MyExecutable MyLibrary)

        En CMake, target_link_libraries()puede usar el comando para vincular el archivo de destino con el archivo de biblioteca especificado y usar el archivo de biblioteca requerido como una dependencia del archivo de destino.

  • target_link_libraries(): este comando se utiliza para vincular el archivo de biblioteca especificado al archivo de destino para satisfacer las dependencias del archivo de destino. La sintaxis es la siguiente:
target_link_libraries(target library1 [library2 ...])

        Entre ellos, targetse encuentra el nombre del archivo de destino (archivo ejecutable, biblioteca estática o biblioteca dinámica) library1y library2el nombre del archivo de biblioteca especificado.

Por ejemplo, el siguiente código se MyLibraryvinculará a MyExecutable:

target_link_libraries(MyExecutable MyLibrary)

        De esta manera, los archivos de la biblioteca MyExecutablese MyLibraryvincularán automáticamente para satisfacer las dependencias durante la compilación.

Además, target_link_libraries()también se puede utilizar para vincular un archivo de destino a otro archivo de destino, vincular un archivo de biblioteca a otro archivo de biblioteca y también vincular bibliotecas del sistema.

En resumen, al usar target_link_libraries()el comando, el archivo de destino se puede vincular con el archivo de biblioteca especificado, de modo que el archivo de destino se pueda compilar y ejecutar con éxito.

  • 10. Utilice message()comandos para generar información de depuración personalizada o información de solicitud.

En CMake, puede utilizar message()comandos para generar información de depuración personalizada o información de solicitud. Este comando también se aplica a proyectos QT.

  • message(): Este comando se utiliza para generar información personalizada o información de solicitud. La sintaxis es la siguiente:
message("message content")

Entre ellos, message contentse encuentra la información que se generará o el contenido de la información solicitada.

Por ejemplo, el siguiente código genera un mensaje de depuración personalizado:

message("My debug message")

En proyectos QT, también puede utilizar este comando para generar información de solicitud o información de depuración. El uso message()de comandos puede generar fácilmente información clave, como variables de entorno, información de ruta, opciones de compilación, etc., para facilitar la depuración y la resolución de problemas.

En resumen, message()el comando es una herramienta de depuración de uso común que puede generar fácilmente información de depuración personalizada o solicitar información para el desarrollo y la depuración del código.

  • Conozca el código de ejemplo utilizado
    #CMakeLists.txt下的代码

cmake_minimum_required (VERSION 3.8)

project (QtPro)

#指定C++标准
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

if(MSVC)
	add_compile_options(/Zc:__cplusplus)
endif()

#指定头文件包含目录
include_directories("D:/Progm/QT/software/install/6.2.4/msvc2019_64/include")
#设置模块的cMake路径
set(CAMKE_PREFIX_PATH "D:/Progm/QT/software/install/6.2.4/msvc2019_64/lib/cmake")
#查找指定模块
find_package(Qt6 COMPONENTS Widgets REQUIRED)
#指定目标位置
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/bin)

# 将源代码添加到此项目的可执行文件。
add_executable (QtPro "main.cpp")

#将目标链接库文件
target_link_libraries(QtPro Qt6::Widgets)
message("My debug message:")
  • Detalles del código en el archivo main.cpp
#include<QApplication>
#include<QWidget>
#pragma comment(linker, "/SUBSYSTEM:windows /ENTRY:mainCRTStartup")
int main(int argc, char* argv[]) {
	
	QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
	QApplication a(argc, argv);
	QWidget w;
	w.show();
	return a.exec();

}
  • 1. Para presentar los archivos de encabezado QApplication y QWidget, primero debe configurar la ruta cMake del módulo qt6 en CMakeLists.txt, luego buscar el módulo Widgets y luego vincular el archivo de la biblioteca en el destino, específicamente correspondiente a CMakeLists. .TXT
    #设置模块的cMake路径
set(CAMKE_PREFIX_PATH "D:/Progm/QT/software/install/6.2.4/msvc2019_64/lib/cmake")
#查找指定模块
find_package(Qt6 COMPONENTS Widgets REQUIRED)

#将目标链接库文件
target_link_libraries(QtPro Qt6::Widgets)

    PD: ¡Atención! Si msvc2019_64\bin y CMake_64\bin no se agregan a las variables de entorno, es fácil informar errores diciendo que no se puede encontrar el módulo especificado. El autor siguió informando errores porque no se agregaron.

  • 2. Uso de la función de entrada y la clase QApplication

           En QT, int main(int argc, char* argv[])también es la función de entrada del programa, y ​​su función es la misma que la función de entrada en C++.

    Por ejemplo:

    #include <QApplication>

int main(int argc, char* argv[]) {
    QApplication app(argc, argv);
    // 创建并显示主窗口等其他操作...
    return app.exec();
}

           En QT, se recomienda utilizar QApplicationclases para gestionar el ciclo de vida de la aplicación para poder manejar mejor operaciones como bucles de eventos y salir de la aplicación. En mainla función, puede usar QApplicationel constructor de la clase para inicializar la aplicación, crear la ventana principal y otros componentes, luego ingresar al QApplication::exec()bucle principal llamando a la función, esperar a que ocurra el evento, usar QApplicationla exec()función de clase para ingresar al evento bucle, para que la ventana y otros componentes puedan recibir y manejar eventos.

  • 3. Elimina las ventanas negras

           En la plataforma Windows, aparecerá una ventana de consola negra cuando se compile y ejecute el programa Qt. Esta ventana mostrará información del sistema y del tiempo de ejecución, pero para la mayoría de las aplicaciones de interfaz gráfica, esta ventana obviamente no es necesaria y puede afectar la experiencia del usuario.

    A continuación se muestran varias formas de eliminar las ventanas negras:

    • ①CHacer opciones de configuración

      • CMake es una herramienta de compilación multiplataforma que puede controlar si aparece una ventana de línea de comando en el programa generado estableciendo opciones de configuración cuando se compila el proyecto. En las plataformas Windows,  CMAKE_WIN32_EXECUTABLE se pueden usar opciones para controlar si el programa ejecutable generado tiene una ventana de línea de comando.

        set(CMAKE_WIN32_EXECUTABLE [ON | OFF])

        Habilitar  CMAKE_WIN32_EXECUTABLE la opción marcará el programa ejecutable generado como una aplicación de Windows, evitando así una ventana de consola negra cuando se inicia el programa.

    • ② comando #pragma
      • #pragma Un tipo de directiva de preprocesador que se puede utilizar en el código para proporcionar compilación especial, enlaces u otra información de configuración al compilador. En plataformas Windows, puede utilizar  #pragma el comando para configurar el archivo ejecutable generado como una aplicación de Windows para eliminar la ventana de línea de comando negra.
      • #ifdef WIN32
#pragma comment(linker, "/SUBSYSTEM:windows /ENTRY:mainCRTStartup")
#endif

        Este código insertará una instrucción antes de la función de entrada del programa  #pragma para configurar el subsistema del archivo ejecutable generado en Windows y especificará la función de entrada del programa  mainCRTStartuppara eliminar la ventana de línea de comando negra.

    • ③Utilice WinMain().

      • En las plataformas Windows, el punto de entrada predeterminado para archivos ejecutables es ejecutable  WinMain()en lugar de la  main() función estándar. Esto significa que si utilizamos una  main() función estándar como punto de entrada del programa, el compilador generará automáticamente una ventana de consola para el programa. Por lo tanto, si deseas eliminar la aparición de ventanas negras, puedes cambiar el punto de entrada del programa a  WinMain(). Sin embargo, este método requiere algunas habilidades de codificación específicas. Para obtener más información, consulte  la implementación de WinMain en Qt .

      • Cabe señalar que si usamos  #pragma instrucciones o cambiamos el punto de entrada a  WinMain(), ya no podremos usar interfaces de línea de comandos, como la salida estándar, cuando el programa se esté ejecutando. Si necesita enviar información a la salida estándar, puede usar las funciones proporcionadas por Qt  qDebug() o usar la vista de depuración en Qt Creator para ver la salida del programa.

      • En resumen, puede elegir el método que más le convenga para eliminar las ventanas negras según la situación real. Entre ellos, el uso de las opciones de configuración de CMake será más general y más fácil de administrar, mientras que  #pragma los  WinMain() métodos y serán más adecuados para situaciones y necesidades específicas.

    • 4. Establecer las propiedades globales de la aplicación

      • QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling)es una declaración que establece las propiedades globales de la aplicación en QT. Su función es permitir el soporte de escalado de alta resolución para que las aplicaciones tengan una mejor capacidad de mostrarse en pantallas de alta resolución.

      • En QT, diferentes aplicaciones tienen diferentes propiedades globales, que se pueden QCoreApplication::setAttribute()configurar mediante funciones. Entre ellos, Qt::AA_EnableHighDpiScalingel parámetro indica habilitar el soporte de escalado de alta resolución.

      • La ejecución de aplicaciones sin soporte de escalado de alta resolución en una pantalla de alta resolución puede generar fuentes, imágenes, etc. Una vez habilitado el soporte de escalado de alta resolución, el sistema operativo y el marco QT ajustarán automáticamente el tamaño y la resolución de los elementos de la interfaz de acuerdo con la diferencia en la densidad de píxeles de la pantalla, para que puedan mostrarse más claramente en pantallas de alta resolución. En algunos dispositivos de visualización de alta resolución, habilitar la compatibilidad con escalado de alta resolución puede mejorar significativamente la experiencia del usuario de su aplicación.    

      • Por lo tanto, QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling)la declaración es muy común en QT para configurar las propiedades globales del soporte de escalado de alta resolución de la aplicación.

    • Conozca el código de caso utilizado

      #include<QApplication>
#include<QWidget>

#pragma comment(linker, "/SUBSYSTEM:windows /ENTRY:mainCRTStartup")

int main(int argc, char* argv[]) {
	
	QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
	QApplication a(argc, argv);
	QWidget w;
	w.show();
	return a.exec();

}

 

Supongo que te gusta

Origin blog.csdn.net/qq_59470001/article/details/130799429
Recomendado
Clasificación
Diario
Más
2024-05-23(34)
2024-05-22(10)
2024-05-21(34)
2024-05-20(5)
2024-05-19(0)
2024-05-18(30)
2024-05-17(4)
2024-05-16(22)
2024-05-15(5)
2024-05-14(10)

Code World

© 2018 codetd.com