C#ポインターとは？unsafeの使い方から参照型との違いまで初心者向けにわかりやすく解説

はじめに

C#は、メモリ管理を.NETランタイムに任せられる「安全性の高い言語」として使われることが多いです。そのため、C言語やC++のようにポインターを日常的に扱う場面は多くありません。

しかし、C#にもポインターは存在します。unsafeを使えば、変数のメモリアドレスを取得したり、ポインター経由で値を書き換えたり、C/C++ライブラリやWin32 APIのようなアンマネージドな世界と連携したりできます。

一方で、C#ポインターは初心者が何となく使うには危険な機能です。通常のC#コードでは、配列、クラス、参照型、ref、Span<T>、Memory<T>などで十分なケースがほとんどです。

この記事では、「C# ポインターとは何か」から、unsafeの使い方、参照型との違い、fixedやstackallocの基本、実際のサンプルコード、初心者が注意すべきポイントまでわかりやすく解説します。

1. C#ポインターとは？初心者がまず押さえる基本

C#ポインターとは、メモリ上の特定の場所を指し示すための仕組みです。通常のC#では、変数やオブジェクトを安全に扱えるように.NETが多くの処理を管理していますが、ポインターを使うと、その管理の一部を開発者が直接扱うことになります。

C#では、ポインターはunsafeコンテキストの中でのみ使用できます。MicrosoftのC#リファレンスでも、unsafeコンテキストではポインター、メモリブロックの割り当てと解放、関数ポインターなどを扱える一方、セキュリティや安定性のリスクがあると説明されています。

1-1. ポインターは「メモリ上のアドレス」を扱う仕組み

ポインターは、値そのものではなく「値が置かれているメモリ上の住所」を扱います。

たとえば、int number = 10;という変数があるとします。このnumberには10という値が入っていますが、コンピューターの内部では、その値はメモリ上のどこかに保存されています。ポインターは、その保存場所を指し示す変数です。

イメージとしては、次のように考えるとわかりやすいです。

C#
int number = 10;
int* p = &number;

この例では、numberは値そのもの、&numberはnumberのアドレス、pはそのアドレスを保持するポインターです。

つまり、ポインターは「値に直接触る」のではなく、「値がある場所をたどってアクセスする」ための仕組みです。

1-2. C#でもポインターは使えるが通常は使わない

C#ではポインターを使えますが、通常のアプリケーション開発ではほとんど使いません。

理由は、C#にはポインターを使わなくても安全にデータを扱う仕組みが多く用意されているからです。たとえば、オブジェクトを扱うなら参照型、メソッド内で値を書き換えたいならrefやout、連続したメモリ領域を効率よく扱いたいならSpan<T>やMemory<T>が使えます。

ポインターが必要になるのは、主にC/C++ライブラリとの連携、Win32 APIの呼び出し、画像処理やバイナリ処理などで低レベルなメモリアクセスが必要な場合です。

初心者がC#を学ぶ段階では、「C#にもポインターはあるが、普段は使わない」と理解しておけば十分です。

1-3. C#のポインターはunsafeコンテキストでのみ使用できる

C#でポインターを使うには、unsafeを指定する必要があります。

C#
unsafe
{
    int number = 10;
    int* p = &number;
    Console.WriteLine(*p);
}

unsafeは「このコードは通常のC#の安全性チェックでは検証できない処理を含みます」という意味です。unsafeを付けたからといって必ず危険なコードになるわけではありませんが、コンパイラやランタイムが安全性を保証しにくくなります。

また、unsafeコードをコンパイルするには、プロジェクト設定でAllowUnsafeBlocksを有効にする必要があります。

1-4. C言語・C++のポインターとの考え方の違い

C言語やC++では、ポインターは非常に基本的な機能です。配列、文字列、動的メモリ確保、関数呼び出しなど、多くの場面でポインターを使います。

一方、C#ではポインターは例外的な機能です。C#の通常のコードは、ガベージコレクション、型安全性、境界チェックなどによって守られています。ポインターを使うと、これらの保護を一部回避してメモリを直接扱うことになります。

つまり、C/C++では「ポインターを理解しないと本格的な開発が難しい」のに対し、C#では「ポインターを使わずに開発できるのが基本」です。

1-5. 初心者が混乱しやすい「ポインター」「参照」「アドレス」の関係

初心者が混乱しやすいのが、「ポインター」「参照」「アドレス」の違いです。

アドレスは、メモリ上の場所を表す値です。ポインターは、そのアドレスを格納する変数です。参照は、C#がオブジェクトを間接的に扱うための仕組みです。

たとえば、クラスのインスタンスを変数に代入すると、その変数はオブジェクトそのものではなく、オブジェクトへの参照を持ちます。しかし、この参照はC#のランタイムが管理するものであり、ポインターのように自由に加算したり、任意のメモリアドレスへ変換したりするものではありません。

簡単にまとめると、ポインターは「メモリアドレスを直接扱うもの」、参照は「オブジェクトを安全に間接参照するためのもの」です。

2. C#でポインターを使う前に知っておきたいメモリの基礎

C#ポインターを理解するには、メモリの基本を知っておく必要があります。特に、スタック、ヒープ、値型、参照型、ガベージコレクションの関係を理解しておくと、unsafeやfixedの意味がわかりやすくなります。

2-1. スタックとヒープの違い

スタックは、メソッド呼び出しやローカル変数などを管理するために使われるメモリ領域です。メソッドが呼び出されると必要な領域が確保され、メソッドが終了すると基本的にその領域は解放されます。

