[C++] char配列(char[]/char*)の使い方をわかりやすく解説

2025-04-15更新日: 2025-04-15

C++でのchar配列は、文字列や文字の集合を扱うために使用されます。

固定長の配列(例: char str[10];)やポインタ(例: char* str;)として宣言できます。

固定長配列はサイズが固定され、文字列の終端には必ずヌル文字\0が必要です。

ポインタは動的メモリ割り当てやリテラル文字列の参照に使われます。

文字列操作には標準ライブラリ関数(例: strcpy, strlen)を使用しますが、バッファオーバーフローに注意が必要です。

目次から探す

char配列の宣言と初期化
- char配列の宣言
- char配列の初期化
char配列の操作方法
char配列の注意点と落とし穴
char配列と動的メモリ割り当て
char配列を使った実践例
char配列と安全な文字列操作
まとめ

char配列の宣言と初期化

C++におけるchar配列は、文字列を扱うための基本的なデータ構造です。

char配列は、文字を格納するための連続したメモリ領域を提供します。

ここでは、char配列の宣言と初期化の方法について解説します。

char配列の宣言

char配列を宣言するには、以下のように記述します。

#include <iostream>
int main() {
    // char配列の宣言
    char myArray[10]; // 10文字分の配列を宣言
    return 0;
}

このコードでは、10文字分のchar配列myArrayを宣言しています。

配列のサイズは、必要な文字数に応じて変更できます。

char配列の初期化

char配列を初期化する方法はいくつかあります。

以下にいくつかの例を示します。

1. 文字列リテラルを使った初期化

#include <iostream>
int main() {
    // 文字列リテラルを使った初期化
    char myArray[] = "こんにちは"; // 自動的にサイズが決まる
    std::cout << myArray << std::endl; // 配列の内容を出力
    return 0;
}

このコードでは、文字列リテラル"こんにちは"を使ってmyArrayを初期化しています。

配列のサイズは自動的に決まります。

こんにちは

2. 各要素を個別に初期化

#include <iostream>
int main() {
    // 各要素を個別に初期化
    char myArray[5] = {'A', 'B', 'C', 'D', 'E'}; // サイズを指定
    for (int i = 0; i < 5; i++) {
        std::cout << myArray[i] << " "; // 各要素を出力
    }
    std::cout << std::endl;
    return 0;
}

このコードでは、各要素を個別に初期化しています。

配列のサイズは5に設定されています。

A B C D E

char配列は、文字列を扱うための基本的な構造であり、宣言と初期化の方法を理解することが重要です。

文字列リテラルを使った初期化や、各要素を個別に初期化する方法を使い分けることで、柔軟に文字列を扱うことができます。

char配列の操作方法

char配列は、文字列を扱うための基本的なデータ構造であり、さまざまな操作が可能です。

ここでは、char配列の基本的な操作方法について解説します。

1. 文字の代入

char配列の特定のインデックスに文字を代入することができます。

以下の例では、配列の特定の位置に新しい文字を代入しています。

#include <iostream>
int main() {
    char myArray[5] = {'a', 'b', 'c', 'd', 'e'}; // 初期化
    // 3番目の要素を変更
    myArray[2] = 'X'; // 'c'を'X'に変更
    for (int i = 0; i < 5; i++) {
        std::cout << myArray[i] << " "; // 各要素を出力
    }
    std::cout << std::endl;
    return 0;
}

a b X d e

2. 文字列の連結

C++では、標準ライブラリの関数を使ってchar配列同士を連結することができます。

以下の例では、strcat関数を使用しています。

#include <iostream>
#include <cstring> // strcatを使用するために必要
int main() {
    char str1[20] = "こんにちは"; // 文字列1
    char str2[] = "世界"; // 文字列2
    // 文字列の連結
    strcat(str1, str2); // str1にstr2を連結
    std::cout << str1 << std::endl; // 結果を出力
    return 0;
}

こんにちは世界

3. 文字列の長さを取得

char配列の長さを取得するには、strlen関数を使用します。

