cmake 引入自己的库 能提供个例子么

当然可以，以下是一个简单的例子：

假设你有一个名为"mylib"的库，它的源代码位于"/path/to/mylib"目录下。你想在你的项目中使用这个库，可以按照以下步骤进行：

1. 在你的项目根目录下创建一个名为"CMakeLists.txt"的文件，并添加以下内容：

cmake_minimum_required(VERSION 3.0)

project(myproject)

add_subdirectory(/path/to/mylib)

add_executable(myapp main.cpp)

target_link_libraries(myapp mylib)

2. 在你的项目根目录下创建一个名为"main.cpp"的文件，并添加以下内容：

#include <mylib/mylib.h>

int main()
{
    mylib::hello();
    return 0;
}

3. 在你的项目根目录下执行以下命令：

mkdir build
cd build
cmake ..
make

4. 运行生成的可执行文件"myapp"，你应该能看到"Hello, world!"的输出。

这个例子中，我们通过"add_subdirectory"命令引入了"mylib"库的源代码，并通过"target_link_libraries"命令将"myapp"可执行文件链接到"mylib"库。

相关问题

cmake引入动态库并在c++中使用的例子

假设我们有一个动态库 `libfoo.so`，并且我们想在 C++ 代码中使用它。下面是一个简单的示例：

首先，我们需要编写一个 CMakeLists.txt 文件来指示 CMake 如何生成我们的可执行文件和链接我们的动态库。假设我们的源代码文件是 `main.cpp`，我们的动态库位于 `/path/to/libfoo.so`。我们可以这样编写 CMakeLists.txt 文件：

cmake_minimum_required(VERSION 3.10)
project(MyProject)

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

# 添加动态库目录和名称
link_directories(/path/to)
target_link_libraries(my_executable foo)

其中，我们使用 `add_executable` 命令来创建一个名为 `my_executable` 的可执行文件，并将 `main.cpp` 添加为源文件。然后，我们使用 `link_directories` 命令来指定我们的动态库所在的目录，并使用 `target_link_libraries` 命令将动态库链接到我们的可执行文件中。

接下来，我们需要在 C++ 代码中包含动态库的头文件并使用其中的函数。假设我们的动态库定义了一个名为 `foo` 的函数，我们可以这样编写 `main.cpp`：

#include <iostream>
#include "foo.h"

int main() {
    std::cout << foo() << std::endl;
    return 0;
}

在这个例子中，我们包含了 `foo.h` 头文件并调用了 `foo` 函数，并将其输出到标准输出。

最后，我们可以使用以下命令来编译和运行我们的代码：

mkdir build
cd build
cmake ..
make
./my_executable

这将生成一个名为 `my_executable` 的可执行文件，并将动态库链接到其中。当我们运行可执行文件时，它将调用 `foo` 函数并将其输出到控制台。

cmake里面引入动态库 并使用的例子

假设有一个名为`myapp`的可执行文件，需要引入名为`libfoo.so`的动态库并使用其中的函数，可以按照以下步骤进行：

1. 创建`CMakeLists.txt`文件，并在其中添加以下内容：

   cmake_minimum_required(VERSION 3.5)
   project(myapp)
   
   add_executable(myapp main.cpp)
   
   find_library(foo NAMES foo PATHS /usr/local/lib)
   target_link_libraries(myapp ${foo})

其中，`main.cpp`是`myapp`的源文件，`foo`是要引入的动态库的名称，`/usr/local/lib`是`libfoo.so`所在的路径。

2. 创建`main.cpp`文件，并在其中使用`libfoo.so`中的函数：

   #include <iostream>
   #include <dlfcn.h>
   
   typedef int (*foo_func_t)(int, int);
   
   int main()
   {
       void *handle = dlopen("libfoo.so", RTLD_LAZY);
       if (!handle) {
           std::cerr << "Error: " << dlerror() << std::endl;
           return 1;
       }
   
       foo_func_t foo_func = (foo_func_t)dlsym(handle, "foo");
       if (!foo_func) {
           std::cerr << "Error: " << dlerror() << std::endl;
           dlclose(handle);
           return 1;
       }
   
       int result = foo_func(3, 4);
       std::cout << "Result: " << result << std::endl;
   
       dlclose(handle);
       return 0;
   }

在`main.cpp`中，首先使用`dlopen`函数打开`libfoo.so`动态库，然后使用`dlsym`函数获取其中的`foo`函数，并将其保存到函数指针变量`foo_func`中。最后，调用`foo_func`函数并输出结果。

注意，这里使用了`dlfcn.h`头文件中的函数，需要在编译时链接`dl`库，可以在`CMakeLists.txt`中添加以下命令：

   target_link_libraries(myapp dl)

3. 在命令行中执行以下命令进行编译：

   mkdir build
   cd build
   cmake ..
   make

编译完成后，可以运行`myapp`可执行文件，输出结果应为`Result: 7`。