Boost

【C++】Boostアルゴリズムで文字列の大文字・小文字を効率的に変換する方法

2025-04-20更新日: 2025-04-20

C++ Boostの文字列操作ライブラリを使うと、boost::algorithm::to_upperやboost::algorithm::to_lowerで簡単に大文字・小文字変換ができます。

ロケール対応でUnicode文字も扱え、元の文字列を壊さず新規文字列を生成するので実用性が高いです。

目次から探す
  1. 利用前の準備
  2. 基本的な to_upper/to_lower の活用
  3. Unicode 対応
  4. パフォーマンス考慮
  5. カスタム要件への対応
  6. 他のアルゴリズムとの併用
  7. 具体例
  8. まとめ

利用前の準備

C++でBoostアルゴリズムを使って文字列の大文字・小文字を変換するには、まず必要なヘッダファイルをインクルードし、名前空間の設定を行う必要があります。

これにより、コードの記述が簡潔になり、Boostの関数をスムーズに利用できるようになります。

<boost/algorithm/string.hpp>のインクルード

Boostライブラリの文字列操作に関する機能は、<boost/algorithm/string.hpp>ヘッダに集約されています。

このヘッダをインクルードすることで、to_upperやto_lowerといった関数を利用できるようになります。

#include <boost/algorithm/string.hpp>

この一行をソースコードの先頭に記述するだけで、Boostの文字列操作に関する豊富な関数群を使用可能となります。

using namespace boost::algorithm;の設定

Boostの関数は、boost::algorithm名前空間に属しています。

これを毎回記述するのは冗長になるため、using namespaceを使って名前空間を省略することが一般的です。

using namespace boost::algorithm;

この一行を記述しておくと、to_upper, to_lowerなどの関数をboost::algorithm::を付けずに直接呼び出せるようになります。

Boostの文字列操作機能を効率的に使うためには、次の2つの準備が必要です。

  • <boost/algorithm/string.hpp>のインクルード
  • using namespace boost::algorithm;の設定

これらを行うことで、コードの可読性と記述の簡潔さが向上し、文字列の大文字・小文字変換をスムーズに実現できます。

基本的な to_upper/to_lower の活用

Boostのto_upperとto_lowerは、文字列全体の大文字・小文字変換を簡単に行える関数です。

これらの関数は、文字列の内容を一括で変換したい場合に非常に便利です。

以下に、それぞれの関数の具体的な使い方と挙動について詳しく解説します。

to_upper の呼び出し例

to_upperは、指定した文字列の内容をすべて大文字に変換します。

変換は、引数として渡した文字列の内容を直接変更します。

返り値はvoidであり、変換後の文字列は引数として渡した文字列に反映されます。

#include <boost/algorithm/string.hpp>
#include <iostream>
int main() {
    // 変換対象の文字列
    std::string message = "Hello, Boost!";
    // 文字列を大文字に変換
    boost::to_upper(message); // Boostライブラリを使用して大文字に変換
    // 変換結果を出力
    std::cout << message << std::endl; // 出力: HELLO, BOOST!
    return 0;
}
HELLO, BOOST!

この例では、messageの内容が"Hello, Boost!"から"HELLO, BOOST!"に変わっています。

to_upperは、引数の文字列を直接変更するため、変換後の値を新たに取得する必要はありません。

to_lower の呼び出し例

to_lowerは、文字列の内容をすべて小文字に変換します。

こちらも引数の文字列を直接変更し、返り値はvoidです。

#include <boost/algorithm/string.hpp>
#include <iostream>
int main() {
    // 変換対象の文字列
    std::string message = "Boost Library!";
    // 文字列を小文字に変換
    boost::to_lower(message);
    // 変換結果を出力
    std::cout << message << std::endl; // 出力: boost library!
    return 0;
}
boost library!

この例では、"Boost Library!"が"boost library!"に変換されていることがわかります。

to_lowerもto_upperと同様に、引数の文字列を直接変更します。

戻り値と参照渡しの違い

to_upperとto_lowerは、どちらもvoidを返す関数であり、引数として渡した文字列を直接変更します。

これにより、関数呼び出し後に変換結果を別の変数に格納する必要はありません。

一方、Boostにはboost::algorithm::to_upper_copyやboost::algorithm::to_lower_copyといった、変換結果を新しい文字列として返す関数もあります。

これらは、元の文字列を変更せずに変換結果を得たい場合に便利です。

