[C++] ポインタの使い方についてわかりやすく詳しく解説

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

C++のポインタは、メモリ上のアドレスを格納する変数です。

ポインタを宣言するには、型の後にアスタリスク(*)を付けます。

例えば、int* ptr;は整数型のポインタを宣言します。

ポインタに値を代入するには、変数のアドレスを取得する&演算子を使用します。

ポインタは動的メモリ管理newやdeleteや配列操作、関数の引数としての利用などに役立ちますが、不正なメモリアクセスに注意が必要です。

ポインタを活用して、より効率的なプログラムを作成することが求められる

目次から探す

ポインタとは何か
ポインタの基本操作
配列とポインタの関係
関数とポインタ
動的メモリ管理とポインタ
ポインタの応用例
ポインタの注意点とベストプラクティス
まとめ

ポインタとは何か

ポインタは、C++において非常に重要な概念であり、メモリのアドレスを扱うための変数です。

ポインタを使用することで、メモリの効率的な管理やデータの直接操作が可能になります。

以下にポインタの基本的な特徴を示します。

特徴	説明
メモリアドレス	ポインタは、他の変数が格納されているメモリのアドレスを保持します。
データ型	ポインタは、指し示すデータの型に基づいて宣言されます。
NULLポインタ	ポインタが何も指していない状態を示すために、NULLを使用します。

ポインタを使うことで、配列や動的メモリの操作が容易になり、プログラムの柔軟性が向上します。

次に、ポインタの基本的な使い方を見ていきましょう。

ポインタの基本操作

ポインタの基本操作には、ポインタの宣言、初期化、値の参照、値の変更などがあります。

これらの操作を理解することで、ポインタを効果的に活用できるようになります。

以下に、ポインタの基本操作を示すサンプルコードを紹介します。

#include <iostream>
int main() {
    int value = 10;          // 整数型の変数を宣言
    int* pointer = &value;  // ポインタを宣言し、valueのアドレスを代入
    std::cout << "valueの値: " << value << std::endl;          // valueの値を表示
    std::cout << "pointerが指すアドレス: " << pointer << std::endl; // pointerの値(アドレス)を表示
    std::cout << "pointerが指す値: " << *pointer << std::endl; // pointerが指す値を表示
    *pointer = 20;          // pointerを通じてvalueの値を変更
    std::cout << "valueの新しい値: " << value << std::endl;   // 新しいvalueの値を表示
    return 0;
}

valueの値: 10
pointerが指すアドレス: 0x7ffee3b1c8bc
pointerが指す値: 10
valueの新しい値: 20

int* pointer = &value; では、valueのアドレスをポインタpointerに代入しています。
*pointerを使うことで、ポインタが指し示すメモリの値を参照したり、変更したりできます。
ポインタを通じて変数の値を変更することで、メモリの直接操作が可能になります。

これにより、効率的なプログラムが実現できます。

配列とポインタの関係

C++において、配列とポインタは密接に関連しています。

配列の名前は、その配列の最初の要素のアドレスを指すポインタとして扱われるため、配列とポインタを使った操作は非常に似ています。

以下に、配列とポインタの関係を示すサンプルコードを紹介します。

#include <iostream>
int main() {
    int array[] = {1, 2, 3, 4, 5}; // 整数型の配列を宣言
    int* pointer = array;         // 配列の最初の要素のアドレスをポインタに代入
    std::cout << "配列の要素をポインタを使って表示:" << std::endl;
    for (int i = 0; i < 5; i++) {
        std::cout << "array[" << i << "] = " << *(pointer + i) << std::endl; // ポインタを使って要素を表示
    }
    return 0;
}

配列の要素をポインタを使って表示:
array[0] = 1
array[1] = 2
array[2] = 3
array[3] = 4
array[4] = 5

int* pointer = array; では、配列arrayの最初の要素のアドレスをポインタpointerに代入しています。
*(pointer + i)を使用することで、ポインタを使って配列の各要素にアクセスしています。

これは、ポインタ算術を利用した方法です。

配列とポインタの関係を理解することで、メモリの効率的な操作や、関数への配列の渡し方などが容易になります。

