MENU
  1. ホーム
  2. C++
  3. C++でのCMakeを使ったクロスプラットフォームビルド方法

C++でのCMakeを使ったクロスプラットフォームビルド方法

C++

C++プロジェクトをクロスプラットフォームでビルドする際、効率的かつ一貫性を保つためにCMakeを使用することが一般的です。CMakeは、オープンソースのビルドシステムであり、プラットフォームに依存しないプロジェクト設定を提供します。これにより、開発者はWindows、macOS、Linuxなどの異なる環境で同じコードベースを簡単にビルドし、デプロイすることができます。本記事では、CMakeの基本概念から始め、具体的な設定方法や外部ライブラリの利用、クロスコンパイルの手法まで、詳しく解説していきます。C++プロジェクトのクロスプラットフォームビルドに関心のある方々にとって、実践的な知識を提供することを目指します。

目次

CMakeとは

CMakeは、ソフトウェア開発におけるビルド管理ツールであり、クロスプラットフォームでのプロジェクト設定を容易にするために設計されています。CMakeは、コンパイラに依存しないビルド設定を記述するための高レベルなスクリプト言語を提供し、プロジェクトを簡単に構成できます。これにより、Windows、macOS、Linuxなどの異なるプラットフォーム間での一貫したビルドプロセスを実現します。

主な機能

CMakeの主な機能には以下のようなものがあります。

  • プラットフォーム非依存性：異なるOSで同じ設定を使用可能
  • ビルドシステムの生成：Makefiles、Visual Studioプロジェクト、Xcodeプロジェクトなどを自動生成
  • 依存関係の管理：外部ライブラリやモジュールの依存関係を簡単に管理
  • 設定のカスタマイズ：ビルド時に特定のオプションを設定可能

利用シーン

CMakeは、小規模なプロジェクトから大規模なプロジェクトまで幅広く利用されており、特に以下のシーンで活躍します。

  • 複数のプラットフォームを対象とするプロジェクト
  • 外部ライブラリやモジュールを多用するプロジェクト
  • 継続的インテグレーション（CI）環境での自動ビルド

CMakeを使用することで、開発者は複雑なビルド設定を簡略化し、効率的な開発環境を構築することができます。

CMakeのインストール

CMakeを利用するためには、まず各プラットフォームに適した方法でインストールを行う必要があります。以下では、主要なプラットフォームでのインストール手順を説明します。

Windowsでのインストール

  1. CMake公式サイト（https://cmake.org/）にアクセスし、Windows用のインストーラをダウンロードします。
  2. ダウンロードしたインストーラを実行し、画面の指示に従ってインストールを進めます。
  3. インストール時に、CMakeをコマンドラインから利用できるようにパスを設定します。

macOSでのインストール

  1. macOSでCMakeをインストールするには、Homebrewを利用するのが一般的です。Homebrewがインストールされていない場合は、公式サイト（https://brew.sh/）の手順に従ってインストールします。
  2. ターミナルを開き、以下のコマンドを実行してCMakeをインストールします。
   brew install cmake
  1. インストール後、以下のコマンドでバージョンを確認します。
   cmake --version

Linuxでのインストール

Linuxでは、ディストリビューションに応じてパッケージマネージャを利用してインストールします。

  • Debian系（Ubuntuなど）:
  sudo apt-get update
  sudo apt-get install cmake
  • Red Hat系（Fedoraなど）:
  sudo dnf install cmake
  • Arch系:
  sudo pacman -S cmake

インストールが完了したら、以下のコマンドでバージョンを確認します。

cmake --version

CMakeのインストールが完了したら、次にCMakeLists.txtファイルを作成してプロジェクトを構成する準備をします。

CMakeLists.txtの基本構成

CMakeを使ってプロジェクトを構成する際には、CMakeLists.txtファイルが重要な役割を果たします。このファイルには、プロジェクトのビルド設定や依存関係などの情報が記述されます。ここでは、CMakeLists.txtの基本的な構成について説明します。

基本構成要素