#include <boost/algorithm/string.hpp>
#include <iostream>
int main() {
    std::string original = "Sample Text";
    // 変換結果を新しい文字列に格納
    std::string upper_copy = boost::to_upper_copy(original);
    std::cout << "元の文字列: " << original << std::endl; // 出力: Sample Text
    std::cout << "大文字のコピー: " << upper_copy << std::endl; // 出力: SAMPLE TEXT
    return 0;
}
元の文字列: Sample Text
大文字のコピー: SAMPLE TEXT

この例では、originalは変更されず、boost::to_upper_copyによって新たに大文字に変換された文字列がupper_copyに格納されています。

  • to_upperとto_lowerは、引数の文字列を直接変更し、返り値はvoid
  • 変換結果を新しい文字列として取得したい場合は、boost::to_upper_copyやboost::to_lower_copyを使います
  • これらの関数を使うことで、文字列の大文字・小文字変換を簡潔に行えます

これらの基本的な使い方を理解しておくと、Boostの文字列操作を効率的に活用できるようになります。

Unicode 対応

C++標準ライブラリやBoostライブラリの文字列操作関数は、基本的にASCIIやロケールに依存した文字列に対して設計されています。

したがって、多言語やUnicode文字列を扱う場合には、特別な配慮が必要です。

ここでは、std::wstringやstd::u16stringを用いたUnicode対応の方法、std::localeを指定した挙動の変更、そしてBoost.Localeとの連携について詳しく解説します。

std::wstringやstd::u16stringでの変換

std::wstringは、ワイド文字列を扱うための標準的な文字列型です。

Windows環境ではUTF-16エンコーディングに対応し、wchar_tは2バイト(UTF-16)を格納します。

一方、std::u16stringはC++11から導入されたUTF-16エンコーディング専用の文字列型です。

これらの文字列型に対して大文字・小文字変換を行う場合、boost::algorithm::to_upperやto_lowerは直接適用できません。

なぜなら、これらの関数はstd::stringを対象としており、wchar_tやchar16_tには対応していないからです。

そのため、Unicode文字列の大文字・小文字変換には、次のような方法を採用します。

  • std::wstringの場合：std::towupperやstd::towlowerを使い、各文字に対して変換を行うループを作成します
  • std::u16stringの場合：std::char16_tに対してstd::towupperやstd::towlowerは使えません。代わりに、Boost.Localeや他のライブラリを利用します

例として、std::wstringの全文字を大文字に変換するコードは以下の通りです。

#include <locale>
#include <string>
#include <iostream>
int main() {
    std::wstring ws = L"こんにちは、Boost！";
    // 各文字に対して大文字変換を適用
    for (auto& ch : ws) {
        ch = std::towupper(ch);
    }
    std::wcout << ws << std::endl; // 出力例：こんにちは、BOOST！
    return 0;
}

ただし、std::towupperやstd::towlowerは、ロケールに依存し、すべてのUnicode文字に正しく対応できるわけではありません。

特に、多言語対応や特殊な文字については、次に紹介するBoost.Localeの利用が推奨されます。

std::locale指定による挙動変更

std::toupperやstd::towlowerは、std::localeを指定することで挙動を変更できます。

これにより、特定のロケールに基づいた大文字・小文字変換を行うことが可能です。

#include <locale>
#include <string>
#include <iostream>
int main() {
    std::wstring ws = L"istanbul";
    // トルコ語のロケールを指定
    std::locale turkish_locale("tr_TR.UTF-8");
    for (auto& ch : ws) {
        ch = std::toupper(ch, turkish_locale);
    }
    std::wcout << ws << std::endl; // 出力例：İSTANBUL
    return 0;
}

MinGW版のGCCでは動かないことが多いので注意

この例では、トルコ語のロケールを指定してstd::toupperを適用しています。

トルコ語では、iの大文字はİ(ドット付きI)となるため、ロケールによる挙動の違いが反映されます。

ただし、std::localeの設定だけでは、すべてのUnicode文字に対応できるわけではありません。

特に、UTF-8やUTF-16のエンコーディングにおいては、文字単位の変換だけでは不十分なケースもあります。

これらの方法を適切に選択し、多言語環境やUnicode文字列の処理に対応してください。

パフォーマンス考慮

大量の文字列や長大なデータを扱う場合、文字列変換のパフォーマンスが重要となります。

ここでは、大規模文字列での実行速度を向上させるためのポイントと、イテレータ範囲を利用した効率的な一括変換の方法について解説します。

大規模文字列での実行速度

