メモリ操作

[C++] newで配列を初期化して0クリアする

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

C++でnewを使用して配列を動的に確保し、0で初期化するには、値型が基本型(例：intやdouble)の場合、newの後に()を付けることで可能です。

例えば、new int[10]()と記述すると、確保された配列の全要素が0で初期化されます。

ただし、クラス型の場合はデフォルトコンストラクタが呼び出されるため、0クリアされるとは限りません。

目次から探す

new演算子を使った配列の動的確保とは
配列を0クリアする方法
new演算子での0クリアの具体例
- new演算子を使った配列の0クリア
- 注意点
new演算子を使わない代替手段
new演算子を使う際の注意点
まとめ

new演算子を使った配列の動的確保とは

C++において、配列を動的に確保するためにはnew演算子を使用します。

これにより、プログラムの実行時に必要なメモリを確保し、配列のサイズを柔軟に変更することが可能になります。

動的配列は、スタックメモリではなくヒープメモリに格納されるため、大きなデータを扱う際に特に有用です。

以下に、new演算子を使って配列を動的に確保する基本的なサンプルコードを示します。

#include <iostream>
int main() {
    int size = 5; // 配列のサイズを指定
    // new演算子を使って配列を動的に確保
    int* array = new int[size]; 
    // 確保した配列の要素を0で初期化
    for (int i = 0; i < size; i++) {
        array[i] = 0; // 各要素を0で初期化
    }
    // 配列の内容を表示
    for (int i = 0; i < size; i++) {
        std::cout << "array[" << i << "] = " << array[i] << std::endl;
    }
    // 確保したメモリを解放
    delete[] array; 
    return 0;
}

array[0] = 0
array[1] = 0
array[2] = 0
array[3] = 0
array[4] = 0

このコードでは、new演算子を使用して整数型の配列を動的に確保し、各要素を0で初期化しています。

最後に、delete[]を使って確保したメモリを解放することが重要です。

これにより、メモリリークを防ぐことができます。

配列を0クリアする方法

C++で配列を0クリアする方法はいくつかありますが、主に以下の3つの方法が一般的です。

それぞれの方法について詳しく解説します。

方法	説明	サンプルコード
`new`演算子とループ	`new`演算子で配列を確保し、ループで初期化	`new int[size];` + ループ
`std::fill`	標準ライブラリの`std::fill`を使用	`std::fill(array, array + size, 0);`
`std::vector`	`std::vector`を使用し、初期化時に0を指定	`std::vector<int> vec(size, 0);`

new演算子とループを使った0クリア

new演算子で配列を動的に確保し、ループを使って各要素を0で初期化する方法です。

以下にサンプルコードを示します。

#include <iostream>
int main() {
    int size = 5; // 配列のサイズを指定
    int* array = new int[size]; // new演算子で配列を確保
    // ループで各要素を0で初期化
    for (int i = 0; i < size; i++) {
        array[i] = 0; // 各要素を0で初期化
    }
    // 配列の内容を表示
    for (int i = 0; i < size; i++) {
        std::cout << "array[" << i << "] = " << array[i] << std::endl;
    }
    delete[] array; // メモリを解放
    return 0;
}

array[0] = 0
array[1] = 0
array[2] = 0
array[3] = 0
array[4] = 0

std::fillを使った0クリア

C++の標準ライブラリに含まれるstd::fillを使用することで、配列の要素を簡単に0で初期化できます。

以下にサンプルコードを示します。

#include <iostream>
#include <algorithm> // std::fillを使用するために必要
int main() {
    int size = 5; // 配列のサイズを指定
    int* array = new int[size]; // new演算子で配列を確保
    // std::fillを使って各要素を0で初期化
    std::fill(array, array + size, 0); // 配列の範囲を指定して0で初期化
    // 配列の内容を表示
    for (int i = 0; i < size; i++) {
        std::cout << "array[" << i << "] = " << array[i] << std::endl;
    }
    delete[] array; // メモリを解放
    return 0;
}