ヒープは、オブジェクトなどを動的に確保するためのメモリ領域です。C#でnewを使って作成したクラスのインスタンスや配列は、通常ヒープ上に確保されます。

スタックは確保と解放が速い一方、使える容量が限られています。ヒープは柔軟に使えますが、不要になったオブジェクトの回収はガベージコレクションによって行われます。

2-2. 値型と参照型のメモリ上の扱い

C#の型は、大きく値型と参照型に分けられます。

値型には、int、double、bool、structなどがあります。値型の変数は、基本的に値そのものを保持します。

参照型には、class、string、配列、objectなどがあります。参照型の変数は、オブジェクトそのものではなく、オブジェクトへアクセスするための参照を保持します。C#のstringは参照型ですが、文字列の内容はイミュータブル、つまり作成後に変更できない性質を持ちます。

ポインターを学ぶときは、「値型は値そのもの」「参照型は参照を通じてオブジェクトを扱う」と整理しておくと理解しやすくなります。

2-3. ガベージコレクションとメモリ管理の仕組み

C#では、不要になったオブジェクトのメモリはガベージコレクション、つまりGCによって自動的に回収されます。

GCは、プログラムがまだ使っているオブジェクトを追跡し、不要になったオブジェクトを解放します。また、必要に応じてヒープ上のオブジェクトを移動し、メモリを整理することがあります。

通常のC#コードでは、この仕組みのおかげで開発者が明示的にメモリを解放する必要はあまりありません。しかし、ポインターを使ってメモリ上の場所を直接扱うと、GCがオブジェクトを移動した場合にポインターが古いアドレスを指してしまう可能性があります。

この問題を防ぐために、C#ではfixedを使ってオブジェクトを一時的に固定します。

2-4. なぜC#ではポインターが制限されているのか

C#でポインターが制限されている理由は、安全性を保つためです。

ポインターを自由に使えると、配列の範囲外にアクセスしたり、すでに解放されたメモリを参照したり、本来書き換えてはいけない領域を書き換えたりできてしまいます。

C#は、型安全性やメモリ安全性を重視した言語です。そのため、通常のコードではポインターを使えないようにし、使う場合はunsafeとして明示する設計になっています。

2-5. マネージドコードとアンマネージドコードの違い

マネージドコードとは、.NETランタイムによって管理されるコードです。C#で普通に書くコードの多くはマネージドコードです。メモリ管理、型チェック、例外処理などを.NETが支援します。

アンマネージドコードとは、.NETランタイムの管理外で動くコードです。C言語やC++で書かれたネイティブライブラリ、OSのAPI、直接確保したアンマネージドメモリなどが該当します。

C#ポインターは、マネージドコードからアンマネージドな領域に近づくための機能です。そのため、便利な反面、通常のC#コードより慎重に扱う必要があります。

3. C#のunsafeとは？ポインターを使うための基本

C#でポインターを扱うには、unsafeの理解が欠かせません。unsafeは、C#の安全性チェックでは完全に検証できないコードを明示するためのキーワードです。

3-1. unsafeキーワードの意味

unsafeは、「危険なコードを書く」というより、「安全性をコンパイラやランタイムが完全には検証できないコードを書く」という意味です。

Microsoftのリファレンスでも、unsafeコードは必ずしも危険という意味ではなく、安全性を検証できないコードだと説明されています。

たとえば、次のような処理はunsafeが必要です。

C#
unsafe
{
    int value = 100;
    int* p = &value;
    Console.WriteLine(*p);
}

このコードでは、&valueで変数のアドレスを取得し、*pでポインターが指す先の値を読み取っています。

3-2. unsafeブロック・unsafeメソッド・unsafeクラスの書き方

unsafeは、ブロック、メソッド、クラスに指定できます。

まず、必要な範囲だけをunsafeにする書き方です。

C#
public static void Main()
{
    unsafe
    {
        int value = 10;
        int* p = &value;
        Console.WriteLine(*p);
    }
}

メソッド全体をunsafeにすることもできます。

C#
public static unsafe void ShowAddress()
{
    int value = 10;
    int* p = &value;
    Console.WriteLine(*p);
}

クラス全体をunsafeにすることも可能です。

C#
public unsafe class PointerSample
{
    public void Run()
    {
        int value = 10;
        int* p = &value;
        Console.WriteLine(*p);
    }
}

初心者は、できるだけunsafeの範囲を小さくするのがおすすめです。必要な部分だけをunsafeブロックにすることで、危険な処理の範囲を把握しやすくなります。

3-3. unsafeコードをコンパイルするための設定

unsafeコードは、ただ書くだけではコンパイルできない場合があります。プロジェクトでunsafeコードを許可する必要があります。

.NET SDK形式のプロジェクトでは、.csprojに次の設定を追加します。

XML
<PropertyGroup>
  <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>

この設定により、unsafeブロックを含むコードをコンパイルできるようになります。

3-4. Visual Studioでunsafeを有効にする方法

Visual Studioを使っている場合は、プロジェクトの設定画面からunsafeを有効にできます。

一般的な手順は次のとおりです。

1. プロジェクトを右クリックする

2. 「プロパティ」を開く

3. 「ビルド」または「ビルド全般」を開く

4. 「アンセーフ コードを許可する」にチェックを入れる

5. 保存してビルドする

Visual Studioのバージョンやプロジェクト形式によって画面名は少し異なりますが、設定内容としてはAllowUnsafeBlocksを有効にしているのと同じです。

3-5. .csprojでAllowUnsafeBlocksを設定する方法

.csprojで直接設定する場合は、次のように書きます。

XML
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
  </PropertyGroup>

</Project>