大きな文字列に対してto_upperやto_lowerを適用すると、処理時間が増加し、パフォーマンスの低下を招くことがあります。

特に、数百万文字規模のデータを処理する場合には、最適化が必要です。

Boostのto_upperやto_lowerは、内部的にループを用いて各文字に対して変換処理を行います。

これを効率的に行うためには、次のポイントに注意します。

  • ループの最適化：ループ内での不要な処理や関数呼び出しを避け、できるだけシンプルに保ちます
  • メモリの連続性：文字列のメモリが連続していることを利用し、キャッシュ効率を高める
  • 並列処理：可能であれば、複数のスレッドを用いて並列化を行います。ただし、Boostの標準関数はシングルスレッド向けのため、並列化には別途工夫が必要でしょう

例として、長大な文字列に対してto_upperを適用する場合のパフォーマンス向上策は以下の通りです。

#include <boost/algorithm/string.hpp>
#include <vector>
#include <string>
#include <chrono>
#include <iostream>
int main() {
    // 1千万文字の長大な文字列を生成
    std::string large_str(10000000, 'a');
    auto start_time = std::chrono::steady_clock::now();
    // in-placeで大文字に変換
    boost::algorithm::to_upper(large_str);
    auto end_time = std::chrono::steady_clock::now();
    std::chrono::duration<double> elapsed_seconds = end_time - start_time;
    std::cout << "処理時間: " << elapsed_seconds.count() << "秒" << std::endl;
    return 0;
}
処理時間: 0.0237455秒

この例では、処理時間を計測し、パフォーマンスの目安を把握できます。

カスタム要件への対応

標準のto_upperやto_lowerは、文字列全体を対象に変換を行いますが、特定の文字だけを対象にしたい場合や、条件に応じて変換処理をカスタマイズしたい場合もあります。

ここでは、特定の文字のみを対象にする方法と、条件付きで変換処理を自作する方法について解説します。

特定文字のみ対象にする方法

特定の文字だけを変換対象にしたい場合、boost::algorithmの関数と標準のアルゴリズムを組み合わせて実現できます。

具体的には、std::transformやstd::for_eachと、条件判定を行うラムダ式を併用します。

例として、文字列中の母音だけを大文字に変換する方法を示します。

#include <algorithm>
#include <string>
#include <iostream>
bool is_vowel(char c) {
    static const std::string vowels = "aeiouAEIOU";
    return vowels.find(c) != std::string::npos;
}
int main() {
    std::string text = "This is a sample sentence.";
    std::transform(text.begin(), text.end(), text.begin(),
        [](char c) {
            if (is_vowel(c)) {
                return static_cast<char>(std::toupper(c));
            } else {
                return c;
            }
        }
    );
    std::cout << text << std::endl; // 出力例：ThIs Is A sAmplE sEntEncE.
    return 0;
}
ThIs Is A sAmplE sEntEncE.

この例では、is_vowel関数で母音かどうかを判定し、母音だけを大文字に変換しています。

条件に合致した文字だけを変換対象にできるため、柔軟なカスタマイズが可能です。

条件付き変換関数の自作

より複雑な条件や処理を行いたい場合、自作の条件付き変換関数を作成すると便利です。

例えば、特定の範囲の文字だけを変換したり、特定のパターンに一致する文字だけを変換したりできます。

以下は、文字列中の英数字だけを大文字に変換する例です。

#include <algorithm>
#include <cctype>
#include <string>
#include <iostream>
bool is_alnum(char c) {
    return std::isalnum(static_cast<unsigned char>(c));
}
int main() {
    std::string text = "Hello, World! 123.";
    std::transform(text.begin(), text.end(), text.begin(),
        [](char c) {
            if (is_alnum(c)) {
                return static_cast<char>(std::toupper(c));
            } else {
                return c;
            }
        }
    );
    std::cout << text << std::endl; // 出力例：HELLO, WORLD! 123.
    return 0;
}
HELLO, WORLD! 123.

このように、自作の条件関数を用意し、std::transformやstd::for_eachと組み合わせることで、細かい条件に基づいた変換処理を実現できます。

  • 特定の文字だけを対象にしたい場合は、条件判定を行う関数とstd::transformやstd::for_eachを併用します
  • 複雑な条件やパターンに基づく変換には、自作の条件付き変換関数を作成すると柔軟に対応できます
  • これらの方法を活用することで、標準の一括変換では対応できないカスタム要件にも対応可能となります