以下の例では、配列の長さを取得して出力しています。

#include <iostream>
#include <cstring> // strlenを使用するために必要
int main() {
    char myArray[] = "こんにちは"; // 初期化
    // 文字列の長さを取得
    size_t length = strlen(myArray); // 長さを取得
    std::cout << "文字列の長さ: " << length << std::endl; // 結果を出力
    return 0;
}

文字列の長さ: 5

文字数ではなくバイト数を返すので注意！

4. 文字列の比較

char配列同士を比較するには、strcmp関数を使用します。

以下の例では、2つの文字列を比較しています。

#include <iostream>
#include <cstring> // strcmpを使用するために必要
int main() {
    char str1[] = "こんにちは"; // 文字列1
    char str2[] = "こんにちは"; // 文字列2
    // 文字列の比較
    int result = strcmp(str1, str2); // 比較結果を取得
    if (result == 0) {
        std::cout << "文字列は同じです。" << std::endl; // 同じ場合
    } else {
        std::cout << "文字列は異なります。" << std::endl; // 異なる場合
    }
    return 0;
}

文字列は同じです。

char配列の操作方法には、文字の代入、文字列の連結、長さの取得、比較などがあります。

これらの基本的な操作を理解することで、文字列を効果的に扱うことができるようになります。

char配列の注意点と落とし穴

char配列は非常に便利なデータ構造ですが、使用する際にはいくつかの注意点や落とし穴があります。

ここでは、char配列を扱う際に気をつけるべきポイントを解説します。

1. 配列のサイズに注意

char配列を宣言する際には、配列のサイズを適切に設定する必要があります。

サイズが不足すると、バッファオーバーフローが発生し、プログラムが予期しない動作をする可能性があります。

#include <iostream>
int main() {
    char myArray[5]; // サイズ5の配列
    // サイズを超えた代入
    for (int i = 0; i < 10; i++) {
        myArray[i] = 'A'; // バッファオーバーフロー
    }
    return 0;
}

このコードでは、配列のサイズを超えて代入を行っているため、未定義の動作が発生します。

2. 文字列の終端を忘れない

C++のchar配列で文字列を扱う場合、文字列の終端を示すヌル文字'\0'を忘れないようにしましょう。

ヌル文字がないと、文字列の長さを正しく取得できず、バグの原因になります。

#include <iostream>
int main() {
    char myArray[5] = {'あ', 'い', 'う', 'え'}; // ヌル文字がない
    // ヌル文字を追加
    myArray[4] = '#include <iostream>
int main() {
char myArray[5] = {'あ', 'い', 'う', 'え'}; // ヌル文字がない
// ヌル文字を追加
myArray[4] = '\0'; // 正しく終端を示す
std::cout << myArray << std::endl; // 正しく出力される
return 0;
}'; // 正しく終端を示す
    std::cout << myArray << std::endl; // 正しく出力される
    return 0;
}

3. メモリ管理の重要性

動的にメモリを割り当てる場合、char配列のメモリ管理に注意が必要です。

newでメモリを確保した場合は、必ずdeleteで解放する必要があります。

解放を忘れると、メモリリークが発生します。

#include <iostream>
int main() {
    // 動的メモリ割り当て
    char* myArray = new char[10]; // サイズ10の配列を動的に確保
    // 使用後は必ず解放
    delete[] myArray; // メモリを解放
    return 0;
}

4. 文字列操作関数の使用に注意

C++の標準ライブラリには、char配列を操作するための関数がいくつか用意されていますが、これらの関数はバッファオーバーフローを引き起こす可能性があります。

特に、strcpyやstrcatなどの関数を使用する際は、配列のサイズを考慮する必要があります。

#include <iostream>
#include <cstring> // strcpyを使用するために必要
int main() {
    char dest[5]; // サイズ5の配列
    char src[] = "こんにちは"; // コピー元
    // バッファオーバーフローの危険
    strcpy(dest, src); // サイズを超えてコピー
    return 0;
}

このコードでは、strcpyを使用して配列のサイズを超えてコピーしているため、未定義の動作が発生します。