CMakeLists.txtファイルの基本的な要素は以下の通りです。

  1. CMakeの最小バージョンの設定:
   cmake_minimum_required(VERSION 3.10)
  1. プロジェクト名とバージョンの設定:
   project(MyProject VERSION 1.0)
  1. 実行ファイルの追加:
    プロジェクト内のソースファイルから実行ファイルを生成するための設定です。
   add_executable(MyExecutable main.cpp)
  1. ライブラリの追加:
    プロジェクト内のソースファイルからライブラリを生成するための設定です。
   add_library(MyLibrary STATIC mylibrary.cpp)
  1. ターゲットのインクルードディレクトリの指定:
    プロジェクトのターゲットに対してインクルードディレクトリを指定します。
   target_include_directories(MyExecutable PUBLIC ${PROJECT_SOURCE_DIR}/include)
  1. ターゲットのリンクライブラリの指定:
    プロジェクトのターゲットに対してリンクするライブラリを指定します。
   target_link_libraries(MyExecutable PRIVATE MyLibrary)

サンプルCMakeLists.txt

以下は、基本的なCMakeLists.txtファイルの例です。

cmake_minimum_required(VERSION 3.10)

# プロジェクトの名前とバージョンを設定
project(MyProject VERSION 1.0)

# 実行ファイルを追加
add_executable(MyExecutable main.cpp)

# ライブラリを追加
add_library(MyLibrary STATIC mylibrary.cpp)

# インクルードディレクトリを指定
target_include_directories(MyExecutable PUBLIC ${PROJECT_SOURCE_DIR}/include)

# リンクするライブラリを指定
target_link_libraries(MyExecutable PRIVATE MyLibrary)

このCMakeLists.txtファイルでは、プロジェクトの基本的な構成要素を定義し、必要な設定を行っています。これにより、CMakeを使ってプロジェクトをビルドするための準備が整います。次に、プロジェクトの具体的な設定方法について解説します。

プロジェクトの設定

CMakeを使用してC++プロジェクトを設定する際には、プロジェクトの構成や依存関係を正しく定義することが重要です。ここでは、基本的なプロジェクト設定の手順を紹介します。

ディレクトリ構造の設定

プロジェクトを構成する際には、わかりやすいディレクトリ構造を設定することが推奨されます。例えば、以下のようなディレクトリ構造を使用することが一般的です。

MyProject/
├── CMakeLists.txt
├── src/
│   ├── main.cpp
│   └── mylibrary.cpp
├── include/
│   └── mylibrary.h
├── tests/
│   └── test_main.cpp
└── build/

このような構造により、ソースコード、ヘッダファイル、テストコードなどが整理され、管理しやすくなります。

CMakeLists.txtの設定

プロジェクトのディレクトリ構造を設定したら、CMakeLists.txtファイルに具体的なビルド設定を記述します。

  1. プロジェクトの宣言とバージョンの設定:
   cmake_minimum_required(VERSION 3.10)
   project(MyProject VERSION 1.0)
  1. ソースファイルとヘッダファイルの指定:
   set(SOURCES src/main.cpp src/mylibrary.cpp)
   set(HEADERS include/mylibrary.h)
  1. 実行ファイルの追加:
   add_executable(MyExecutable ${SOURCES})
  1. インクルードディレクトリの指定:
   target_include_directories(MyExecutable PUBLIC ${PROJECT_SOURCE_DIR}/include)
  1. ライブラリの追加とリンク:
   add_library(MyLibrary STATIC src/mylibrary.cpp)
   target_link_libraries(MyExecutable PRIVATE MyLibrary)
  1. ビルドタイプの設定:
    ビルドタイプを設定することで、デバッグや最適化のオプションを制御できます。
   set(CMAKE_BUILD_TYPE Release)

ビルド手順

CMakeLists.txtファイルの設定が完了したら、以下の手順でプロジェクトをビルドします。

  1. ビルドディレクトリの作成:
   mkdir build
   cd build
  1. ビルドシステムの生成:
   cmake ..
  1. プロジェクトのビルド:
   cmake --build .