複数のターゲットフレームワークを指定している場合でも、PropertyGroupにAllowUnsafeBlocksを追加すればunsafeコードを許可できます。

3-6. unsafeを使うときの注意点

unsafeを使うときは、次の点に注意しましょう。

まず、ポインターが指す先が有効であることを確認する必要があります。無効なアドレスを参照すると、不正アクセスやクラッシュの原因になります。

次に、GCによって移動する可能性があるオブジェクトをポインターで扱う場合は、fixedで固定する必要があります。C#のポインターはGCに追跡されないため、管理対象ヒープ上のオブジェクトを指す場合は特に注意が必要です。

また、unsafeを使う範囲はできるだけ小さくし、代替手段がある場合はそちらを優先しましょう。

4. C#ポインターの基本文法と使い方

ここからは、C#ポインターの基本文法を見ていきます。最初は難しく見えますが、型*、&、*の3つを押さえると基本は理解できます。

4-1. ポインター型の宣言方法

C#でポインター型を宣言するには、型名の後ろに*を付けます。

C#
int* p;
double* d;
byte* b;
char* c;

int*は「int型の値を指すポインター」、byte*は「byte型の値を指すポインター」です。

ポインターのポインターも宣言できます。

C#
int** pp;

これは「int型ポインターを指すポインター」です。

C#のポインター型はobjectを継承せず、ポインターとobjectの間の変換もありません。ボックス化やアンボックス化もポインターには対応していません。

4-2. &演算子で変数のアドレスを取得する

&演算子を使うと、変数のアドレスを取得できます。

C#
unsafe
{
    int number = 123;
    int* p = &number;

    Console.WriteLine((long)p);
}

&numberは、numberが置かれているメモリアドレスを表します。そのアドレスをint*型の変数pに代入しています。

ただし、どんな変数でも自由にアドレスを取得できるわけではありません。GCで移動される可能性があるオブジェクトや配列要素を扱う場合は、fixedが必要になります。

4-3. *演算子でポインターの参照先にアクセスする

*演算子は、ポインターが指す先の値にアクセスするために使います。これを「間接参照」と呼びます。

C#
unsafe
{
    int number = 123;
    int* p = &number;

    Console.WriteLine(*p);
}

このコードでは、pがnumberのアドレスを持っているため、*pはnumberの値である123を表します。

宣言時のint* pの*は「ポインター型を宣言する記号」であり、式の中の*pは「ポインターの参照先にアクセスする記号」です。同じ*でも意味が違うので注意しましょう。

4-4. ポインター経由で値を読み書きするサンプル

ポインター経由で値を読み取るだけでなく、書き換えることもできます。

C#
using System;

class Program
{
    static unsafe void Main()
    {
        int number = 10;
        int* p = &number;

        Console.WriteLine(number); // 10

        *p = 99;

        Console.WriteLine(number); // 99
    }
}

*p = 99;によって、ポインターが指しているnumberの値が書き換わります。

このように、ポインターは変数の実体に直接アクセスできる強力な仕組みです。しかし、間違ったアドレスを指していると、意図しないメモリを書き換えてしまう危険があります。

4-5. nullポインターの扱い方

ポインターにはnullを代入できます。

C#
unsafe
{
    int* p = null;

    if (p == null)
    {
        Console.WriteLine("ポインターはnullです");
    }
}

nullポインターは、どこも指していないポインターです。nullかどうかを比較することはできますが、*pのように参照先へアクセスしてはいけません。

C#
unsafe
{
    int* p = null;

    // 危険：nullポインターを間接参照している
    // Console.WriteLine(*p);
}

C#のリファレンスでも、nullポインターに間接参照演算子を適用した場合の動作は実装依存とされています。

4-6. void*の使い方と注意点

void*は、型が決まっていないポインターを表します。

C#
unsafe
{
    int number = 10;
    void* vp = &number;
}

void*は「何らかのメモリアドレス」を持てますが、参照先の型が不明なため、そのまま*vpのように値へアクセスすることはできません。

値にアクセスしたい場合は、具体的なポインター型にキャストします。

C#
unsafe
{
    int number = 10;
    void* vp = &number;

    int* p = (int*)vp;
    Console.WriteLine(*p);
}

void*は便利ですが、型情報を失うため危険も大きくなります。初心者のうちは、できるだけ具体的な型のポインターを使う方が安全です。

4-7. ポインター同士の型変換とキャスト

C#では、ポインター型同士を明示的にキャストできます。

C#
unsafe
{
    int number = 1024;
    int* ip = &number;
    byte* bp = (byte*)ip;

    Console.WriteLine(*bp);
}

この例では、int*をbyte*に変換しています。これにより、intのメモリ表現を1バイト単位で見ることができます。

ただし、型変換を間違えると、メモリの解釈を誤ります。たとえば、本来intとして扱うべき領域を別の構造体として読み取ると、意味のない値になったり、不正アクセスの原因になったりします。

ポインターのキャストは、バイナリ解析やネイティブ連携など、目的が明確な場合に限定しましょう。

5. C#ポインターと参照型の違い

C#ポインターを理解するときに最も混同しやすいのが、参照型との違いです。クラス変数もオブジェクトの場所を間接的に扱うため、「参照型はポインターと同じでは？」と感じるかもしれません。

しかし、C#の参照型とポインターは別物です。

5-1. 参照型はオブジェクトの場所を間接的に扱う仕組み

クラスのインスタンスは参照型です。

C#
class Person
{
    public string Name { get; set; } = "";
}

Person p = new Person();
p.Name = "Alice";

このpは、Personオブジェクトそのものを直接持っているわけではありません。オブジェクトにアクセスするための参照を持っています。

