ポインタ

[C++] ポインタ渡しの基礎と活用法

2025-01-18更新日: 2025-01-18

C++におけるポインタ渡しは、関数に引数としてポインタを渡す手法です。

これにより、関数内で引数として渡された変数の値を直接変更できます。

ポインタ渡しは、メモリ効率の向上や大きなデータ構造のコピーを避けるために有用です。

例えば、配列やオブジェクトを関数に渡す際にポインタを使うことで、オーバーヘッドを減らし、パフォーマンスを向上させます。

また、動的メモリ管理やデータ構造の操作にも頻繁に利用されます。

ポインタを使う際は、メモリリークや不正なメモリアクセスに注意が必要です。

目次から探す

ポインタ渡しの基礎

ポインタとは何か

ポインタは、メモリ上の特定のアドレスを指し示す変数です。

C++では、ポインタを使用することで、変数のアドレスを直接操作することができます。

これにより、関数間でデータを効率的に渡したり、動的メモリを管理したりすることが可能になります。

ポインタの宣言と初期化

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

初期化する際には、変数のアドレスを取得するためにアンパサンド(&)を使用します。

#include <iostream>
int main() {
    int number = 10; // 整数型の変数を宣言
    int* ptr = &number; // ポインタを宣言し、変数のアドレスで初期化
    std::cout << "numberのアドレス: " << ptr << std::endl; // ポインタの値(アドレス)を出力
    return 0;
}

numberのアドレス: 0x7ffee4b3c8ac

このコードでは、numberという整数型の変数を宣言し、そのアドレスをptrというポインタに格納しています。

ptrはnumberのメモリ上の位置を指し示しています。

ポインタとアドレスの関係

ポインタは変数のアドレスを保持するため、変数のメモリ位置を直接操作することができます。

これにより、関数にデータを渡す際に、コピーを作成することなく、元のデータを操作することが可能です。

#include <iostream>
void printAddress(int* ptr) {
    std::cout << "ポインタが指すアドレス: " << ptr << std::endl;
}
int main() {
    int value = 20;
    printAddress(&value); // 変数のアドレスを関数に渡す
    return 0;
}

ポインタが指すアドレス: 0x7ffee4b3c8ac

この例では、valueのアドレスをprintAddress関数に渡し、ポインタを通じてアドレスを出力しています。

ポインタのデリファレンス

デリファレンスとは、ポインタが指し示すアドレスの値を取得する操作です。

アスタリスク(*)を使用してデリファレンスを行います。

#include <iostream>
int main() {
    int number = 30;
    int* ptr = &number; // ポインタを宣言し、変数のアドレスで初期化
    std::cout << "numberの値: " << *ptr << std::endl; // デリファレンスして値を出力
    return 0;
}

numberの値: 30

このコードでは、ptrをデリファレンスすることで、numberの値を取得し、出力しています。

デリファレンスを使用することで、ポインタを通じて変数の値を直接操作することができます。

ポインタ渡しのメリット

メモリ効率の向上

ポインタを使用することで、メモリ効率を向上させることができます。

特に大きなデータ構造を関数に渡す際、ポインタを使うことでデータのコピーを避け、メモリ使用量を削減できます。

これにより、プログラムのパフォーマンスが向上します。

#include <iostream>
#include <vector>
// ベクトルの要素を出力する関数
void printVector(const std::vector<int>* vec) {
    for (int num : *vec) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5}; // ベクトルを宣言
    printVector(&numbers); // ベクトルのアドレスを関数に渡す
    return 0;
}

1 2 3 4 5

この例では、numbersというベクトルのアドレスをprintVector関数に渡しています。

これにより、ベクトル全体をコピーすることなく、関数内でその内容を出力できます。

大きなデータ構造の操作

ポインタを使うことで、大きなデータ構造を効率的に操作できます。

データ構造のアドレスを渡すことで、関数内で直接データを操作することが可能です。

#include <iostream>
#include <vector>
// ベクトルの要素を2倍にする関数
void doubleValues(std::vector<int>* vec) {
    for (int& num : *vec) {
        num *= 2;
    }
}
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5}; // ベクトルを宣言
    doubleValues(&numbers); // ベクトルのアドレスを関数に渡す
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