この手順により、CMakeが指定された設定に基づいてプロジェクトをビルドします。次に、異なるプラットフォーム向けのビルドシステムを生成する手順を紹介します。

ビルドシステムの生成

CMakeを使用すると、異なるプラットフォーム向けのビルドシステムを簡単に生成することができます。ここでは、主要なプラットフォーム（Windows、macOS、Linux）に対してビルドシステムを生成する手順を紹介します。

Windows向けビルドシステムの生成

Windowsでは、CMakeを使用してVisual Studioプロジェクトを生成するのが一般的です。以下の手順で行います。

  1. ビルドディレクトリの作成と移動:
   mkdir build
   cd build
  1. CMakeを実行してVisual Studioプロジェクトを生成:
   cmake -G "Visual Studio 16 2019" ..

このコマンドにより、Visual Studio 2019用のソリューションファイルとプロジェクトファイルが生成されます。生成されたファイルは、Visual Studioで開いてビルドやデバッグを行うことができます。

macOS向けビルドシステムの生成

macOSでは、CMakeを使用してXcodeプロジェクトを生成することができます。

  1. ビルドディレクトリの作成と移動:
   mkdir build
   cd build
  1. CMakeを実行してXcodeプロジェクトを生成:
   cmake -G "Xcode" ..

このコマンドにより、Xcode用のプロジェクトファイルが生成されます。生成されたプロジェクトファイルをXcodeで開き、ビルドやデバッグを行うことができます。

Linux向けビルドシステムの生成

Linuxでは、CMakeを使用してMakefilesを生成することが一般的です。

  1. ビルドディレクトリの作成と移動:
   mkdir build
   cd build
  1. CMakeを実行してMakefilesを生成:
   cmake ..
  1. Makeコマンドを実行してプロジェクトをビルド:
   make

この手順により、Makefilesが生成され、makeコマンドを実行することでプロジェクトをビルドできます。

共通オプションの使用

CMakeでは、共通のビルドオプションを使用して、より細かい設定を行うことができます。例えば、デバッグビルドやリリースビルドを指定するために、以下のようにCMAKE_BUILD_TYPEを設定します。

cmake -DCMAKE_BUILD_TYPE=Debug ..
cmake -DCMAKE_BUILD_TYPE=Release ..

これにより、デバッグシンボルを含むデバッグビルドや最適化されたリリースビルドを生成することができます。

以上の手順により、CMakeを使用して異なるプラットフォーム向けのビルドシステムを簡単に生成することができます。次に、CMakeで外部ライブラリを利用する方法を説明します。

外部ライブラリの利用

C++プロジェクトでは、外部ライブラリを利用することが多く、CMakeはこれらのライブラリを簡単に統合するための機能を提供しています。ここでは、CMakeを使って外部ライブラリをプロジェクトに取り込む方法について説明します。

Findモジュールの使用

CMakeには、標準ライブラリや一般的なサードパーティライブラリを見つけるためのFindモジュールが多数用意されています。これらのモジュールを使用してライブラリを検出し、プロジェクトにリンクすることができます。例えば、Boostライブラリを使用する場合は次のようにします。

  1. FindBoostモジュールの使用:
   find_package(Boost 1.70 REQUIRED COMPONENTS filesystem system)
  1. ヘッダファイルのインクルードディレクトリを指定:
   include_directories(${Boost_INCLUDE_DIRS})
  1. ターゲットにライブラリをリンク:
   target_link_libraries(MyExecutable Boost::filesystem Boost::system)

Configモジュールの使用

いくつかのライブラリは、自身のCMake設定ファイル（Configモジュール）を提供しています。これを利用すると、より簡単にライブラリをプロジェクトに統合できます。例えば、SQLiteを使用する場合は次のようにします。

  1. find_packageを使用してSQLiteを検出:
   find_package(SQLite3 REQUIRED)
  1. ヘッダファイルのインクルードディレクトリを指定:
   include_directories(${SQLite3_INCLUDE_DIRS})
  1. ターゲットにライブラリをリンク:
   target_link_libraries(MyExecutable ${SQLite3_LIBRARIES})

ExternalProjectモジュールの使用