ただし、この参照はC#のランタイムが管理します。開発者が参照の数値アドレスを見たり、p + 1のようなポインター演算をしたりすることはできません。

5-2. ポインターはメモリアドレスを直接扱う仕組み

ポインターは、メモリアドレスを直接扱います。

C#
unsafe
{
    int value = 10;
    int* p = &value;

    Console.WriteLine(*p);
}

このpには、valueのアドレスが入っています。ポインター演算を使えば、次の要素に移動することもできます。

C#
p++;

このような操作は、参照型の変数にはできません。

参照型はC#が安全に管理する間接参照、ポインターは開発者が直接扱うメモリアドレス、と考えると違いが明確になります。

5-3. 参照型はGCに管理され、ポインターは管理対象外

参照型のオブジェクトはGCに管理されます。GCは、オブジェクトがまだ使われているかどうかを追跡し、不要になったものを回収します。

一方、ポインターはGCに追跡されません。Microsoftのドキュメントでも、GCはポインター型がオブジェクトを指しているかどうかを追跡しないため、管理対象ヒープ上のオブジェクトを指す場合は、その間オブジェクトを固定する必要があると説明されています。

この違いは非常に重要です。参照型はランタイムが守ってくれますが、ポインターは開発者が責任を持って扱う必要があります。

5-4. ref・out・inとポインターの違い

C#には、ポインターを使わずに変数を参照渡しする仕組みがあります。それがref、out、inです。

refを使うと、メソッドに変数を参照渡しできます。

C#
static void AddOne(ref int value)
{
    value++;
}

int number = 10;
AddOne(ref number);
Console.WriteLine(number); // 11

outは、メソッドから値を返すために使います。

C#
static void CreateValue(out int value)
{
    value = 100;
}

inは、コピーを避けつつ読み取り専用で渡したい場合に使います。

C#
static void Show(in int value)
{
    Console.WriteLine(value);
}

refは、メソッド呼び出しやローカル変数で参照を扱うためのキーワードとして使われます。

これらはポインターと似て見えますが、C#の型安全性や寿命管理のルールに従うため、通常はポインターより安全です。

5-5. クラスの参照とポインターを混同しないための考え方

クラスの参照は、「オブジェクトを操作するための安全なハンドル」のようなものです。開発者は、参照の中身が実際にどのようなアドレスかを意識しません。

ポインターは、「メモリ上の場所そのものを指す値」です。アドレスを取得し、間接参照し、必要ならポインター演算も行います。

したがって、クラス変数を見て「これはポインターのようなもの」と考えるより、「C#が管理している安全な参照」と考える方が適切です。

5-6. 初心者はポインターより参照型・refを優先すべき理由

初心者がC#で値を共有したり、メソッド内で書き換えたりしたい場合は、まず参照型やrefを使うべきです。

理由は、ポインターよりも安全で、読みやすく、保守しやすいからです。

たとえば、値を書き換えるだけなら次のようにrefで十分です。

C#
static void Double(ref int value)
{
    value *= 2;
}

配列を処理するなら、通常のインデックスアクセスで十分なことが多いです。

C#
int[] numbers = { 1, 2, 3 };

for (int i = 0; i < numbers.Length; i++)
{
    numbers[i] *= 2;
}

ポインターは、これらの方法では解決できない明確な理由がある場合に使うものです。

6. fixed・stackalloc・配列で使うC#ポインター

C#ポインターで重要なのが、fixedとstackallocです。どちらもメモリを扱う機能ですが、目的が異なります。

fixedは、GCによって移動される可能性のあるオブジェクトを一時的に固定するために使います。stackallocは、スタック上に一時的なメモリ領域を確保するために使います。

6-1. fixedとは？GCによる移動を防ぐ仕組み

fixedは、GCがオブジェクトを移動しないように一時的に固定するための構文です。

配列や文字列などは通常ヒープ上にあり、GCによって移動される可能性があります。その状態でポインターを取得すると、GCがオブジェクトを移動したときにポインターが古い場所を指してしまいます。

fixedを使うと、ブロック内では対象のアドレスが変わらないようにできます。Microsoftのドキュメントでも、fixed文は移動可能な変数をGCが再配置しないようにし、その変数へのポインターを宣言すると説明されています。

6-2. 配列や文字列のアドレスを固定してポインターで扱う方法

配列の先頭アドレスを取得する例です。

C#
using System;

class Program
{
    static unsafe void Main()
    {
        int[] numbers = { 10, 20, 30 };

        fixed (int* p = numbers)
        {
            Console.WriteLine(*p);       // 10
            Console.WriteLine(*(p + 1)); // 20
            Console.WriteLine(*(p + 2)); // 30
        }
    }
}

fixed (int* p = numbers)によって、配列を固定し、先頭要素へのポインターを取得しています。

文字列の場合は、char*として扱えます。

C#
using System;

class Program
{
    static unsafe void Main()
    {
        string message = "Hello";

        fixed (char* p = message)
        {
            Console.WriteLine(*p); // H
        }
    }
}

ただし、stringはイミュータブルです。文字列の内容を書き換える目的でポインターを使うのは避けるべきです。

6-3. stackallocとは？スタック上にメモリを確保する方法

stackallocは、スタック上に一時的なメモリ領域を確保するための構文です。

C#
unsafe
{
    int* buffer = stackalloc int[3];

    buffer[0] = 10;
    buffer[1] = 20;
    buffer[2] = 30;

    Console.WriteLine(buffer[1]); // 20
}