char配列を使用する際には、配列のサイズ、ヌル文字の管理、メモリ管理、文字列操作関数の使用に注意が必要です。

これらのポイントを理解し、適切に対処することで、より安全にchar配列を扱うことができます。

char配列と動的メモリ割り当て

C++では、char配列を動的にメモリ割り当てすることができます。

これにより、プログラムの実行時に必要なサイズの配列を作成することが可能になります。

ここでは、動的メモリ割り当ての方法とその注意点について解説します。

1. 動的メモリ割り当ての基本

動的メモリ割り当てには、new演算子を使用します。

以下の例では、ユーザーからの入力に基づいてchar配列を動的に作成しています。

#include <iostream>
int main() {
    int size;
    std::cout << "配列のサイズを入力してください: ";
    std::cin >> size; // ユーザーからサイズを取得
    // 動的メモリ割り当て
    char* myArray = new char[size]; // 指定したサイズの配列を確保
    // 配列に値を代入
    for (int i = 0; i < size; i++) {
        myArray[i] = 'A' + i; // 'A'から始まる文字を代入
    }
    // 配列の内容を出力
    for (int i = 0; i < size; i++) {
        std::cout << myArray[i] << " "; // 各要素を出力
    }
    std::cout << std::endl;
    // メモリを解放
    delete[] myArray; // 確保したメモリを解放
    return 0;
}

配列のサイズを入力してください: 5
A B C D E

2. メモリの解放

動的に確保したメモリは、使用後に必ず解放する必要があります。

解放を忘れると、メモリリークが発生し、プログラムのパフォーマンスに悪影響を及ぼします。

delete[]を使用して、配列のメモリを解放します。

3. サイズの変更

動的メモリ割り当てを使用すると、必要に応じてサイズを変更することも可能です。

realloc関数を使用することで、既存のメモリブロックのサイズを変更できますが、C++ではnewとdeleteを使うのが一般的です。

以下の例では、新しい配列を作成し、古い配列の内容をコピーしています。

#include <iostream>
#include <cstring> // memcpyを使用するために必要
int main() {
    int size = 5;
    char* myArray = new char[size]; // 初期サイズの配列を確保
    // 配列に値を代入
    for (int i = 0; i < size; i++) {
        myArray[i] = 'A' + i; // 'A'から始まる文字を代入
    }
    // サイズを変更するための新しい配列を確保
    int newSize = 10;
    char* newArray = new char[newSize]; // 新しいサイズの配列を確保
    // 古い配列の内容を新しい配列にコピー
    memcpy(newArray, myArray, size); // 古い配列の内容をコピー
    // 新しい配列の内容を出力
    for (int i = 0; i < size; i++) {
        std::cout << newArray[i] << " "; // 各要素を出力
    }
    std::cout << std::endl;
    // メモリを解放
    delete[] myArray; // 古い配列を解放
    delete[] newArray; // 新しい配列を解放
    return 0;
}

A B C D E

4. エラーチェック

動的メモリ割り当てを行う際には、メモリの確保が成功したかどうかを確認することが重要です。

メモリが不足している場合、newは例外をスローします。

以下のように、例外処理を行うことができます。

#include <iostream>
#include <new> // std::bad_allocを使用するために必要
int main() {
    try {
        char* myArray = new char[1000000000]; // 大きな配列を確保
    } catch (const std::bad_alloc& e) {
        std::cerr << "メモリの確保に失敗しました: " << e.what() << std::endl; // エラーメッセージを出力
    }
    return 0;
}

char配列を動的にメモリ割り当てすることで、柔軟にサイズを変更したり、実行時に必要なメモリを確保したりすることができます。

しかし、メモリの解放やエラーチェックを怠ると、メモリリークやプログラムの不具合を引き起こす可能性があるため、注意が必要です。

char配列を使った実践例

char配列は、文字列を扱うための基本的なデータ構造であり、さまざまな実践的な用途があります。

ここでは、char配列を使った具体的な例をいくつか紹介します。