CMakeのExternalProjectモジュールを使用すると、ソースコードから直接外部プロジェクトをダウンロード、ビルド、およびインストールできます。例えば、Google Testをプロジェクトに組み込む場合は次のようにします。

  1. ExternalProjectモジュールのインクルード:
   include(ExternalProject)
  1. Google Testプロジェクトの追加:
   ExternalProject_Add(
       googletest
       GIT_REPOSITORY https://github.com/google/googletest.git
       GIT_TAG release-1.10.0
       CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/googletest
   )
  1. Google Testライブラリのリンク:
   add_library(gtest IMPORTED STATIC GLOBAL)
   set_target_properties(gtest PROPERTIES
       IMPORTED_LOCATION ${CMAKE_BINARY_DIR}/googletest/lib/libgtest.a
       INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_BINARY_DIR}/googletest/include
   )
   target_link_libraries(MyExecutable gtest)

FetchContentモジュールの使用

FetchContentモジュールは、外部ライブラリを簡単に取得してビルドするための便利な方法を提供します。例えば、fmtライブラリを使用する場合は次のようにします。

  1. FetchContentモジュールのインクルード:
   include(FetchContent)
  1. fmtライブラリのダウンロードとインクルード:
   FetchContent_Declare(
       fmt
       GIT_REPOSITORY https://github.com/fmtlib/fmt.git
       GIT_TAG 8.0.1
   )
   FetchContent_MakeAvailable(fmt)
  1. ターゲットにfmtライブラリをリンク:
   target_link_libraries(MyExecutable fmt)

これらの方法を使用することで、CMakeプロジェクトに外部ライブラリを簡単に取り込み、依存関係を効率的に管理することができます。次に、異なるアーキテクチャ向けにクロスコンパイルする方法を解説します。

クロスコンパイルの設定

クロスコンパイルとは、特定のプラットフォームやアーキテクチャ向けにプログラムをビルドすることを指します。CMakeはクロスコンパイルをサポートしており、異なる環境向けにプロジェクトをビルドするための設定が可能です。ここでは、CMakeを使用してクロスコンパイルを設定する方法を説明します。

クロスコンパイルツールチェーンファイルの作成

クロスコンパイルを行うには、ツールチェーンファイルを作成し、ターゲットプラットフォームのコンパイラやリンカを指定する必要があります。以下に、Raspberry Pi向けのツールチェーンファイルの例を示します。

# Toolchain file: arm-gcc-toolchain.cmake
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR arm)

# クロスコンパイル用コンパイラのパスを設定
set(CMAKE_C_COMPILER /usr/bin/arm-linux-gnueabihf-gcc)
set(CMAKE_CXX_COMPILER /usr/bin/arm-linux-gnueabihf-g++)

# 必要なライブラリやインクルードディレクトリの設定
set(CMAKE_FIND_ROOT_PATH /usr/arm-linux-gnueabihf)
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

プロジェクトのクロスコンパイル設定

ツールチェーンファイルを作成したら、CMakeを実行する際にこのファイルを指定してプロジェクトを設定します。

  1. ビルドディレクトリの作成と移動:
   mkdir build
   cd build
  1. ツールチェーンファイルを指定してCMakeを実行:
   cmake -DCMAKE_TOOLCHAIN_FILE=../arm-gcc-toolchain.cmake ..
  1. プロジェクトのビルド:
   cmake --build .

具体例：ARM向けクロスコンパイル

以下に、具体的なクロスコンパイル設定の例を示します。ここでは、ARMアーキテクチャ向けにビルドするための手順を紹介します。

  1. ツールチェーンファイルの作成:
   # File: arm-toolchain.cmake
   set(CMAKE_SYSTEM_NAME Linux)
   set(CMAKE_SYSTEM_PROCESSOR arm)

   set(CMAKE_C_COMPILER /usr/bin/arm-linux-gnueabihf-gcc)
   set(CMAKE_CXX_COMPILER /usr/bin/arm-linux-gnueabihf-g++)

   set(CMAKE_FIND_ROOT_PATH /usr/arm-linux-gnueabihf)
   set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
   set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
   set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
  1. CMakeの実行:
   mkdir build
   cd build
   cmake -DCMAKE_TOOLCHAIN_FILE=../arm-toolchain.cmake ..
   cmake --build .

