qt 使用环境变量引入类库

科学的发展-只不过是读大自然写的代码

已于 2024-09-20 14:49:30 修改

阅读量2k

点赞数 57

CC 4.0 BY-SA版权

文章标签： qt 开发语言

于 2024-09-20 10:20:31 首次发布

本文链接：https://blog.youkuaiyun.com/xie__jin__cheng/article/details/142376318

1.概要

1.1.概述

qt 使用环境变量引入类库

1.2 记忆要点

1.2.1.添加库的搜索路径：

link_directories 全局

target_link_libraries 只当前工程

1.2.2.添加头文件的搜索路径

include_directories 全局

target_include_directories 只当前工程

`1.2.3 创建库和库的头文件`

add_library 创建类库，指定库的名称和类型

target_include_directories 添加头文件的目录

其实库的引用无外呼找到头文件和找到库，所以无论什么情况、什么系统、什么方式；只要能找到头文件且能找到类库的路径，就能使用类库

1.3 相关链接

关于类库概述-优快云博客

2.代码

1.类库工程

1.工程结构

2.工程文件

cmake_minimum_required(VERSION 3.14)

project(untitled4 LANGUAGES CXX)

set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Core)
find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Core)

add_library(untitled4 SHARED
  untitled4_global.h
  untitled4.cpp
  untitled4.h
)

target_link_libraries(untitled4 PRIVATE Qt${QT_VERSION_MAJOR}::Core)

target_compile_definitions(untitled4 PRIVATE UNTITLED4_LIBRARY)

3.代码

1.untitled4.h

#ifndef UNTITLED4_H
#define UNTITLED4_H

#include "untitled4_global.h"

class UNTITLED4_EXPORT Untitled4
{
public:
    Untitled4();
    int add(int a,int b);
};

#endif // UNTITLED4_H

2.untitled4.app

#include "untitled4.h"

Untitled4::Untitled4() {}

int Untitled4::add(int a,int b){
    return a+b;
}

3.untitled4_global.h

#ifndef UNTITLED4_GLOBAL_H
#define UNTITLED4_GLOBAL_H

#include <QtCore/qglobal.h>

#if defined(UNTITLED4_LIBRARY)
#define UNTITLED4_EXPORT Q_DECL_EXPORT
#else
#define UNTITLED4_EXPORT Q_DECL_IMPORT
#endif

#endif // UNTITLED4_GLOBAL_H

2.运行工程

1.工程结构

2.工程文件

cmake_minimum_required(VERSION 3.14)

project(untitled5 LANGUAGES CXX)
# 读取环境变量 MY_LIBRARY_PATH
set(MY_LIBRARY_PATH "$ENV{LIB}")
# 添加库的搜索路径（不推荐，但简单）
link_directories(${MY_LIBRARY_PATH})


set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Core)
find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Core)

add_executable(untitled5
  main.cpp
)
target_link_libraries(untitled5 Qt${QT_VERSION_MAJOR}::Core)

include(GNUInstallDirs)
install(TARGETS untitled5
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

# 链接库
target_link_libraries(untitled5 untitled4)
# 添加头文件的搜索路径
include_directories(${MY_LIBRARY_PATH}/include)

3.代码

#include <QCoreApplication>
#include "untitled4.h"
#include <QDebug>


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    Untitled4 unt4;
    int b = unt4.add(4,5);
    qDebug()<<b;
    return a.exec();
}

3.运行结果

09:48:31: Starting D:\projects\qts\untitled5\build\Desktop_Qt_6_7_2_MinGW_64_bit-Debug\untitled5.exe...
9

4.参考资料

1.cmake 添加类库和头文件目录

记忆要点：

add_library 创建类库，指定库的名称和类型

target_include_directories 添加头文件的目录

内容：

在 CMake 中添加类库和头文件目录通常涉及使用 add_library、target_include_directories 和 target_link_libraries 等指令。以下是一个基本示例，演示如何在 CMake 项目中添加类库和头文件目录。

假设你的项目结构如下：

MyProject/  
├── CMakeLists.txt  
├── src/  
│   ├── main.cpp  
│   └── MyClass.cpp  
├── include/  
│   └── MyClass.h  
└── lib/  
    └── some_library/  
        ├── CMakeLists.txt  
        ├── src/  
        │   └── some_library.cpp  
        └── include/  
            └── some_library.h