1. ユーザー入力を受け取るプログラム

ユーザーからの入力を受け取り、char配列に格納するプログラムの例です。

以下のコードでは、ユーザーが入力した文字列をchar配列に保存し、出力します。

#include <iostream>
int main() {
    const int size = 100; // 配列のサイズ
    char userInput[size]; // char配列の宣言
    std::cout << "文字列を入力してください: ";
    std::cin.getline(userInput, size); // ユーザー入力を受け取る
    std::cout << "入力された文字列: " << userInput << std::endl; // 入力内容を出力
    return 0;
}

文字列を入力してください: こんにちは、世界！
入力された文字列: こんにちは、世界！

2. 文字列の逆順表示

char配列を使って、文字列を逆順に表示するプログラムの例です。

以下のコードでは、入力された文字列を逆にして出力します。

#include <iostream>
#include <cstring> // strlenを使用するために必要
int main() {
    const int size = 100; // 配列のサイズ
    char userInput[size]; // char配列の宣言
    std::cout << "文字列を入力してください: ";
    std::cin.getline(userInput, size); // ユーザー入力を受け取る
    // 文字列の長さを取得
    int length = strlen(userInput);
    std::cout << "逆順の文字列: ";
    for (int i = length - 1; i >= 0; i--) {
        std::cout << userInput[i]; // 逆順に出力
    }
    std::cout << std::endl;
    return 0;
}

文字列を入力してください: こんにちは
逆順の文字列: はちにんこ

3. 文字列の単語数をカウント

char配列を使って、入力された文字列の単語数をカウントするプログラムの例です。

以下のコードでは、空白で区切られた単語の数を数えます。

#include <iostream>
#include <cstring> // strtokを使用するために必要
int main() {
    const int size = 100; // 配列のサイズ
    char userInput[size]; // char配列の宣言
    std::cout << "文字列を入力してください: ";
    std::cin.getline(userInput, size); // ユーザー入力を受け取る
    // 単語をカウント
    int wordCount = 0;
    char* token = strtok(userInput, " "); // 空白で区切る
    while (token != nullptr) {
        wordCount++; // 単語数をカウント
        token = strtok(nullptr, " "); // 次の単語を取得
    }
    std::cout << "単語数: " << wordCount << std::endl; // 結果を出力
    return 0;
}

文字列を入力してください: こんにちは 世界 今日は
単語数: 3

4. 文字列の置換

char配列を使って、特定の文字を別の文字に置換するプログラムの例です。

以下のコードでは、指定された文字を別の文字に置き換えます。

#include <iostream>
#include <cstring> // strlenを使用するために必要
int main() {
    const int size = 100; // 配列のサイズ
    char userInput[size]; // char配列の宣言
    char targetChar, replaceChar; // 置換対象と置換後の文字
    std::cout << "文字列を入力してください: ";
    std::cin.getline(userInput, size); // ユーザー入力を受け取る
    std::cout << "置換したい文字を入力してください: ";
    std::cin >> targetChar; // 置換対象の文字を取得
    std::cout << "置換後の文字を入力してください: ";
    std::cin >> replaceChar; // 置換後の文字を取得
    // 文字の置換
    for (int i = 0; i < strlen(userInput); i++) {
        if (userInput[i] == targetChar) {
            userInput[i] = replaceChar; // 置換
        }
    }
    std::cout << "置換後の文字列: " << userInput << std::endl; // 結果を出力
    return 0;
}

文字列を入力してください: こんにちは
置換したい文字を入力してください: こ
置換後の文字を入力してください: あ
置換後の文字列: あんにちは

char配列を使った実践例として、ユーザー入力の受け取り、文字列の逆順表示、単語数のカウント、文字の置換などを紹介しました。

これらの例を通じて、char配列の使い方やその応用方法を理解することができます。

char配列と安全な文字列操作

C++におけるchar配列は、文字列を扱うための基本的なデータ構造ですが、適切に使用しないとバッファオーバーフローやメモリリークなどの問題を引き起こす可能性があります。