2 4 6 8 10

このコードでは、doubleValues関数がnumbersベクトルの要素を2倍にしています。

ポインタを使うことで、関数内で直接データを変更することができます。

関数内での値の変更

ポインタを使用することで、関数内で変数の値を変更することができます。

これにより、関数から呼び出し元の変数に影響を与えることが可能です。

#include <iostream>
// 変数の値を変更する関数
void changeValue(int* ptr) {
    *ptr = 100; // デリファレンスして値を変更
}
int main() {
    int value = 50; // 変数を宣言
    changeValue(&value); // 変数のアドレスを関数に渡す
    std::cout << "変更後の値: " << value << std::endl;
    return 0;
}

変更後の値: 100

この例では、changeValue関数がvalueの値を100に変更しています。

ポインタを使うことで、関数内で変数の値を直接変更することができます。

ポインタ渡しの基本的な使い方

関数へのポインタ渡し

関数にポインタを渡すことで、関数内で変数の値を直接操作することができます。

これにより、関数から呼び出し元の変数に影響を与えることが可能です。

#include <iostream>
// 変数の値を2倍にする関数
void doubleValue(int* ptr) {
    *ptr *= 2; // デリファレンスして値を2倍にする
}
int main() {
    int number = 10; // 変数を宣言
    doubleValue(&number); // 変数のアドレスを関数に渡す
    std::cout << "2倍にした値: " << number << std::endl;
    return 0;
}

2倍にした値: 20

このコードでは、doubleValue関数がnumberの値を2倍にしています。

ポインタを使うことで、関数内で変数の値を直接変更することができます。

配列とポインタの関係

配列の名前は、その配列の最初の要素のアドレスを指すポインタとして扱われます。

これにより、配列を関数に渡す際にポインタを使用することができます。

#include <iostream>
// 配列の要素を出力する関数
void printArray(int* arr, int size) {
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " "; // 配列の要素を出力
    }
    std::cout << std::endl;
}
int main() {
    int numbers[] = {1, 2, 3, 4, 5}; // 配列を宣言
    int size = sizeof(numbers) / sizeof(numbers[0]); // 配列のサイズを計算
    printArray(numbers, size); // 配列のアドレスを関数に渡す
    return 0;
}

1 2 3 4 5

この例では、numbers配列のアドレスをprintArray関数に渡し、配列の要素を出力しています。

配列の名前はポインタとして扱われるため、関数に渡す際に特別な操作は必要ありません。

文字列とポインタ

C++では、文字列は文字の配列として扱われます。

文字列リテラルは、文字の配列の先頭を指すポインタとして扱われます。

#include <iostream>
// 文字列を出力する関数
void printString(const char* str) {
    std::cout << str << std::endl; // 文字列を出力
}
int main() {
    const char* message = "こんにちは、世界！"; // 文字列リテラルを宣言
    printString(message); // 文字列のアドレスを関数に渡す
    return 0;
}

こんにちは、世界！

このコードでは、messageという文字列リテラルのアドレスをprintString関数に渡し、文字列を出力しています。

文字列リテラルは文字の配列の先頭を指すポインタとして扱われるため、関数に渡す際にポインタを使用します。

ポインタ渡しの応用

動的メモリ管理

動的メモリ管理は、プログラムの実行時に必要なメモリを動的に確保し、使用後に解放する技術です。

C++では、new演算子を使ってメモリを確保し、delete演算子を使って解放します。

ポインタを使用することで、動的に確保したメモリを操作することができます。

#include <iostream>
int main() {
    int* ptr = new int; // 整数型のメモリを動的に確保
    *ptr = 42; // デリファレンスして値を設定
    std::cout << "動的に確保した値: " << *ptr << std::endl;
    delete ptr; // メモリを解放
    return 0;
}

動的に確保した値: 42

このコードでは、newを使って整数型のメモリを動的に確保し、ptrポインタを通じてそのメモリを操作しています。

使用後はdeleteを使ってメモリを解放します。

データ構造の操作

ポインタを使うことで、リンクリストやツリーなどのデータ構造を効率的に操作することができます。

これにより、データの挿入、削除、探索などの操作を柔軟に行うことが可能です。