ユニバーサルビルドの設定

macOSでは、ユニバーサルバイナリを作成するためのクロスコンパイルも可能です。以下の設定例では、x86_64とarm64の両方をサポートするユニバーサルバイナリを作成します。

  1. CMakeLists.txtの設定:
   set(CMAKE_OSX_ARCHITECTURES "x86_64;arm64" CACHE STRING "" FORCE)
  1. CMakeの実行:
   mkdir build
   cd build
   cmake ..
   cmake --build .

このように、CMakeを使用すると、異なるアーキテクチャやプラットフォーム向けにプロジェクトを簡単にクロスコンパイルできます。次に、CMakeを使ってユニットテストを実装する方法を紹介します。

ユニットテストの実装

CMakeを使用してプロジェクトにユニットテストを組み込むことで、コードの品質を確保し、バグを早期に発見することができます。ここでは、Google Testフレームワークを用いてC++プロジェクトにユニットテストを追加する方法を説明します。

Google Testの取得と設定

まず、Google Testをプロジェクトに追加します。Google TestはオープンソースのC++テストフレームワークで、広く使われています。

  1. Google Testをプロジェクトに組み込む:
    FetchContentモジュールを使ってGoogle Testを取得します。
   include(FetchContent)

   FetchContent_Declare(
     googletest
     GIT_REPOSITORY https://github.com/google/googletest.git
     GIT_TAG release-1.10.0
   )

   FetchContent_MakeAvailable(googletest)
  1. テストのターゲットを追加:
    CMakeLists.txtにテスト用のターゲットを追加します。
   enable_testing()

   add_executable(
     MyProjectTests
     tests/test_main.cpp
     tests/test_mylibrary.cpp
   )

   target_link_libraries(
     MyProjectTests
     gtest_main
   )

   include(GoogleTest)
   gtest_discover_tests(MyProjectTests)

テストコードの作成

次に、ユニットテストのコードを作成します。ここでは、mylibraryの関数をテストする例を示します。

  1. テスト用のメイン関数:
    Google Testは独自のmain関数を持つため、テスト用のメイン関数を作成します。
   // tests/test_main.cpp
   #include <gtest/gtest.h>

   int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();
   }
  1. 具体的なテストケース:
    テストしたい機能ごとにテストケースを作成します。
   // tests/test_mylibrary.cpp
   #include <gtest/gtest.h>
   #include "mylibrary.h"

   TEST(MyLibraryTest, FunctionReturnsTrue) {
     MyLibrary lib;
     EXPECT_TRUE(lib.myFunction());
   }

   TEST(MyLibraryTest, FunctionReturnsExpectedValue) {
     MyLibrary lib;
     EXPECT_EQ(lib.computeValue(2, 3), 5);
   }

テストのビルドと実行

CMakeでテストターゲットを設定したら、ビルドおよびテストを実行します。

  1. ビルドディレクトリの作成と移動:
   mkdir build
   cd build
  1. CMakeを実行してビルドシステムを生成:
   cmake ..
  1. プロジェクトのビルド:
   cmake --build .
  1. テストの実行:
    ビルドが成功したら、以下のコマンドでテストを実行します。
   ctest

これにより、Google Testを使って作成したユニットテストが実行され、結果が表示されます。

以上の手順で、CMakeを使用してプロジェクトにユニットテストを追加し、品質管理を強化することができます。次に、ビルドエラーや実行時エラーのデバッグ方法について解説します。

デバッグとトラブルシューティング

C++プロジェクトの開発中に遭遇するビルドエラーや実行時エラーを効率的にデバッグすることは非常に重要です。ここでは、CMakeを使用したプロジェクトにおけるデバッグとトラブルシューティングの方法について説明します。

ビルドエラーのデバッグ