stackallocで確保されたメモリは、メソッドが終了すると自動的に破棄されます。明示的に解放することはできません。また、GCの対象ではないため、fixedで固定する必要もありません。

6-4. fixedとstackallocの違い

fixedとstackallocの違いは、扱うメモリの場所です。

fixedは、すでに存在する配列や文字列などの管理対象オブジェクトを一時的に固定します。つまり、対象は基本的にヒープ上のオブジェクトです。

stackallocは、新しい一時バッファをスタック上に確保します。ヒープにオブジェクトを作らないため、短時間だけ使う小さなバッファに向いています。

まとめると、既存の配列や文字列のアドレスを取りたいならfixed、一時的な小さいバッファを確保したいならstackallocです。

6-5. Span<T>とstackallocを組み合わせる方法

最近のC#では、stackallocをポインターではなくSpan<T>と組み合わせて使うことができます。

C#
Span<int> numbers = stackalloc int[3];

numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

Console.WriteLine(numbers[1]); // 20

この書き方では、ポインター型を直接使わないため、unsafeコンテキストが不要です。Microsoftのドキュメントでも、stackallocの結果をSpan<T>やReadOnlySpan<T>に代入する場合はunsafeコンテキストが不要であり、可能な場合はSpan<T>やReadOnlySpan<T>を使うことが推奨されています。

初心者が一時バッファを扱うなら、まずはポインターではなくSpan<T>との組み合わせを検討しましょう。

6-6. ポインター演算で配列要素にアクセスする方法

ポインターは加算や減算ができます。

C#
using System;

class Program
{
    static unsafe void Main()
    {
        int[] numbers = { 10, 20, 30 };

        fixed (int* p = numbers)
        {
            Console.WriteLine(*p);       // 10
            Console.WriteLine(*(p + 1)); // 20
            Console.WriteLine(*(p + 2)); // 30
        }
    }
}

p + 1は、アドレスを1バイト進めるという意味ではありません。int*の場合、intのサイズ分だけ進みます。

つまり、p + 1は次のint要素、p + 2はさらに次のint要素を指します。

6-7. 範囲外アクセスに注意すべき理由

通常の配列アクセスでは、範囲外にアクセスすると例外が発生します。

C#
int[] numbers = { 10, 20, 30 };
Console.WriteLine(numbers[10]); // IndexOutOfRangeException

しかし、ポインターで範囲外にアクセスすると、C#の通常の境界チェックを受けずに不正なメモリを読んだり書いたりする可能性があります。

C#
unsafe
{
    int[] numbers = { 10, 20, 30 };

    fixed (int* p = numbers)
    {
        // 危険：配列の範囲外
        // Console.WriteLine(*(p + 10));
    }
}

このようなコードは、クラッシュやメモリ破壊につながる可能性があります。ポインター演算を使う場合は、必ず範囲を自分で管理する必要があります。

7. C#でポインターを使う主な場面

C#ポインターは日常的に使う機能ではありませんが、必要になる場面もあります。ここでは、代表的な用途を紹介します。

7-1. C言語・C++ライブラリとの連携

C言語やC++で作られたライブラリは、引数としてポインターを要求することがあります。

たとえば、バッファの先頭アドレスを渡して、ネイティブ側でデータを書き込むようなAPIです。このような場合、C#側でもポインターやIntPtr、Span<T>、Marshalなどを使って連携することがあります。

ただし、P/Invokeでは必ずしもポインターが必要とは限りません。配列や構造体、SafeHandleなどを使ってより安全に扱える場合もあります。

7-2. Win32 APIなどアンマネージドAPIの呼び出し

Windowsの低レベルAPI、いわゆるWin32 APIでは、ハンドル、構造体ポインター、バッファポインターなどを扱うことがあります。

C#からこれらを呼び出す場合、DllImport、IntPtr、Marshal、SafeHandleなどを使います。場合によってはunsafeポインターを使った方が自然なこともあります。

ただし、OSリソースを扱う場合は、ポインターそのものよりも、リソースの解放漏れを防ぐ設計が重要です。

7-3. 画像処理・音声処理など高速なメモリアクセス

画像処理や音声処理では、大量のバイト列を高速に処理する必要があります。ピクセルデータや音声サンプルに対して、1要素ずつアクセスする処理では、ポインターを使うことでオーバーヘッドを減らせる場合があります。

ただし、現代の.NETではJIT最適化、Span<T>、SIMD、MemoryMarshalなどの選択肢もあります。ポインターを使う前に、まず安全な方法で十分な性能が出るかを確認しましょう。

7-4. Unityやゲーム開発でのパフォーマンス最適化

Unityやゲーム開発では、パフォーマンスを重視する場面があります。大量の頂点データ、バイナリデータ、ネイティブプラグインとの連携などで、ポインターやアンマネージドメモリを扱うことがあります。

ただし、ゲーム開発でも、ポインターを使えば必ず速くなるわけではありません。アルゴリズム、メモリアクセスパターン、GCアロケーション削減、データ構造の見直しの方が効果的な場合も多いです。

7-5. 構造体やバイナリデータを直接扱う処理

ファイルフォーマット、ネットワークパケット、センサーデータなど、バイナリデータを構造体として読み書きしたい場面があります。

このような場合、ポインターを使うと、メモリ上のバイト列を構造体として扱えることがあります。

C#
unsafe struct Header
{
    public int Id;
    public short Version;
}

ただし、構造体のレイアウト、エンディアン、アラインメント、パディングなどに注意が必要です。単純にポインターでキャストすれば常に正しく読めるわけではありません。

7-6. ポインターを使うべきケースと使わない方がよいケース

ポインターを使うべきケースは、主に次のような場面です。