これらのテクニックを駆使して、必要に応じた文字列変換処理を実現し、より高度な文字列操作を行えるようにしましょう。

他のアルゴリズムとの併用

文字列の大文字・小文字変換だけでなく、正規表現や文字列のトリミング、分割といった他のアルゴリズムと併用することで、より高度で柔軟な文字列操作が可能となります。

ここでは、それらの併用例について詳しく解説します。

正規表現と連携した置換処理

正規表現は、パターンマッチングに優れたツールであり、特定のパターンに一致する部分だけを抽出・置換するのに適しています。

Boost.Regexや標準の<regex>ライブラリと組み合わせることで、文字列の一部だけを大文字・小文字に変換したり、特定のパターンに基づいて置換したりできます。

例として、メールアドレスのドメイン部分だけを大文字に変換する例を示します。

#include <regex>
#include <string>
#include <iostream>
int main() {
    std::string text = "Contact us at support@example.com or sales@example.com.";
    std::regex pattern(R"((@)([a-zA-Z0-9._-]+))");
    std::string result;
    auto begin = std::sregex_iterator(text.begin(), text.end(), pattern);
    auto end = std::sregex_iterator();
    result = text; // 元の文字列をコピー
    for (auto it = begin; it != end; ++it) {
        std::string domain = (*it)[2].str();
        // ドメイン部分だけ大文字に変換
        std::transform(domain.begin(), domain.end(), domain.begin(), ::toupper);
        // 置換
        result.replace(it->position(2), domain.length(), domain);
    }
    std::cout << result << std::endl;
    // 出力例：Contact us at support@EXAMPLE.COM or sales@EXAMPLE.COM.
    return 0;
}
Contact us at support@EXAMPLE.COM or sales@EXAMPLE.COM.

この例では、正規表現を使ってメールアドレスのドメイン部分を抽出し、その部分だけを大文字に変換しています。

正規表現と文字列操作を併用することで、パターンに基づいた部分だけの変換が可能です。

トリミングや分割と組み合わせる

文字列の前後の空白を除去したり、特定の区切り文字で分割したりする操作と、文字列の大文字・小文字変換を組み合わせることもよくあります。

これにより、入力データの整形や解析を効率的に行えます。

例として、複数の単語を分割し、それぞれを大文字に変換してから再結合する例を示します。

#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <iostream>
int main() {
    std::string sentence = "  this is a sample sentence.  ";
    // 前後の空白をトリミング
    sentence.erase(0, sentence.find_first_not_of(" \t\n\r\f\v"));
    sentence.erase(sentence.find_last_not_of(" \t\n\r\f\v") + 1);
    // 空白で分割
    std::istringstream iss(sentence);
    std::vector<std::string> words;
    std::string word;
    while (iss >> word) {
        // 各単語を大文字に変換
        std::transform(word.begin(), word.end(), word.begin(), ::toupper);
        words.push_back(word);
    }
    // 再結合
    std::ostringstream oss;
    for (size_t i = 0; i < words.size(); ++i) {
        if (i != 0) oss << " ";
        oss << words[i];
    }
    std::cout << oss.str() << std::endl; // 出力例：THIS IS A SAMPLE SENTENCE.
    return 0;
}
THIS IS A SAMPLE SENTENCE.

この例では、文字列のトリミングと分割、変換、再結合を組み合わせて、整形済みの大文字の文章を作成しています。

  • 正規表現と併用することで、パターンに一致する部分だけを対象にした変換や置換が可能です
  • トリミングや分割と組み合わせることで、入力データの整形や解析を効率化できます
  • これらの併用により、より複雑な文字列操作やデータ前処理を柔軟に行えます

これらの技術を駆使して、実用的かつ効率的な文字列処理を実現し、さまざまなシナリオに対応できるようにしましょう。

具体例

実際のアプリケーションやデータ処理の場面では、特定の条件に基づいた文字列変換や、多言語を含む複雑な文字列の前処理が求められることがあります。

ここでは、英字のみを大文字化するケースと、多言語混在の文字列の前処理例について詳しく解説します。

英字のみ大文字化するケース

英字だけを対象に大文字化を行いたい場合、文字が英字かどうかを判定し、その条件に合致した文字だけを変換します。

これにより、数字や記号、その他の文字はそのまま保持され、英字だけが大文字に変換されます。

例として、文字列中の英字だけを大文字に変換するコードを示します。