1. 添加你的库

首先，在你的 lib/some_library/ 目录中创建一个 CMakeLists.txt 来定义库：

# lib/some_library/CMakeLists.txt  
  
# 指定 CMake 的最小版本  
cmake_minimum_required(VERSION 3.10)  
  
# 设置项目名称  
project(some_library)  
  
# 添加库  
add_library(some_library STATIC  
    src/some_library.cpp  
)  
  
# 添加头文件目录  
target_include_directories(some_library PUBLIC  
    ${CMAKE_CURRENT_SOURCE_DIR}/include  
)

2. 在主项目中添加库和头文件目录

然后，在你的主 CMakeLists.txt 中添加子目录和主可执行文件：

# MyProject/CMakeLists.txt  
  
# 指定 CMake 的最小版本  
cmake_minimum_required(VERSION 3.10)  
  
# 设置项目名称  
project(MyProject)  
  
# 设置 C++ 标准  
set(CMAKE_CXX_STANDARD 11)  
set(CMAKE_CXX_STANDARD_REQUIRED True)  
  
# 添加子目录，其中包含一些库  
add_subdirectory(lib/some_library)  
  
# 添加你的可执行文件  
add_executable(MyProject src/main.cpp src/MyClass.cpp)  
  
# 添加头文件目录  
target_include_directories(MyProject PRIVATE  
    ${CMAKE_SOURCE_DIR}/include  
)  
  
# 链接库到可执行文件  
target_link_libraries(MyProject some_library)

3. 编写源文件

例如，你的 some_library.cpp 和 some_library.h 可能如下所示：

// lib/some_library/src/some_library.cpp  
#include "some_library.h"  
  
void some_function() {  
    // 实现细节  
}

// lib/some_library/include/some_library.h  
#pragma once  
  
void some_function();

你的主项目源文件，例如 main.cpp 和 MyClass.cpp / MyClass.h，可能如下所示：

// src/main.cpp  
#include <iostream>  
#include "MyClass.h"  
#include "some_library.h"  
  
int main() {  
    std::cout << "Hello, World!" << std::endl;  
    MyClass myClass;  
    myClass.doSomething();  
    some_function();  
    return 0;  
}

// src/MyClass.cpp  
#include "MyClass.h"  
  
void MyClass::doSomething() {  
    // 实现细节  
}

// src/MyClass.cpp  
#include "MyClass.h"  
  
void MyClass::doSomething() {  
    // 实现细节  
}

4. 构建项目

最后，在你的项目根目录中运行以下命令以构建项目：

mkdir build  
cd build  
cmake ..  
make

这将生成 MyProject 可执行文件，并将 some_library 静态库链接到该可执行文件中。

通过这种方式，你可以轻松地在 CMake 项目中添加类库和头文件目录。

2. cmake 引入环境变量中的类库

记忆要点

1.添加库的搜索路径：

link_directories 全局

target_link_libraries 只当前工程

2.添加头文件的搜索路径

include_directories 全局

target_include_directories 只当前工程

其实库的引用无外呼找到头文件和找到库，所以无论什么情况、什么系统、什么方式；只要能找到头文件且能找到类库的路径，就能使用类库

在 CMake 中引入环境变量中的类库通常涉及几个步骤：从环境变量中读取路径、将这些路径添加到 CMake 的搜索路径中、然后链接所需的库。以下是一个示例，演示如何在 CMake 项目中完成这些操作。

假设你有一个环境变量 MY_LIBRARY_PATH，它指向包含你所需库的目录。

1. 读取环境变量

首先，你需要在 CMakeLists.txt 中读取这个环境变量。

	`# 读取环境变量 MY_LIBRARY_PATH`
	`set(MY_LIBRARY_PATH "$ENV{MY_LIBRARY_PATH}")`

2. 添加库的搜索路径

接下来，你需要将这个路径添加到 CMake 的库搜索路径中。这可以通过 link_directories 实现，但请注意，link_directories 是一个不推荐使用的指令，因为它会影响所有构建目标，而不仅仅是你想要链接的那个。更好的方法是使用 target_link_directories，但不幸的是，CMake 没有直接提供这个指令。相反，你应该在链接库时指定完整路径（通过 target_link_libraries），或者将库的路径添加为一个目标属性（如 INTERFACE_LINK_DIRECTORIES）。