ネイティブAPIがポインターを要求している場合、非常に低レベルなメモリ操作が必要な場合、安全な代替手段では性能要件を満たせないことを測定済みの場合です。

逆に、通常の業務アプリ、Webアプリ、一般的なデータ処理、単なる値の受け渡しでは、ポインターを使う必要はほとんどありません。

初心者は、「ポインターを使うと高度に見える」ではなく、「ポインターを使わないと解決できない明確な理由があるか」で判断しましょう。

8. C#ポインターを使う際のリスクと注意点

C#ポインターは強力ですが、リスクもあります。ここでは、実務で特に注意すべきポイントを整理します。

8-1. メモリ破壊や不正アクセスが起こる可能性

ポインターを使うと、本来アクセスしてはいけないメモリを読んだり書いたりできてしまいます。

たとえば、配列の範囲外に書き込むと、別のデータを壊す可能性があります。問題がすぐに表面化するとは限らず、後から別の場所で原因不明のクラッシュが発生することもあります。

通常のC#では配列境界チェックや型安全性が守ってくれますが、ポインターでは開発者自身が安全性を確認する必要があります。

8-2. GCの管理外になることによる危険性

C#ポインターはGCに追跡されません。そのため、管理対象オブジェクトのアドレスをポインターとして保持している場合、GCがそのオブジェクトを移動すると問題が起こります。

この問題を防ぐためにfixedを使いますが、fixedの範囲外でポインターを使い続けると危険です。

C#
int* p;

fixed (int* temp = numbers)
{
    p = temp;
}

// 危険：fixedブロックの外でpを使うべきではない

fixedで得たポインターは、基本的にfixedブロック内だけで使うと考えましょう。

8-3. セキュリティリスクと保守性の低下

unsafeコードは、セキュリティ上のリスクにもつながります。

不正なメモリアクセス、バッファオーバーラン、データ破壊などが発生すると、アプリケーションの信頼性が下がります。外部入力を扱う処理でポインターを使う場合は、特に注意が必要です。

また、unsafeコードは読む人に高度な理解を要求します。チーム開発では、保守できるメンバーが限られる可能性もあります。

Microsoftのunsafeコードのベストプラクティスでも、unsafeコードは安全チェックを回避できるため、メモリ破壊につながる不安定なパターンを生む可能性があり、必要な場合に慎重に使うべきだと説明されています。

8-4. fixedを長時間使い続けない方がよい理由

fixedは、GCによるオブジェクト移動を一時的に防ぎます。これはポインターを使うためには必要ですが、長時間固定し続けるとGCの効率に影響する可能性があります。

GCはメモリを整理するためにオブジェクトを移動することがありますが、固定されたオブジェクトは動かせません。固定された領域が多くなると、ヒープの断片化につながる場合があります。

そのため、fixedはできるだけ短い範囲で使い、必要な処理が終わったらすぐにブロックを抜けるのが基本です。

8-5. unsafeコードをレビューするときのチェックポイント

unsafeコードをレビューするときは、次の点を確認しましょう。

ポインターが有効な範囲内で使われているか、fixedブロック外にポインターを持ち出していないか、配列やバッファの範囲外にアクセスしていないか、nullポインターを間接参照していないか、アンマネージドメモリの解放漏れがないかを確認します。

また、そもそもunsafeが本当に必要かも確認すべきです。Span<T>、Memory<T>、Marshal、SafeHandle、通常の配列操作で代替できるなら、そちらを優先した方がよい場合が多いです。

8-6. 初心者が避けたいポインターの書き方

初心者が避けるべきなのは、寿命が短いローカル変数のアドレスを外へ返すコードです。

C#
// 悪い例
static unsafe int* GetPointer()
{
    int value = 10;
    return &value;
}

このようなコードは、メソッド終了後に無効になるローカル変数のアドレスを返してしまいます。

また、fixedブロック内で取得したポインターをフィールドに保存するような書き方も避けましょう。

C#
// 危険な考え方
// fixedで取得したポインターを後で使うために保存する

ポインターは「今この瞬間に有効な場所」を指しているだけです。寿命を超えて使うと危険です。

9. C#ポインターの代替手段

C#では、ポインターを使わなくても多くの処理を実現できます。実務では、まず代替手段を検討し、それでも必要な場合だけポインターを使うのが基本です。

9-1. 参照型で実現できるケース

オブジェクトを共有したいだけなら、参照型で十分です。

C#
class Counter
{
    public int Value { get; set; }
}

Counter counter = new Counter();
counter.Value = 10;

Update(counter);

static void Update(Counter counter)
{
    counter.Value = 20;
}

この例では、Counterが参照型なので、メソッド内でプロパティを書き換えると呼び出し元にも反映されます。

このような処理にポインターは不要です。

9-2. ref・out・inで代替できるケース

値型の変数をメソッド内で変更したい場合は、refで代替できます。

C#
static void Increment(ref int value)
{
    value++;
}

複数の値を返したい場合は、outを使えます。

C#
static bool TryDivide(int x, int y, out int result)
{
    if (y == 0)
    {
        result = 0;
        return false;
    }

    result = x / y;
    return true;
}

大きな構造体をコピーせず読み取り専用で渡したい場合は、inを使えます。

C#
static void Print(in LargeStruct value)
{
    Console.WriteLine(value);
}

これらは、ポインターより安全でC#らしい書き方です。

9-3. Span<T>・Memory<T>で安全にメモリを扱う方法

連続したメモリ領域を扱いたい場合は、Span<T>やMemory<T>が有力な選択肢です。