#include <iostream>
// ノードを表す構造体
struct Node {
    int data; // データ
    Node* next; // 次のノードへのポインタ
};
// リストの要素を出力する関数
void printList(Node* head) {
    Node* current = head;
    while (current != nullptr) {
        std::cout << current->data << " "; // ノードのデータを出力
        current = current->next; // 次のノードに移動
    }
    std::cout << std::endl;
}
int main() {
    Node* head = new Node{1, nullptr}; // 最初のノードを作成
    head->next = new Node{2, nullptr}; // 次のノードを作成
    head->next->next = new Node{3, nullptr}; // 次のノードを作成
    printList(head); // リストを出力
    // メモリを解放
    delete head->next->next;
    delete head->next;
    delete head;
    return 0;
}

1 2 3

この例では、リンクリストを作成し、ポインタを使って各ノードを操作しています。

リストの要素を出力した後、動的に確保したメモリを解放しています。

コールバック関数の実装

コールバック関数は、特定のイベントが発生したときに呼び出される関数です。

ポインタを使って関数を渡すことで、柔軟なコールバック機能を実装することができます。

#include <iostream>
// コールバック関数の型を定義
typedef void (*Callback)(int);
// コールバック関数を呼び出す関数
void executeCallback(Callback cb, int value) {
    cb(value); // コールバック関数を呼び出す
}
// コールバック関数の実装
void printValue(int value) {
    std::cout << "コールバックで受け取った値: " << value << std::endl;
}
int main() {
    executeCallback(printValue, 100); // コールバック関数を渡して実行
    return 0;
}

コールバックで受け取った値: 100

このコードでは、Callback型の関数ポインタを使ってコールバック関数を実装しています。

executeCallback関数にprintValue関数を渡し、指定された値を出力しています。

ポインタを使うことで、関数を柔軟に渡すことが可能です。

ポインタ渡しの注意点

メモリリークの防止

メモリリークは、動的に確保したメモリを解放せずにプログラムが終了することによって発生します。

これを防ぐためには、newで確保したメモリは必ずdeleteで解放する必要があります。

メモリリークが発生すると、プログラムのメモリ使用量が増加し、最終的にはシステムのパフォーマンスに悪影響を及ぼす可能性があります。

#include <iostream>
int main() {
    int* ptr = new int(42); // メモリを動的に確保
    // メモリを使用する処理
    std::cout << "値: " << *ptr << std::endl;
    delete ptr; // メモリを解放
    ptr = nullptr; // ポインタをNULLに設定
    return 0;
}

このコードでは、newで確保したメモリをdeleteで解放し、さらにポインタをnullptrに設定することで、メモリリークを防いでいます。

不正なメモリアクセスの回避

不正なメモリアクセスは、解放済みのメモリや無効なメモリアドレスを参照することによって発生します。

これを防ぐためには、ポインタを使用する際に注意深く管理し、解放済みのメモリを再度使用しないようにする必要があります。

#include <iostream>
int main() {
    int* ptr = new int(42); // メモリを動的に確保
    delete ptr; // メモリを解放
    ptr = nullptr; // ポインタをNULLに設定
    // 不正なメモリアクセスを防ぐためのチェック
    if (ptr != nullptr) {
        std::cout << "値: " << *ptr << std::endl;
    } else {
        std::cout << "ポインタは無効です。" << std::endl;
    }
    return 0;
}

このコードでは、メモリを解放した後にポインタをnullptrに設定し、不正なメモリアクセスを防いでいます。

ポインタのNULLチェック

ポインタを使用する際には、必ずnullptrチェックを行うことが重要です。

nullptrチェックを行うことで、無効なポインタをデリファレンスすることによるクラッシュを防ぐことができます。

#include <iostream>
// ポインタの値を出力する関数
void printValue(int* ptr) {
    if (ptr != nullptr) { // NULLチェック
        std::cout << "値: " << *ptr << std::endl;
    } else {
        std::cout << "ポインタはNULLです。" << std::endl;
    }
}
int main() {
    int* validPtr = new int(42); // 有効なポインタ
    int* nullPtr = nullptr; // NULLポインタ
    printValue(validPtr); // 有効なポインタを渡す
    printValue(nullPtr); // NULLポインタを渡す
    delete validPtr; // メモリを解放
    return 0;
}