ここでは、char配列を安全に操作するための方法と推奨される手法について解説します。

1. ヌル終端の重要性

char配列を使用する際には、文字列の終端を示すヌル文字'\0'を忘れないことが重要です。

ヌル終端がないと、文字列操作関数が正しく動作せず、未定義の動作を引き起こす可能性があります。

#include <iostream>
int main() {
    char myArray[6] = {'あ', 'い', 'う', 'え', 'お', '#include <iostream>
int main() {
char myArray[6] = {'あ', 'い', 'う', 'え', 'お', '\0'}; // ヌル終端を追加
std::cout << myArray << std::endl; // 正しく出力される
return 0;
}'}; // ヌル終端を追加
    std::cout << myArray << std::endl; // 正しく出力される
    return 0;
}

2. 安全な文字列コピー

文字列をコピーする際には、strcpyの代わりにstrncpyを使用することで、バッファオーバーフローを防ぐことができます。

strncpyは、コピーする文字数を指定できるため、配列のサイズを超えないようにすることができます。

#include <iostream>
#include <cstring> // strncpyを使用するために必要
int main() {
    const int size = 10;
    char source[] = "こんにちは";
    char destination[size]; // コピー先の配列
    // 安全に文字列をコピー
    strncpy(destination, source, size - 1); // ヌル終端のために1を引く
    destination[size - 1] = '#include <iostream>
#include <cstring> // strncpyを使用するために必要
int main() {
const int size = 10;
char source[] = "こんにちは";
char destination[size]; // コピー先の配列
// 安全に文字列をコピー
strncpy(destination, source, size - 1); // ヌル終端のために1を引く
destination[size - 1] = '\0'; // ヌル終端を追加
std::cout << "コピーされた文字列: " << destination << std::endl;
return 0;
}'; // ヌル終端を追加
    std::cout << "コピーされた文字列: " << destination << std::endl;
    return 0;
}

コピーされた文字列: こんにちは

3. 安全な文字列連結

文字列を連結する際も、strcatの代わりにstrncatを使用することで、バッファオーバーフローを防ぐことができます。

strncatは、連結する文字数を指定できるため、配列のサイズを超えないようにすることができます。

#include <iostream>
#include <cstring> // strncatを使用するために必要
int main() {
    const int size = 20;
    char str1[10] = "こんにちは";
    char str2[] = "世界";
    // 安全に文字列を連結
    strncat(str1, str2, size - strlen(str1) - 1); // 残りのサイズを考慮
    std::cout << "連結された文字列: " << str1 << std::endl;
    return 0;
}

連結された文字列: こんにちは世界

4. C++標準ライブラリの利用

C++では、std::stringを使用することで、char配列の代わりに安全に文字列を扱うことができます。

std::stringは、メモリ管理を自動で行い、バッファオーバーフローのリスクを軽減します。

#include <iostream>
#include <string> // std::stringを使用するために必要
int main() {
    std::string str1 = "こんにちは";
    std::string str2 = "世界";
    // 文字列の連結
    std::string result = str1 + str2;
    std::cout << "連結された文字列: " << result << std::endl;
    return 0;
}

連結された文字列: こんにちは世界

5. 例外処理の活用

動的メモリ割り当てを行う際には、例外処理を活用することで、メモリ確保の失敗に対処できます。

new演算子は、メモリが不足している場合にstd::bad_alloc例外をスローします。

#include <iostream>
#include <new> // std::bad_allocを使用するために必要
int main() {
    try {
        char* myArray = new char[1000000000]; // 大きな配列を確保
        // 使用後は必ず解放
        delete[] myArray;
    } catch (const std::bad_alloc& e) {
        std::cerr << "メモリの確保に失敗しました: " << e.what() << std::endl; // エラーメッセージを出力
    }
    return 0;
}

char配列を安全に操作するためには、ヌル終端の管理、安全な文字列コピーや連結、C++標準ライブラリの利用、例外処理の活用が重要です。

これらのポイントを理解し、適切に対処することで、より安全に文字列を扱うことができます。