array[0] = 0
array[1] = 0
array[2] = 0
array[3] = 0
array[4] = 0

std::vectorを使った0クリア

std::vectorを使用することで、配列のサイズを動的に変更でき、初期化時に0を指定することも可能です。

以下にサンプルコードを示します。

#include <iostream>
#include <vector> // std::vectorを使用するために必要
int main() {
    int size = 5; // 配列のサイズを指定
    std::vector<int> vec(size, 0); // std::vectorを使って0で初期化
    // 配列の内容を表示
    for (int i = 0; i < size; i++) {
        std::cout << "vec[" << i << "] = " << vec[i] << std::endl;
    }
    return 0;
}

vec[0] = 0
vec[1] = 0
vec[2] = 0
vec[3] = 0
vec[4] = 0

これらの方法を使うことで、C++において配列を簡単に0クリアすることができます。

用途に応じて適切な方法を選択してください。

new演算子での0クリアの具体例

new演算子を使用して配列を動的に確保し、同時に0で初期化する具体的な方法を紹介します。

C++では、new演算子を使って配列を確保する際に、初期化を行うための便利なテクニックがあります。

以下にその方法を示します。

new演算子を使った配列の0クリア

new演算子を使って配列を確保し、()を使って初期化することで、全ての要素を0で初期化することができます。

以下にサンプルコードを示します。

#include <iostream>
int main() {
    int size = 5; // 配列のサイズを指定
    // new演算子を使って配列を動的に確保し、0で初期化
    int* array = new int[size](); // ()を使うことで全要素を0で初期化
    // 配列の内容を表示
    for (int i = 0; i < size; i++) {
        std::cout << "array[" << i << "] = " << array[i] << std::endl;
    }
    delete[] array; // メモリを解放
    return 0;
}

array[0] = 0
array[1] = 0
array[2] = 0
array[3] = 0
array[4] = 0

このコードでは、new int[size]()という構文を使用しています。

()を追加することで、確保した配列の全ての要素が自動的に0で初期化されます。

この方法は、ループを使って手動で初期化する手間を省くことができ、コードがシンプルになります。

注意点

new演算子で確保したメモリは、使用後に必ずdelete[]を使って解放する必要があります。

これを怠ると、メモリリークが発生します。

new演算子を使った配列の初期化は、基本的に動的メモリ管理が必要な場合に使用されます。

スタックメモリを使用する場合は、通常の配列宣言を使用することが推奨されます。

このように、new演算子を使った配列の0クリアは非常に便利で、特に動的にサイズを変更する必要がある場合に役立ちます。

new演算子を使わない代替手段

C++では、new演算子を使わずに配列を確保し、0で初期化する方法もいくつか存在します。

これらの方法は、スタックメモリを使用するため、メモリ管理が簡単で、特に小規模な配列に適しています。

以下に代表的な代替手段を紹介します。

方法	説明	サンプルコード
スタティック配列	スタックメモリに固定サイズの配列を宣言	`int array[size] = {0};`
std::array	C++11以降の標準ライブラリを使用	`std::array<int, size> array = {0};`
std::vector	動的配列を使用し、初期化時に0を指定	`std::vector<int> vec(size, 0);`

スタティック配列を使った0クリア

スタティック配列を使用することで、new演算子を使わずに配列を確保し、0で初期化することができます。

以下にサンプルコードを示します。

#include <iostream>
int main() {
    const int size = 5; // 配列のサイズを指定
    int array[size] = {0}; // スタティック配列を宣言し、0で初期化
    // 配列の内容を表示
    for (int i = 0; i < size; i++) {
        std::cout << "array[" << i << "] = " << array[i] << std::endl;
    }
    return 0;
}

array[0] = 0
array[1] = 0
array[2] = 0
array[3] = 0
array[4] = 0

std::arrayを使った0クリア