然而，对于简单的情况，或者如果你确定你的项目结构不会受到 link_directories 的负面影响，你可以这样做：

	`# 添加库的搜索路径（不推荐，但简单）`
	`link_directories(${MY_LIBRARY_PATH})`

3. 链接库

现在你可以链接你的库了。假设你的库名为 mylib，你可以这样链接它：

	`# 添加可执行文件`
	`add_executable(MyExecutable main.cpp)`

	`# 链接库`
	`target_link_libraries(MyExecutable mylib)`

但是，如果你想要避免使用 link_directories，你应该在 target_link_libraries 中指定库的完整路径：

	`# 添加可执行文件`
	`add_executable(MyExecutable main.cpp)`

	`# 链接库，指定完整路径`
	`target_link_libraries(MyExecutable ${MY_LIBRARY_PATH}/libmylib.a) # 对于静态库`
	`# 或者`
	`target_link_libraries(MyExecutable ${MY_LIBRARY_PATH}/libmylib.so) # 对于动态库`

4. 添加头文件的搜索路径

如果你的库还有头文件，并且这些头文件位于一个特定的目录中（比如 ${MY_LIBRARY_PATH}/include），你还需要将这些目录添加到头文件的搜索路径中：

	`# 添加头文件的搜索路径`
	`include_directories(${MY_LIBRARY_PATH}/include)`

但是，同样地，include_directories 是一个影响所有构建目标的指令。更好的方法是使用 target_include_directories：

	`# 添加可执行文件`
	`add_executable(MyExecutable main.cpp)`

	`# 添加头文件的搜索路径，针对特定目标`
	`target_include_directories(MyExecutable PRIVATE ${MY_LIBRARY_PATH}/include)`

总结

综上所述，一个更现代、更推荐的 CMakeLists.txt 文件可能看起来像这样：

cmake_minimum_required(VERSION 3.10)  
project(MyProject)  
  
# 读取环境变量  
set(MY_LIBRARY_PATH "$ENV{MY_LIBRARY_PATH}")  
  
# 添加可执行文件  
add_executable(MyExecutable main.cpp)  
  
# 添加头文件的搜索路径  
target_include_directories(MyExecutable PRIVATE ${MY_LIBRARY_PATH}/include)  
  
# 链接库，指定完整路径  
target_link_libraries(MyExecutable ${MY_LIBRARY_PATH}/libmylib.a) # 对于静态库  
# 或者使用动态库  
# target_link_libraries(MyExecutable ${MY_LIBRARY_PATH}/libmylib.so)

这样，你就成功地在 CMake 项目中引入了环境变量中的类库。

3.上面的MyExecutable是什么

在 CMake 中，MyExecutable 是一个你定义的目标（target）的名称。目标可以是可执行文件、静态库、共享库（动态库）或其他类型的输出文件。在你提供的上下文中，MyExecutable 是一个可执行文件。

具体来说，当你使用 add_executable 指令时，你正在告诉 CMake 你想要创建一个可执行文件，并且你给出了这个目标的名字（在这个例子中是 MyExecutable）以及构成这个可执行文件的源文件列表（例如 main.cpp）。

	`# 添加可执行文件`
	`add_executable(MyExecutable main.cpp)`

在这行指令之后，CMake 将知道它需要编译 main.cpp（以及可能的其他文件，如果你后续用 target_sources 或其他方式添加了更多源文件）来生成一个名为 MyExecutable 的可执行文件。

这个名字 MyExecutable 是你可以自定义的，它对于你的项目来说应该是唯一的，以便 CMake 能够正确区分不同的目标。在实际构建过程中，这个名字也将用作生成的可执行文件的文件名（除非你在构建配置中指定了不同的输出目录或文件名前缀/后缀）。

4.add_library

add_library 是 CMake 中的一个命令，用于创建一个库目标。在 CMake 脚本中使用 add_library 可以定义要生成的库（静态库、共享库或模块库），并指定源文件或对象文件列表。这个命令非常灵活，支持多种配置选项，允许你定义库的名称、类型以及构成库的源文件。

语法

	`add_library(<name> [STATIC \| SHARED \| MODULE]`
	`[EXCLUDE_FROM_ALL]`
	`source1 source2 ... sourceN)`