関数とポインタ

C++では、ポインタを使って関数に引数を渡すことができます。

これにより、関数内で引数の値を変更したり、動的にメモリを管理したりすることが可能になります。

以下に、関数とポインタの関係を示すサンプルコードを紹介します。

#include <iostream>
// 整数型のポインタを引数に取る関数
void modifyValue(int* ptr) {
    *ptr = 100; // ポインタを通じて値を変更
}
int main() {
    int value = 50; // 整数型の変数を宣言
    std::cout << "関数呼び出し前のvalueの値: " << value << std::endl; // 初期値を表示
    modifyValue(&value); // valueのアドレスを渡して関数を呼び出し
    std::cout << "関数呼び出し後のvalueの値: " << value << std::endl; // 変更後の値を表示
    return 0;
}

関数呼び出し前のvalueの値: 50
関数呼び出し後のvalueの値: 100

void modifyValue(int* ptr) では、整数型のポインタを引数として受け取る関数を定義しています。
modifyValue(&value); で、変数valueのアドレスを関数に渡しています。
関数内で*ptrを使って、ポインタが指し示す値を変更することができます。

これにより、関数外の変数の値を直接変更することが可能になります。

ポインタを使った関数の引数渡しは、特に大きなデータ構造を扱う際に効率的です。

動的メモリ管理とポインタ

C++では、ポインタを使用して動的にメモリを管理することができます。

これにより、プログラムの実行時に必要なメモリを確保し、使用後に解放することが可能になります。

動的メモリ管理は、特にサイズが不明なデータ構造(例えば、リストや配列)を扱う際に非常に便利です。

以下に、動的メモリ管理の基本的な使い方を示すサンプルコードを紹介します。

#include <iostream>
int main() {
    int* array = new int[5]; // 動的に整数型の配列を確保
    // 配列に値を代入
    for (int i = 0; i < 5; i++) {
        array[i] = i + 1; // 1から5までの値を代入
    }
    std::cout << "動的配列の要素:" << std::endl;
    for (int i = 0; i < 5; i++) {
        std::cout << "array[" << i << "] = " << array[i] << std::endl; // 配列の要素を表示
    }
    delete[] array; // 確保したメモリを解放
    return 0;
}

動的配列の要素:
array[0] = 1
array[1] = 2
array[2] = 3
array[3] = 4
array[4] = 5

int* array = new int[5]; では、動的に整数型の配列を5つ分確保しています。

この時、arrayはその配列の先頭要素のアドレスを指します。

delete[] array; で、確保したメモリを解放しています。

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

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

動的メモリ管理を使用することで、プログラムの柔軟性が向上し、必要なメモリを効率的に使用することができます。

ポインタの応用例

ポインタは、C++プログラミングにおいて多くの場面で応用されます。

以下に、ポインタの具体的な応用例をいくつか紹介します。

1. 文字列操作

ポインタを使用して文字列を操作することができます。

以下のサンプルコードでは、ポインタを使って文字列の各文字にアクセスしています。

#include <iostream>
int main() {
    const char* str = "Hello, World!"; // 文字列をポインタで宣言
    std::cout << "文字列の各文字:" << std::endl;
    for (const char* ptr = str; *ptr != '#include <iostream>
int main() {
const char* str = "Hello, World!"; // 文字列をポインタで宣言
std::cout << "文字列の各文字:" << std::endl;
for (const char* ptr = str; *ptr != '\0'; ptr++) { // ポインタを使って文字列を走査
std::cout << *ptr << std::endl; // 各文字を表示
}
return 0;
}'; ptr++) { // ポインタを使って文字列を走査
        std::cout << *ptr << std::endl; // 各文字を表示
    }
    return 0;
}

文字列の各文字:
H
e
l
l
o
,
 
W
o
r
l
d
!

2. リンクリストの実装

ポインタは、データ構造の一つであるリンクリストの実装においても重要です。

以下のサンプルコードでは、単純なリンクリストのノードを定義し、ポインタを使ってノードをつなげています。