C++11以降では、std::arrayを使用することで、固定サイズの配列をより安全に扱うことができます。

以下にサンプルコードを示します。

#include <iostream>
#include <array> // std::arrayを使用するために必要
int main() {
    const int size = 5; // 配列のサイズを指定
    std::array<int, size> array = {0}; // std::arrayを使って0で初期化
    // 配列の内容を表示
    for (int i = 0; i < size; i++) {
        std::cout << "array[" << i << "] = " << array[i] << std::endl;
    }
    return 0;
}

array[0] = 0
array[1] = 0
array[2] = 0
array[3] = 0
array[4] = 0

std::vectorを使った0クリア

std::vectorを使用することで、動的にサイズを変更できる配列を簡単に扱うことができます。

以下にサンプルコードを示します。

#include <iostream>
#include <vector> // std::vectorを使用するために必要
int main() {
    int size = 5; // 配列のサイズを指定
    std::vector<int> vec(size, 0); // std::vectorを使って0で初期化
    // 配列の内容を表示
    for (int i = 0; i < size; i++) {
        std::cout << "vec[" << i << "] = " << vec[i] << std::endl;
    }
    return 0;
}

vec[0] = 0
vec[1] = 0
vec[2] = 0
vec[3] = 0
vec[4] = 0

これらの方法を使用することで、new演算子を使わずに配列を確保し、0で初期化することができます。

スタティック配列やstd::arrayは、サイズが固定されている場合に便利で、std::vectorは動的なサイズ変更が必要な場合に適しています。

用途に応じて適切な方法を選択してください。

new演算子を使う際の注意点

C++においてnew演算子を使用する際には、いくつかの注意点があります。

これらの注意点を理解し、適切に対処することで、メモリ管理やプログラムの安定性を向上させることができます。

以下に主な注意点を示します。

注意点	説明
メモリリーク	`new`で確保したメモリは必ず`delete`で解放する必要がある。
例外処理	メモリ確保に失敗した場合、例外が発生する可能性がある。
配列の解放	配列を確保した場合は`delete[]`を使用して解放する。
初期化の重要性	確保したメモリは初期化しないと不定値が入る可能性がある。
ヒープメモリの管理	ヒープメモリはスタックメモリよりも管理が難しいため注意が必要。

メモリリーク

new演算子で確保したメモリは、使用後に必ずdeleteまたはdelete[]を使って解放する必要があります。

これを怠ると、メモリリークが発生し、プログラムのメモリ使用量が増加し続けることになります。

以下にサンプルコードを示します。

#include <iostream>
int main() {
    int* array = new int[5]; // メモリを確保
    // 何らかの処理
    // メモリを解放しないとメモリリークが発生する
    // delete[] array; // これを忘れないようにする
    return 0;
}

例外処理

new演算子でメモリを確保する際、メモリが不足している場合には例外が発生します。

C++では、std::bad_alloc例外がスローされるため、適切に例外処理を行うことが重要です。

以下に例外処理のサンプルコードを示します。

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

配列の解放

配列をnew演算子で確保した場合、解放する際にはdelete[]を使用する必要があります。

deleteを使用すると未定義の動作が発生する可能性があります。

以下に正しい解放方法を示します。

#include <iostream>
int main() {
    int* array = new int[5]; // 配列を確保
    // 配列の処理
    delete[] array; // 配列を正しく解放
    return 0;
}

初期化の重要性

new演算子で確保したメモリは、自動的に初期化されません。

初期化を行わないと、不定値が入る可能性があります。

以下に初期化の重要性を示すサンプルコードを示します。

#include <iostream>
int main() {
    int* array = new int[5]; // メモリを確保
    // 初期化しないと不定値が入る
    for (int i = 0; i < 5; i++) {
        std::cout << "array[" << i << "] = " << array[i] << std::endl; // 不定値が表示される可能性がある
    }
    delete[] array; // メモリを解放
    return 0;
}