参数解释

<name>: 库的名称。创建的库文件最终会以这个名字命名。
[STATIC | SHARED | MODULE]: 库的类型。可以是以下几种之一：
- STATIC: 静态库，默认值。如果不指定类型，CMake 将创建一个静态库。
- SHARED: 共享库（动态链接库）。
- MODULE: 模块库，通常在动态加载插件时使用（例如，在某些操作系统的插件机制中）。
[EXCLUDE_FROM_ALL]: 可选布尔标志，表示是否将库从默认的构建目标中排除。如果设置了这个标志，只有当显式构建该目标或该目标被其他显式构建的目标依赖时才会构建它。
source1 source2 ... sourceN: 构成库的源文件列表。可以包含源文件、头文件、以及其他类型的文件（如预编译的对象文件）。

示例

创建一个静态库:

add_library(MyStaticLib STATIC src1.cpp src2.cpp)
这将创建一个名为 libMyStaticLib.a（在 Unix-like 系统上）或 MyStaticLib.lib（在 Windows 上）的静态库。
创建一个共享库:

add_library(MySharedLib SHARED src1.cpp src2.cpp)
这将创建一个名为 libMySharedLib.so（在 Unix-like 系统上）或 MySharedLib.dll（在 Windows 上）的共享库。
创建一个模块库:

add_library(MyModule MODULE src1.cpp src2.cpp)
模块库的具体命名和用途依赖于平台和使用场景。

注意事项

当指定库类型为 SHARED 或 MODULE 时，应该确保 CMakeLists.txt 文件中正确设置了适用于你的平台和编译器的共享库构建选项。
在构建库时，可以使用 target_link_libraries 命令来指定库的依赖关系，以及使用 target_include_directories、target_compile_definitions 等命令来设置编译选项。
在大型项目中，合理组织源文件和使用 add_subdirectory 命令可以帮助管理复杂的库依赖关系。

5.target_include_directories

target_include_directories 是 CMake 中的一个命令，用于为指定的目标（通常是一个库或可执行文件）添加包含目录。这些包含目录会被添加到编译器的搜索路径中，使得目标能够找到并包含所需的头文件。

语法

target_include_directories(<target> [SYSTEM] [AFTER|BEFORE] [<interface>|<public>|<private>] [items1 [items2 ...]])

参数解释

<target>: 需要添加包含目录的目标的名称。这必须是一个已经通过 add_executable 或 add_library 命令创建的目标。
[SYSTEM]: 可选标志，表示指定的包含目录是系统目录。这通常用于指示编译器这些目录中的头文件是系统头文件，可能影响编译器的警告和错误处理。
[AFTER|BEFORE]: 可选标志，指定添加的包含目录是放在现有包含目录列表的之后（AFTER，默认值）还是之前（BEFORE）。
[<interface>|<public>|<private>]: 可选标志，指定包含目录的范围（可见性）：
- INTERFACE: 表示这些包含目录是接口的一部分，将被传播到依赖这个目标的其他目标。
- PUBLIC: 表示这些包含目录既用于当前目标，也传播到依赖它的目标。
- PRIVATE: 表示这些包含目录仅用于当前目标，不会传播到依赖它的目标。
[items1 [items2 ...]]: 一个或多个包含目录的路径。这些路径可以是绝对路径，也可以是相对于当前源目录或构建目录的相对路径。

示例

为目标添加包含目录:

target_include_directories(MyTarget PRIVATE /path/to/include)
这将为 MyTarget 添加一个私有的包含目录 /path/to/include。
为目标和依赖它的目标添加包含目录:

target_include_directories(MyTarget PUBLIC /path/to/include)
这将为 MyTarget 和所有依赖 MyTarget 的目标添加一个公共的包含目录 /path/to/include。
添加系统包含目录:

target_include_directories(MyTarget SYSTEM /path/to/system/include)
这将为 MyTarget 添加一个系统包含目录 /path/to/system/include，编译器可能会以不同的方式处理这些目录中的头文件（例如，减少警告）。
在现有包含目录之前添加目录:

target_include_directories(MyTarget BEFORE /path/to/include)
这将把 /path/to/include 添加到 MyTarget 的现有包含目录列表之前。