Span<T>は、配列、スタック上のメモリ、ネイティブメモリなど、連続したメモリ領域を表現できます。

C#
Span<int> numbers = stackalloc int[3];
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

Span<T>は範囲を持つため、ポインターより安全に扱えます。パフォーマンスが必要な処理でも、まずSpan<T>を検討する価値があります。

Memory<T>は、非同期処理やフィールド保持が必要な場合に使いやすい型です。Span<T>はスタック限定の性質があるため、長く保持したい場合はMemory<T>が適しています。

9-4. Marshalクラスでアンマネージドメモリを扱う方法

アンマネージドメモリを扱う場合、Marshalクラスを使う方法があります。

Marshalクラスは、アンマネージドメモリの割り当て、メモリブロックのコピー、マネージド型とアンマネージド型の変換など、アンマネージドコードと連携するためのメソッドを提供します。

たとえば、アンマネージドメモリを確保して解放する例です。

C#
using System;
using System.Runtime.InteropServices;

class Program
{
    static void Main()
    {
        IntPtr ptr = Marshal.AllocHGlobal(100);

        try
        {
            // ptrを使った処理
        }
        finally
        {
            Marshal.FreeHGlobal(ptr);
        }
    }
}

Marshalを使う場合も、確保したメモリの解放を忘れないことが重要です。

9-5. SafeHandleを使って安全にリソースを管理する方法

OSハンドルなどのアンマネージドリソースを扱う場合は、IntPtrをそのまま持つよりSafeHandleを使う方が安全です。

SafeHandleは、OSハンドルを操作するためのラッパークラスであり、IDisposableを実装しています。Microsoftのドキュメントでは、OSハンドルを表すラッパークラスで、継承して使うものと説明されています。

SafeHandleを使うと、例外が発生した場合でもハンドル解放の責任を型に閉じ込めやすくなります。

ファイル、プロセス、レジストリ、パイプなどのハンドルを扱う場合は、既存のSafeFileHandleなどを使えるか確認しましょう。

9-6. ポインターを使う前に検討すべき選択肢

C#ポインターを使う前に、次の順番で検討するとよいです。

まず、通常の配列やクラスで書けないかを考えます。次に、ref、out、inで解決できないかを確認します。連続メモリを扱うなら、Span<T>やMemory<T>を検討します。アンマネージド連携なら、IntPtr、Marshal、SafeHandle、P/Invokeのマーシャリング機能を検討します。

それでも性能やAPI仕様の都合で必要な場合に、初めてunsafeポインターを使うのが安全です。

10. C#ポインターのサンプルコードで理解を深める

ここからは、C#ポインターの基本をサンプルコードで確認します。実際に動かす場合は、プロジェクトでAllowUnsafeBlocksを有効にしてください。

10-1. int型変数のアドレスを取得する基本サンプル

C#
using System;

class Program
{
    static unsafe void Main()
    {
        int number = 42;
        int* p = &number;

        Console.WriteLine($"numberの値: {number}");
        Console.WriteLine($"ポインター経由の値: {*p}");
        Console.WriteLine($"アドレス: {(long)p:X}");
    }
}

このコードでは、&numberでnumberのアドレスを取得し、int* pに代入しています。*pでポインターが指す先の値を表示しています。

(long)p:Xは、ポインターの値を16進数で表示するための書き方です。

10-2. ポインター経由で値を書き換えるサンプル

C#
using System;

class Program
{
    static unsafe void Main()
    {
        int number = 10;
        int* p = &number;

        Console.WriteLine(number); // 10

        *p = 50;

        Console.WriteLine(number); // 50
    }
}

*p = 50;によって、numberの値が直接書き換わります。

このように、ポインターは参照先の変数そのものを変更できます。便利ですが、間違ったアドレスを指していると危険です。

10-3. 配列をfixedで固定して操作するサンプル

C#
using System;

class Program
{
    static unsafe void Main()
    {
        int[] numbers = { 10, 20, 30 };

        fixed (int* p = numbers)
        {
            for (int i = 0; i < numbers.Length; i++)
            {
                Console.WriteLine(*(p + i));
            }
        }
    }
}

配列はGCによって移動される可能性があるため、ポインターで扱う場合はfixedで固定します。

p + iによって、配列のi番目の要素に対応するアドレスへ移動しています。*(p + i)でその値を読み取ります。

10-4. stackallocで一時バッファを作るサンプル

C#
using System;

class Program
{
    static unsafe void Main()
    {
        int* buffer = stackalloc int[5];

        for (int i = 0; i < 5; i++)
        {
            buffer[i] = i * 10;
        }

        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine(buffer[i]);
        }
    }
}

stackalloc int[5]によって、スタック上にint5個分の領域を確保しています。

ただし、stackallocは大量のメモリ確保には向きません。スタックの容量は限られているため、大きなバッファには配列やメモリプールなどを使いましょう。

Span<T>を使うなら、より安全に書けます。

C#
using System;

class Program
{
    static void Main()
    {
        Span<int> buffer = stackalloc int[5];

        for (int i = 0; i < buffer.Length; i++)
        {
            buffer[i] = i * 10;
        }

        foreach (int value in buffer)
        {
            Console.WriteLine(value);
        }
    }
}

この書き方なら、ポインターを直接使わずにスタック上の一時バッファを扱えます。

10-5. 構造体をポインターで扱うサンプル

構造体のポインターを使う例です。

C#
using System;

struct Point
{
    public int X;
    public int Y;
}

class Program
{
    static unsafe void Main()
    {
        Point point = new Point { X = 10, Y = 20 };
        Point* p = &point;

        Console.WriteLine(p->X); // 10
        Console.WriteLine(p->Y); // 20

        p->X = 99;

        Console.WriteLine(point.X); // 99
    }
}