ビルドエラーが発生した場合、以下の手順で問題を特定し修正します。

  1. エラーメッセージの確認:
    CMakeやコンパイラのエラーメッセージを注意深く読み、問題の箇所を特定します。エラーメッセージは問題の原因を示す手がかりとなります。
  2. CMakeLists.txtの見直し:
    CMakeLists.txtファイルに記述された設定を確認し、誤りや不足がないかチェックします。特に、ファイルのパスや依存関係の設定に注意します。
  3. インクルードディレクトリの確認:
    ヘッダファイルが正しくインクルードされているか確認します。CMakeLists.txtで設定したインクルードディレクトリが正しいか確認します。
   target_include_directories(MyExecutable PUBLIC ${PROJECT_SOURCE_DIR}/include)
  1. ライブラリのリンク設定:
    外部ライブラリが正しくリンクされているか確認します。ライブラリのパスが正しく設定されているか確認します。
   target_link_libraries(MyExecutable PRIVATE MyLibrary)

実行時エラーのデバッグ

実行時エラーが発生した場合、以下の手順で問題を特定し修正します。

  1. デバッガの使用:
    デバッガ（例：gdb、lldb、Visual Studioデバッガ）を使用してプログラムをステップ実行し、問題の箇所を特定します。
   gdb ./MyExecutable
  1. ログの追加:
    プログラムにログ出力を追加し、実行時の状態を確認します。ログを使って、どの部分で問題が発生しているかを特定します。
   std::cout << "FunctionX started" << std::endl;
  1. メモリ管理の確認:
    メモリリークや未定義の動作を検出するために、ツール（例：Valgrind）を使用してメモリ管理を確認します。
   valgrind ./MyExecutable
  1. ユニットテストの強化:
    ユニットテストを充実させ、個々の機能が期待通りに動作するか確認します。エラーが発生した場合、テストケースを追加して問題を再現しやすくします。

一般的なトラブルシューティングの手法

  1. CMakeキャッシュのクリア:
    CMakeのキャッシュが古くなっている場合、ビルドがうまくいかないことがあります。キャッシュをクリアして再ビルドします。
   rm -rf build/*
   cd build
   cmake ..
  1. ドキュメントとリソースの参照:
    CMakeの公式ドキュメントやライブラリのマニュアルを参照し、正しい設定や使用方法を確認します。
  2. コミュニティの利用:
    エラーが解決できない場合、Stack OverflowやGitHubのIssueトラッカーなどのコミュニティで質問し、助けを求めます。

以上の手法を用いることで、ビルドエラーや実行時エラーを効率的にデバッグし、プロジェクトを安定させることができます。次に、CMakeを使用してモバイルアプリをビルドする具体例を紹介します。

応用例:モバイルアプリのビルド

CMakeを使用すると、クロスプラットフォーム対応のモバイルアプリをビルドすることができます。ここでは、AndroidおよびiOS向けのアプリをCMakeでビルドする方法について説明します。

Androidアプリのビルド

AndroidアプリをCMakeでビルドするには、Android NDK（Native Development Kit）を使用します。以下の手順で設定を行います。

  1. Android NDKのインストール:
    Android NDKをダウンロードし、インストールします。Android StudioのSDK Managerからインストールすることも可能です。
  2. プロジェクトのディレクトリ構造:
    Androidプロジェクトのディレクトリ構造は以下のようになります。
   MyAndroidApp/
   ├── app/
   │   ├── build.gradle
   │   ├── src/
   │   │   ├── main/
   │   │   │   ├── cpp/
   │   │   │   │   ├── CMakeLists.txt
   │   │   │   │   ├── native-lib.cpp
   │   │   │   ├── java/
   │   │   │       ├── com/example/myandroidapp/
   │   │   │           ├── MainActivity.java
   ├── build.gradle
   ├── settings.gradle
  1. CMakeLists.txtの設定:
    app/src/main/cpp/ディレクトリにCMakeLists.txtファイルを作成します。
   cmake_minimum_required(VERSION 3.10)
   project(MyAndroidApp)

   add_library(native-lib SHARED native-lib.cpp)

   find_library(log-lib log)

   target_link_libraries(native-lib ${log-lib})
  1. Gradleファイルの設定:
    app/build.gradleファイルにCMakeの設定を追加します。
   android {
       ...
       externalNativeBuild {
           cmake {
               path "src/main/cpp/CMakeLists.txt"
               version "3.10.2"
           }
       }
   }

   dependencies {
       implementation fileTree(dir: "libs", include: ["*.jar"])
       ...
   }
  1. ネイティブコードの作成:
    app/src/main/cpp/native-lib.cppファイルにネイティブコードを記述します。
   #include <jni.h>
   #include <string>

   extern "C" JNIEXPORT jstring JNICALL
   Java_com_example_myandroidapp_MainActivity_stringFromJNI(JNIEnv* env, jobject /* this */) {
       std::string hello = "Hello from C++";
       return env->NewStringUTF(hello.c_str());
   }
  1. Javaコードの作成:
    app/src/main/java/com/example/myandroidapp/MainActivity.javaファイルにJavaコードを記述します。
   package com.example.myandroidapp;

   public class MainActivity extends AppCompatActivity {
       static {
           System.loadLibrary("native-lib");
       }

       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_main);

           TextView tv = findViewById(R.id.sample_text);
           tv.setText(stringFromJNI());
       }

       public native String stringFromJNI();
   }
  1. ビルドと実行:
    Android Studioでプロジェクトを開き、ビルドおよび実行します。

