C では、次のように変数を定義できます。
// 関数内で宣言された変数は、通常スタックに格納されます。
int a = 42;
// `static` を付けて宣言した変数、またはファイルスコープで宣言した変数は、通常 `.data`
// または `.rodata` に格納されます。
static int b = 2026;
これらの変数の記憶領域は、言語自体によって管理されます。しかし、場合によってはメモリを手動で管理する必要があります。そのような場合、malloc()、calloc()、realloc() などの関数を使って、動的に確保されたメモリを取得できます。
// 動的に確保されたメモリは、通常ヒープから取得されます。
int *c = malloc(sizeof *c);
*c = 42;
メモリが不要になったら、free() を使って解放します。
free(c);
これにより、必要に応じて柔軟にメモリを確保・解放できるようになり、さまざまな複雑なデータ構造を実装できます。その結果、静的に確保されたメモリだけでは実現が難しいことや、実現できないことも可能になります。
しかし、この方法には問題もあります。
次のような状況を考えてみましょう。
int *a = malloc(sizeof *a);
int *b = a;
このメモリを解放する責任は誰にあるのでしょうか。
当然、どちらも解放しないのは解決策になりません。メモリリークが発生するからです。また、両方のポインタを使って同じメモリを解放するのも解決策にはなりません。ISO/IEC 9899 における未定義動作を引き起こし、一般に二重解放と呼ばれます。
このメモリは、どちらか一方のポインタを使って解放すべきです。しかし、どちらを使えばよいのでしょうか。ここで、メモリ管理、ひいてはリソース管理全般における重要な概念である所有権が登場します。
所有権、借用、移転
所有権とは、プログラムのどの部分がリソースを管理し、不要になったときに解放する責任を負うのかを定める取り決めです。あるポインタ変数が free() を使ってメモリを解放する責任を負うものとして定められている場合、そのポインタ変数はそのメモリを所有していると言います。
所有権がリソースの適切な管理にどのように役立つのかを説明するために、連結リストを実装してみましょう。まず、次の構造体を定義します。
typedef struct N
{
int data;
struct N *previous;
struct N *next;
} Node;
previous == NULL は番兵ノード(その data メンバーには意味がありません)を示し、next == NULL は連結リストの最後の要素を示すものとします。
ファイルスコープで定義された Node 型の変数を番兵ノードとして使用するとします。
Node l = {0, NULL, NULL};
この連結リストを操作するために、いくつかの関数が必要です。
次の関数を定義しましょう。
Node *getNode(Node *guard, int index)
{
if (index < 0)
return NULL; // インデックスが負の値です。
else if (index > 0 && guard->next == NULL)
return NULL; // インデックスが範囲外です。
else if (index == 0)
return guard->next;
else return getNode(guard->next, index - 1);
}
void setData(Node *x, int data)
{
x->data = data;
}
int getData(Node *x)
{
return x->data;
}
ここで、main() 関数内の次の処理を考えてみましょう。
/* ... */
Node *a = malloc(sizeof *a);
a->previous = NULL;
a->next = NULL;
setData(a, 42);
printf("%d\n", getData(a));
/* ... */
setData() と getData() の呼び出しが終わった後、a が指すメモリを解放する責任は誰にあるのでしょうか。当然、引き続き a にあります。setData() と getData() は、引数を通じて渡されたメモリを読み取ったり変更したりするだけで、メモリの確保も解放もしません。また、そのポインタを、同じメモリを管理する別の関数やグローバル変数に渡すこともありません。したがって、これらの関数はメモリの所有権を取得するのではなく、メモリを借用すると言います。
借用とは、関数がリソースのライフタイムを管理する責任を引き受けずに、そのリソースへのアクセス権を得ることです。インターフェースの取り決めに応じて、関数はリソースを読み取ったり変更したりできますが、独自の判断で解放してはいけません。
getNode() についても同じことが言えます。この関数は連結リストをたどり、インデックスに基づいてノードを取得します。メモリの確保も解放も行わず、所有権の移転も行いません。
しかし、必ずしもそうとは限りません。次の関数を考えてみましょう。
Node *createNode(int data)
{
Node *ans = malloc(sizeof *ans);
if (! ans)
exit(EXIT_FAILURE);
ans->data = data;
ans->previous = NULL;
ans->next = NULL;
return ans;
}
int insertNode(Node *guard, Node *n, int index)
{
if (index < 0)
return 1; // インデックスが負の値です。
else if (index > 0 && guard->next == NULL)
return 2; // インデックスが範囲外です。
else if (index == 0)
{
if (guard->next)
{
n->next = guard->next;
guard->next->previous = n;
}
n->previous = guard;
guard->next = n;
return 0;
}
else return insertNode(guard->next, n, index - 1);
}
これで、確保したノードを連結リストに挿入するために、a を insertNode() に渡せるようになりました。
/* ... */
insertNode(&l, a, 0);
/* ... */
ここで何が起こるでしょうか。
当然、insertNode() が正常にノードを挿入した後は、a に対して free() を呼び出してはいけません。そのようにすると連結リストが壊れてしまいます。代わりに、連結リストを破棄するときにノードを解放します。
void destroyExceptGuard(Node *guard)
{
if (guard == NULL)
return;
Node *current = guard->next;
guard->next = NULL;
while (current != NULL)
{
Node *next = current->next;
free(current);
current = next;
}
}
insertNode() がノードの挿入に成功すると、そのノードの所有権は呼び出し元から連結リストへと移転します。この関数が移転を実行しますが、挿入後にそのノードを管理する責任を負うのは連結リストです。
createNode() はその逆の処理を行います。メモリを確保し、そのメモリを指すポインタを返します。関数が戻った後、その関数はメモリを解放する責任を負いません。代わりに、返されたポインタを受け取る呼び出し元にその責任が移ります。これを、関数から呼び出し元への所有権の移転と言います。
ライフタイム — リソースはどれくらいの期間存続すべきか
所有権を持つということは、所有者がメモリを解放する責任を負うだけでなく、いつ解放するかを決める責任も負うということです。言い換えれば、所有者がリソースのライフタイムを決定します。
より一般的に言えば、所有権とは、プログラムのどの部分がリソースのライフタイムを管理し、特に不要になったときに解放する責任を負うのかを定めるプログラミング上の取り決めです。ポインタはリソースを所有せずにそのリソースを指すことができ、複数のポインタが同じリソースを指すこともあります。
C では、動的に確保された記憶領域にあるオブジェクトのライフタイムは、free() や、確保された領域を変更する可能性のあるその他の関数によって管理されます。オブジェクトはメモリが確保された時点から存在し始め、その確保領域に対してこれらの関数のいずれかが呼び出されるまで存続します。
連結リストのノードをもう一度見てみましょう。
typedef struct N
{
int data;
struct N *previous;
struct N *next;
} Node;
完全で正しい構造を持つ連結リストには、番兵ノードと、ポインタによって互いに正しく接続された複数の要素ノードが存在します。関連するポインタを先に更新せずにノードを解放すると、隣接するノードに、そのライフタイムがすでに終了したオブジェクトを指すポインタ値が残ってしまうことがあります。これらのポインタは使用してはいけません。その結果、これらのポインタ関係をたどって連結リストを走査すると、未定義動作が発生する可能性があります。さらに、破棄されたノードより後ろにあるノードは、番兵ノードからリストを走査したときに到達できなくなることがあります。
ポインタのライフタイムについて話すとき、通常はポインタ変数自体のライフタイムではなく、そのポインタが指すオブジェクトのライフタイムを指しています。ポインタ変数にも独自のライフタイムがありますが、それは別のものであり、参照先のオブジェクトのライフタイムには影響しません。
ライフタイムの問題は、プログラマー自身がライフタイムを管理する動的確保メモリだけに限られません。例えば、createNode() を次の実装に置き換えた場合を考えてみましょう。
Node *createNode(int data)
{
Node ans;
ans.data = data;
ans.previous = NULL;
ans.next = NULL;
return &ans;
}
この実装は無効です。ans のライフタイムは関数の実行中に限られているからです。関数が戻ると ans のライフタイムも終了し、その時点で戻り値のポインタは、もはや存在していないオブジェクトを指すことになります。
Node ans に static を付けても問題は解決しません。これによって ans のライフタイムはプログラムの実行期間全体に延びますが、関数を呼び出すたびに新しいオブジェクトが作られるのではなく、常に同じオブジェクトが使われます。
異なるプログラミング言語における所有権とライフタイム
C では、所有権は言語自体によって強制されるものではありません。代わりに、プログラマーがクラッシュや予期しない動作を避けるために取り決めを定め、それを守ります。一方、オブジェクトのライフタイムは言語自体によって定義されています。
ほかのプログラミング言語では、所有権が言語自体によって強制される場合があります。Rust はその代表的な例です。Rust にはコンパイラーによって強制される所有権システムがあります。すべての値には所有者が存在し、移動セマンティクスによって変数間で所有権を移転できます。参照(&T と &mut T)を使うと、プログラムのほかの部分が所有権を取得せずに値を借用できます。Rust のライフタイム規則は、借用された参照が参照先の値より長く存続しないことを保証します。例えば、String は文字列データを格納する動的に確保されたバッファーを管理する所有型であり、&str は借用された文字列スライスです。Rust には、共有所有権を実現するための Rc<T> や Arc<T> といった型も用意されています。
C++ は RAII を採用しており、自動的なリソース管理と手動管理の仕組みを組み合わせています。new と delete を使ってメモリを手動で管理することもできますし、C++ 標準ライブラリが提供する std::unique_ptr<T> や std::shared_ptr<T> などのスマートポインターを使うこともできます。これらのオブジェクトは、動的に確保されたメモリの所有権に関する情報を内部に保持し、言語によるリソースの自動管理を可能にします。独自のスマートポインターを実装することもできます。std::unique_ptr<T> は排他的所有権を強制し、C における排他的所有権の取り決めと同様に振る舞いますが、リソースを自動的に管理します。std::shared_ptr<T> はカウンターを使用して、何個の変数がリソースの共有所有権を持っているかを追跡します。共有所有権を保持する変数がなくなると、リソースを自動的に解放します。
Python のような言語では、一般に自動メモリ管理が採用されており、プログラマーが明示的にメモリを確保したり解放したりする必要はありません。例えば、CPython は参照カウント方式と循環ガベージコレクターを組み合わせて使用しています。