値: 42
ポインタはNULLです。

このコードでは、printValue関数内でnullptrチェックを行い、無効なポインタをデリファレンスしないようにしています。

これにより、プログラムの安定性を向上させることができます。

ポインタ渡しの実践例

配列のソート

ポインタを使用して配列をソートすることで、効率的にデータを並べ替えることができます。

以下は、バブルソートアルゴリズムを使用して整数配列をソートする例です。

#include <iostream>
// 配列をバブルソートする関数
void bubbleSort(int* arr, int size) {
    for (int i = 0; i < size - 1; ++i) {
        for (int j = 0; j < size - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                // 要素を交換
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
int main() {
    int numbers[] = {5, 3, 8, 6, 2}; // 配列を宣言
    int size = sizeof(numbers) / sizeof(numbers[0]); // 配列のサイズを計算
    bubbleSort(numbers, size); // 配列をソート
    for (int num : numbers) {
        std::cout << num << " "; // ソートされた配列を出力
    }
    std::cout << std::endl;
    return 0;
}

2 3 5 6 8

このコードでは、bubbleSort関数がポインタを使って配列をソートしています。

配列の要素を直接操作することで、効率的に並べ替えを行っています。

リンクリストの操作

リンクリストは、ポインタを使って各ノードを接続するデータ構造です。

以下は、リンクリストに要素を追加し、出力する例です。

#include <iostream>
// ノードを表す構造体
struct Node {
    int data; // データ
    Node* next; // 次のノードへのポインタ
};
// リストの末尾に要素を追加する関数
void append(Node** head, int newData) {
    Node* newNode = new Node{newData, nullptr}; // 新しいノードを作成
    if (*head == nullptr) {
        *head = newNode; // リストが空の場合、新しいノードを先頭に設定
        return;
    }
    Node* last = *head;
    while (last->next != nullptr) {
        last = last->next; // リストの末尾を探す
    }
    last->next = newNode; // 新しいノードを末尾に追加
}
// リストの要素を出力する関数
void printList(Node* node) {
    while (node != nullptr) {
        std::cout << node->data << " "; // ノードのデータを出力
        node = node->next; // 次のノードに移動
    }
    std::cout << std::endl;
}
int main() {
    Node* head = nullptr; // リストの先頭を初期化
    append(&head, 1); // 要素を追加
    append(&head, 2);
    append(&head, 3);
    printList(head); // リストを出力
    // メモリを解放
    while (head != nullptr) {
        Node* temp = head;
        head = head->next;
        delete temp;
    }
    return 0;
}

1 2 3

この例では、append関数を使ってリンクリストに要素を追加し、printList関数でリストの要素を出力しています。

ポインタを使ってノードを接続し、リストを操作しています。

ツリー構造の探索

ツリー構造は、ノードが階層的に配置されたデータ構造です。

以下は、二分探索木を作成し、深さ優先探索(DFS)を行う例です。

#include <iostream>
// ノードを表す構造体
struct TreeNode {
    int data; // データ
    TreeNode* left; // 左の子ノードへのポインタ
    TreeNode* right; // 右の子ノードへのポインタ
};
// 新しいノードを作成する関数
TreeNode* newNode(int data) {
    TreeNode* node = new TreeNode{data, nullptr, nullptr};
    return node;
}
// 深さ優先探索(前順)を行う関数
void preOrder(TreeNode* node) {
    if (node == nullptr) {
        return;
    }
    std::cout << node->data << " "; // ノードのデータを出力
    preOrder(node->left); // 左の子ノードを探索
    preOrder(node->right); // 右の子ノードを探索
}
int main() {
    TreeNode* root = newNode(1); // ルートノードを作成
    root->left = newNode(2); // 左の子ノードを作成
    root->right = newNode(3); // 右の子ノードを作成
    root->left->left = newNode(4); // 左の子ノードの左の子ノードを作成
    root->left->right = newNode(5); // 左の子ノードの右の子ノードを作成
    preOrder(root); // ツリーを探索
    // メモリを解放
    delete root->left->right;
    delete root->left->left;
    delete root->right;
    delete root->left;
    delete root;
    return 0;
}