iOSアプリのビルド

iOSアプリをCMakeでビルドするには、XcodeとCMakeを使用します。

  1. プロジェクトのディレクトリ構造:
    iOSプロジェクトのディレクトリ構造は以下のようになります。
   MyiOSApp/
   ├── CMakeLists.txt
   ├── main.cpp
   ├── MyiOSApp.xcodeproj
  1. CMakeLists.txtの設定:
    プロジェクトのルートディレクトリにCMakeLists.txtファイルを作成します。
   cmake_minimum_required(VERSION 3.10)
   project(MyiOSApp)

   add_executable(MyiOSApp main.cpp)
   set_target_properties(MyiOSApp PROPERTIES
       MACOSX_BUNDLE TRUE
       MACOSX_BUNDLE_INFO_PLIST ${CMAKE_SOURCE_DIR}/Info.plist
   )
  1. ネイティブコードの作成:
    main.cppファイルにネイティブコードを記述します。
   #include <iostream>

   int main(int argc, char *argv[]) {
       std::cout << "Hello, iOS from C++!" << std::endl;
       return 0;
   }
  1. Xcodeプロジェクトの生成:
    CMakeを使用してXcodeプロジェクトを生成します。
   mkdir build
   cd build
   cmake -G "Xcode" ..
  1. Xcodeでビルドと実行:
    生成されたXcodeプロジェクトを開き、ビルドおよび実行します。

以上の手順で、CMakeを使用してAndroidおよびiOS向けのモバイルアプリをビルドすることができます。これにより、クロスプラットフォーム対応のアプリ開発が容易になります。次に、まとめとして本記事の内容を総括します。

まとめ

本記事では、C++プロジェクトにおけるCMakeを使用したクロスプラットフォームビルドの方法について解説しました。CMakeの基本概念から始まり、具体的なインストール手順、プロジェクト設定、ビルドシステムの生成、外部ライブラリの利用、クロスコンパイルの設定、ユニットテストの実装、デバッグとトラブルシューティング、そしてモバイルアプリのビルドといった各ステップを詳しく説明しました。

CMakeを使用することで、複雑なビルド設定をシンプルにし、異なるプラットフォーム間で一貫性のあるビルド環境を構築できます。特にクロスプラットフォーム対応が求められる現代のソフトウェア開発において、CMakeの活用は非常に有用です。

本記事が、C++プロジェクトのビルドプロセスを効率化し、開発をスムーズに進めるための一助となることを願っています。CMakeをマスターして、さらに高度なクロスプラットフォーム開発に挑戦してみてください。

C++
ビルド クロスプラットフォーム C++ CMake

コメント

コメントする

目次