#include <iostream>
struct Node {
    int data;        // ノードのデータ
    Node* next;     // 次のノードへのポインタ
};
int main() {
    // ノードを動的に作成
    Node* head = new Node{1, nullptr}; // 最初のノード
    head->next = new Node{2, nullptr}; // 2番目のノード
    head->next->next = new Node{3, nullptr}; // 3番目のノード
    // リンクリストの要素を表示
    Node* current = head;
    while (current != nullptr) {
        std::cout << current->data << " "; // ノードのデータを表示
        current = current->next; // 次のノードへ移動
    }
    std::cout << std::endl;
    // メモリの解放
    current = head;
    while (current != nullptr) {
        Node* temp = current;
        current = current->next;
        delete temp; // 各ノードを解放
    }
    return 0;
}

1 2 3

3. 配列の動的割り当て

ポインタを使用して、サイズが不明な配列を動的に割り当てることができます。

以下のサンプルコードでは、ユーザーからの入力に基づいて配列のサイズを決定し、動的にメモリを確保しています。

#include <iostream>
int main() {
    int size;
    std::cout << "配列のサイズを入力してください: ";
    std::cin >> size; // ユーザーから配列のサイズを取得
    int* array = new int[size]; // 動的に配列を確保
    // 配列に値を代入
    for (int i = 0; i < size; i++) {
        array[i] = i + 1; // 1からsizeまでの値を代入
    }
    std::cout << "配列の要素:" << std::endl;
    for (int i = 0; i < size; i++) {
        std::cout << array[i] << " "; // 配列の要素を表示
    }
    std::cout << std::endl;
    delete[] array; // メモリの解放
    return 0;
}

配列のサイズを入力してください: 5
配列の要素:
1 2 3 4 5

ポインタは、文字列やデータ構造の操作、動的メモリ管理など、さまざまな場面で活用されます。
文字列操作では、ポインタを使って各文字にアクセスし、表示することができます。
リンクリストの実装では、ポインタを使ってノードをつなげ、動的にメモリを管理します。
配列の動的割り当てでは、ユーザーの入力に基づいてメモリを確保し、柔軟なプログラムを実現します。

ポインタを使うことで、プログラムの効率性と柔軟性が向上します。

ポインタの注意点とベストプラクティス

ポインタは非常に強力な機能ですが、適切に使用しないとバグやメモリリークの原因となることがあります。

以下に、ポインタを使用する際の注意点とベストプラクティスを紹介します。

1. メモリの解放を忘れない

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

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

以下のように、deleteやdelete[]を使用してメモリを解放しましょう。

delete pointer; // 単一のオブジェクトを解放
delete[] array; // 配列を解放

2. NULLポインタのチェック

ポインタを使用する前に、NULLポインタでないことを確認することが重要です。

NULLポインタを参照すると、プログラムがクラッシュする原因となります。

以下のように、ポインタがNULLでないかを確認しましょう。

if (pointer != nullptr) {
    // ポインタがNULLでない場合の処理
}

3. ポインタの初期化

ポインタを宣言したら、必ず初期化することが重要です。

未初期化のポインタを使用すると、未定義の動作を引き起こす可能性があります。

初期化には、NULLや他の有効なアドレスを使用します。

int* pointer = nullptr; // NULLで初期化

4. ポインタ算術の注意

ポインタ算術を使用する際は、配列の範囲を超えないように注意が必要です。

範囲外のメモリにアクセスすると、未定義の動作を引き起こす可能性があります。

配列のサイズを把握し、適切にループを制御しましょう。

for (int i = 0; i < size; i++) {
    // 配列の範囲内でアクセス
}

5. スマートポインタの利用

C++11以降では、std::unique_ptrやstd::shared_ptrなどのスマートポインタが提供されています。

これらを使用することで、メモリ管理が自動化され、メモリリークのリスクを減少させることができます。

以下は、std::unique_ptrの使用例です。

#include <iostream>
#include <memory> // スマートポインタを使用するためのヘッダ
int main() {
    std::unique_ptr<int> ptr(new int(10)); // スマートポインタを使用してメモリを確保
    std::cout << "値: " << *ptr << std::endl; // 値を表示
    // メモリは自動的に解放される
    return 0;
}