#include <algorithm>
#include <cctype>
#include <string>
#include <iostream>
int main() {
    std::string text = "Hello, 世界! 123abc";
    std::transform(text.begin(), text.end(), text.begin(),
        [](char c) {
            if (std::isalpha(static_cast<unsigned char>(c))) {
                return static_cast<char>(std::toupper(c));
            } else {
                return c;
            }
        }
    );
    std::cout << text << std::endl; // 出力例：HELLO, 世界! 123ABC
    return 0;
}
HELLO, 世界! 123ABC

この例では、std::isalphaを使って英字かどうかを判定し、英字だけを大文字に変換しています。

数字や記号はそのまま残るため、必要な部分だけを変換できる柔軟性があります。

多言語混在文字列の前処理

多言語を含む文字列の前処理では、エンコーディングや文字の種類に応じた適切な処理が必要です。

特に、Unicode文字列のトリミングや分割、変換は、標準のcharベースの関数だけでは対応できない場合があります。

例として、多言語混在の文字列をトリミングし、各単語を大文字に変換してから再結合する例を示します。

#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
int main() {
    // 多言語混在の文字列(UTF-8)
    std::string text = "  こんにちは、Hello 世界！  ";
    // 先頭と末尾の空白をトリミング
    text.erase(0, text.find_first_not_of(" \t\n\r\f\v"));
    text.erase(text.find_last_not_of(" \t\n\r\f\v") + 1);
    // 空白で分割(UTF-8対応の分割は複雑なため、ここでは簡易的に空白区切りとする)
    std::istringstream iss(text);
    std::vector<std::string> words;
    std::string word;
    while (iss >> word) {
        // 各単語を大文字に変換(ASCII部分のみ)
        std::transform(word.begin(), word.end(), word.begin(),
                       [](unsigned char c) {
                           if (std::isalpha(c)) {
                               return static_cast<char>(std::toupper(c));
                           } else {
                               return static_cast<char>(c);
                           }
                       });
        words.push_back(word);
    }
    // 再結合
    std::ostringstream oss;
    for (size_t i = 0; i < words.size(); ++i) {
        if (i != 0) oss << " ";
        oss << words[i];
    }
    std::cout << "前処理後: " << oss.str() << std::endl;
    // 出力例：前処理後: こんにちは、HELLO 世界！
    return 0;
}
前処理後: こんにちは、HELLO 世界！

この例では、UTF-8文字列のトリミングと分割を行い、ASCII範囲の英字だけを大文字に変換しています。

ただし、多言語の完全なUnicode対応には、Boost.LocaleやICUライブラリの利用が推奨されます。

  • 英字だけを対象に大文字化したい場合は、std::isalphaやUnicode対応の判定関数と組み合わせて条件付き変換を行います
  • 多言語混在の文字列の前処理には、トリミングや分割、変換を適切に組み合わせる必要があります
  • Unicode対応や多言語処理には、Boost.LocaleやICUなどのライブラリを併用するとより正確な処理が可能です

これらの具体例を参考に、実際のアプリケーションやデータ処理の要件に合わせて適切な文字列操作を設計してください。

まとめ

この記事では、Boostライブラリを使った文字列の大文字・小文字変換の基本から、Unicode対応や多言語処理、パフォーマンス向上の工夫、カスタム要件への対応方法まで詳しく解説しました。

特定文字だけの変換や正規表現との併用、問題解決のポイントも紹介しています。

これらを理解し適用することで、多言語環境や大規模データの効率的な文字列操作が可能になります。

2025-04-20更新日: 2025-04-20

関連記事

【C++】Boost.Randomで範囲指定一様分布乱数を手軽に生成

2025-04-20

【C++】Boostのlcm関数で最小公倍数を簡単に計算する方法

2025-04-20

【C++】Boost Filesystemでファイル名変更を簡単に実現する方法

2025-04-20

【C++】Boostを活用した任意精度べき乗計算の実装例

2025-04-19

【C++】Boost.Geometryを活用した直角三角形の斜辺計算方法

2025-04-20

【C++】Boostで実現するフォルダ移動：ソースパスからターゲットパスへの基本操作

2025-04-20

【C++】Boostライブラリで実現する効率的な部分文字列抽出と操作方法

2025-04-20

【C++】Boostのis_base_ofを使った基底クラス継承判定の基本と実践

2025-04-20

【C++】Boost.Mathで正確に四捨五入する方法：roundとiround・lroundの使い分け

2025-04-20

【C++】Boost Multiprecisionで実現する多倍長浮動小数点数の高精度計算技法

2025-04-20
Back to top button
目次へ