構造体ポインターでは、p->Xのように->演算子を使ってメンバーへアクセスできます。

これは次の書き方と似ています。

C#
(*p).X

ただし、p->Xの方が読みやすいため、構造体ポインターではよく使われます。

10-6. よくあるコンパイルエラーと解決方法

ポインター関連でよくあるエラーの1つは、unsafeコンテキストではない場所でポインターを使うことです。

C#
int number = 10;
int* p = &number; // エラー

解決するには、unsafeブロックやunsafeメソッド内に書きます。

C#
unsafe
{
    int number = 10;
    int* p = &number;
}

次によくあるのは、プロジェクトでunsafeコードが許可されていないエラーです。この場合は、.csprojに次を追加します。

XML
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>

また、配列のアドレスを取得しようとしてエラーになることもあります。

C#
int[] numbers = { 1, 2, 3 };

// fixedなしでは危険
// int* p = &numbers[0];

この場合は、fixedを使います。

C#
fixed (int* p = &numbers[0])
{
    Console.WriteLine(*p);
}

11. C#ポインターに関するよくある質問

最後に、C#ポインターについて初心者が疑問に思いやすい点をQ&A形式で整理します。

11-1. C#でポインターは必要ですか？

通常のC#開発では、ポインターはほとんど必要ありません。

Webアプリ、業務システム、デスクトップアプリ、一般的なゲームロジックなどでは、クラス、配列、コレクション、ref、Span<T>などで十分です。

ポインターが必要になるのは、ネイティブAPIとの連携、低レベルなバイナリ処理、特殊な高速化が必要な場面などです。

初心者は、まずポインターを使わないC#の書き方をしっかり身につけることを優先しましょう。

11-2. unsafeを使うと必ず危険ですか？

unsafeを使ったからといって、必ず危険なコードになるわけではありません。

ただし、unsafeコードは通常のC#の安全性チェックでは検証できない処理を含みます。つまり、正しく書けば問題ありませんが、間違えるとメモリ破壊や不正アクセスにつながる可能性があります。

重要なのは、unsafeの範囲を小さくし、入力値やバッファサイズを厳密に確認し、レビューしやすいコードにすることです。

11-3. 参照型はポインターと同じですか？

同じではありません。

参照型は、C#ランタイムが管理する安全な参照です。開発者は、参照の数値アドレスを直接操作したり、ポインター演算をしたりできません。

ポインターは、メモリアドレスを直接保持し、間接参照やポインター演算ができます。

クラスの変数は「ポインターのようにオブジェクトを間接的に扱う」と説明されることがありますが、C#の機能としては参照型とポインターは明確に区別されます。

11-4. stringやclassのポインターは取得できますか？

stringはfixedを使うことで、文字データへのchar*を取得できます。

C#
unsafe
{
    string text = "ABC";

    fixed (char* p = text)
    {
        Console.WriteLine(*p); // A
    }
}

ただし、stringはイミュータブルなので、内容を書き換える目的で扱うべきではありません。

一方、通常のクラスインスタンスをそのままMyClass*のようなポインターとして扱うことはできません。クラスは参照型であり、C#のポインターとは別の仕組みです。

クラスのデータをネイティブに渡したい場合は、構造体、マーシャリング、GCHandle、SafeHandle、IntPtrなど、目的に応じた方法を検討します。

11-5. ポインターを使うと必ず高速になりますか？

必ず高速になるわけではありません。

ポインターを使うと配列境界チェックを避けられる場合があり、特定の処理では高速化につながることがあります。しかし、現代の.NETはJIT最適化が進んでおり、安全なコードでも十分高速なことが多いです。

また、ポインターを使うことでコードが複雑になり、バグのリスクが増えるなら、多少の速度差よりも安全性と保守性を優先すべきです。

高速化を目的にポインターを使う場合は、必ずベンチマークを取り、実際に効果があることを確認しましょう。

11-6. 初心者はどこまで理解すればよいですか？

初心者は、まず次の内容を理解できれば十分です。

C#にもポインターはあるが通常は使わないこと、ポインターはメモリアドレスを直接扱うこと、使うにはunsafeが必要なこと、配列や文字列をポインターで扱う場合はfixedが必要なこと、代替手段としてref、Span<T>、Memory<T>などがあることです。

実際にポインターを本格的に使うのは、C#の基本、参照型、値型、GC、構造体、P/Invokeなどを理解してからで問題ありません。

まとめ

C#ポインターは、メモリ上のアドレスを直接扱うための機能です。C言語やC++では中心的な機能ですが、C#では通常の開発で頻繁に使うものではありません。

C#でポインターを使うには、unsafeコンテキストが必要です。int*のようにポインター型を宣言し、&でアドレスを取得し、*で参照先の値にアクセスします。配列や文字列のようにGCで移動される可能性があるオブジェクトを扱う場合は、fixedで一時的に固定します。一時的な小さいバッファにはstackallocを使えますが、最近のC#ではSpan<T>と組み合わせる方が安全な場合も多いです。

参照型とポインターは似て見えますが、まったく同じではありません。参照型はC#ランタイムに管理される安全な仕組みであり、ポインターはメモリアドレスを直接扱う低レベルな仕組みです。

初心者は、まず参照型、ref、out、in、Span<T>、Memory<T>などの安全な方法を優先しましょう。C#ポインターは、ネイティブAPIとの連携や高度なパフォーマンス最適化など、明確な理由がある場合にだけ使うべき機能です。