ポインタ（コンピュータプログラミング）

コンピュータサイエンスにおいて、ポインタとは、多くのプログラミング言語でメモリアドレスを格納するオブジェクトです。これは、コンピュータメモリにある別の値のアドレス、またはメモリマップされたコンピュータハードウェアのアドレスである場合もあります。ポインタはメモリ内の場所を参照し、その場所に格納されている値を取得することをポインタの逆参照といいます。類推として、本の索引にあるページ番号は、対応するページへのポインタと考えることができます。このようなポインタの逆参照は、指定されたページ番号のページに移動し、そのページにあるテキストを読むことで行われます。ポインタ変数の実際の形式と内容は、基盤となるコンピュータアーキテクチャによって異なります。

ポインタを使用すると、反復可能なデータ構造(文字列、ルックアップ テーブル、制御テーブル、ツリー構造など) のトラバースなどの反復操作のパフォーマンスが大幅に向上します。特に、ポインタをコピーして逆参照する方が、ポインタが指すデータをコピーしてアクセスするよりも、時間とスペースの面ではるかに安価になることがよくあります。

ポインターは、手続き型プログラミングで呼び出されるサブルーチンのエントリ ポイントのアドレスを保持したり、ダイナミック リンク ライブラリ (DLL)への実行時リンクを保持したりするためにも使用されます。オブジェクト指向プログラミングでは、関数へのポインターは、多くの場合、仮想メソッド テーブルを使用してメソッドをバインドするために使用されます。

ポインタは、より抽象的な参照 データ型の単純でより具体的な実装です。いくつかの言語、特に低レベル言語は、何らかのタイプのポインタをサポートしていますが、その使用には他の言語よりも多くの制限があります。「ポインタ」は一般的に参照を指すために使用されていますが、より適切には、ポインタを明示的に操作できるインターフェイスを持つデータ構造に適用されます（算術的に操作する）。ポインタはメモリアドレスとしてアクセスと保護されていないアクセスの両方を許可するため、特に後者の場合、使用にはリスクが伴います。プリミティブポインタは整数に似た形式で格納されることが多いですが、値が有効なメモリアドレスで^はないポインタを逆参照または^「検索」しようとすると、プログラムがクラッシュする (または無効なデータが含まれる) 可能性があります。この型の安全性の観点から、ポインタは、たとえ基になる表現が整数であっても、指すデータの型によってパラメータ化された別の型と見なされます。ポインタ変数に有効なメモリアドレスであり、プロセッサがアドレス指定できる数値範囲内の値が含まれていることを確認するために、 検証や境界チェック

1955年、ソビエトウクライナのコンピュータ科学者カテリーナ・ユシチェンコは、間接アドレッシングと最高ランクのアドレス（ポインタに類似）を可能にするアドレスプログラミング言語を作成した。この言語はソビエト連邦のコンピュータで広く使用されていた。しかし、ソビエト連邦以外では知られておらず、通常、ポインタの発明者は1964年のハロルド・ローソンであるとされている。 ^[2] 2000年、ローソンは「ポインタ変数を発明し、この概念をPL/Iに導入し、汎用の高級言語でリンクリストを柔軟に処理する機能を初めて提供した」としてIEEEからコンピュータパイオニア賞を受賞した。 ^[3]この概念に関する彼の独創的な論文は、1967年6月発行のCACM誌に「PL/Iリスト処理」と題して掲載された。オックスフォード英語辞典によると、ポインタという単語が印刷物に初めて登場したのは、 システム開発会社による技術覚書の中でスタックポインタとしてだった。

コンピュータサイエンスでは、ポインタは参照の一種です。

データプリミティブ(または単にプリミティブ) は、1 回のメモリ アクセスを使用してコンピュータ メモリから読み取ったり、コンピュータ メモリに書き込んだりできるデータです(たとえば、バイトとワードはどちらもプリミティブです)。

データ集合体(または単に集合体) は、メモリ内で論理的に連続し、集合的に 1 つのデータとして見られるプリミティブのグループです (たとえば、集合体は 3 つの論理的に連続するバイトで、その値は空間内の 1 点の 3 つの座標を表します)。集合体全体が同じ種類のプリミティブで構成されている場合、その集合体は配列と呼ばれることがあります。ある意味では、マルチバイトワードプリミティブはバイトの配列であり、一部のプログラムではワードをこのように使用します。

ポインタは、値またはオブジェクトを格納するメモリ位置を参照またはポイントするためにコンピュータ サイエンスで使用されるプログラミング概念です。本質的には、データ自体を格納するのではなく、別の変数またはデータ構造のメモリ アドレスを格納する変数です。

ポインタは、C や C++ などの直接メモリ操作をサポートするプログラミング言語でよく使用されます。ポインタを使用すると、プログラマはメモリを直接操作できるため、効率的なメモリ管理とより複雑なデータ構造が可能になります。ポインタを使用すると、メモリ内にあるデータにアクセスして変更したり、関数間でデータを効率的に渡したり、リンク リスト、ツリー、グラフなどの動的なデータ構造を作成したりできます。

簡単に言えば、ポインターはコンピューターのメモリ内の特定の場所を指し示し、その場所に保存されているデータとやり取りできるようにする矢印と考えることができます。

メモリ ポインタ(または単にポインタ) は、その値がメモリ アドレスとして使用されることを意図したプリミティブです。ポインタはメモリ アドレスを指していると言われます。また、ポインタの値がデータのメモリ アドレスである場合、 ポインタは [メモリ内の] データを指していると言われます。

より一般的には、ポインタは参照の一種であり、ポインタはメモリ内のどこかに格納されているデータを参照すると言われています。そのデータを取得するには、ポインタを逆参照します。ポインタを他の種類の参照と区別する特徴は、ポインタの値がメモリアドレスとして解釈されることを意図しており、これはかなり低レベルの概念です。

参照は間接レベルとして機能します。ポインターの値によって、計算で使用するメモリ アドレス (つまり、データ) が決まります。間接はアルゴリズムの基本的な側面であるため、ポインターはプログラミング言語の基本データ型として表現されることが多く、静的(または厳密に) 型付けされたプログラミング言語では、ポインターの型によって、ポインターが指すデータの型が決まります。

ポインタは、ほとんどの最新アーキテクチャが提供するアドレス指定機能の上にある非常に薄い抽象化です。最も単純なスキームでは、アドレス、つまり数値インデックスがシステム内の各メモリ ユニットに割り当てられます。このユニットは通常、アーキテクチャがバイト アドレス指定可能かワード アドレス指定可能かに応じてバイトまたはワードのいずれかであり、実質的にすべてのメモリが非常に大きな配列に変換されます。システムは、指定されたアドレスのメモリ ユニットに格納されている値を取得する操作も提供します (通常はマシンの汎用レジスタを使用)。

通常の場合、ポインタはシステム内のメモリの単位よりも多くのアドレスを保持できるほど大きい。このため、十分なメモリがインストールされていない (つまり、使用可能なメモリの範囲を超えている) か、アーキテクチャがそのようなアドレスをサポートしていないために、プログラムがメモリの単位に対応しないアドレスにアクセスしようとする可能性が生じる。最初のケースは、Intel x86アーキテクチャなどの特定のプラットフォームでは、セグメンテーション違反(segfault)と呼ばれることがある。2 番目のケースは、ポインタが 64 ビット長で、アドレスが 48 ビットまでしか拡張されないAMD64の現在の実装で発生する可能性がある。ポインタは特定の規則 (標準アドレス) に準拠する必要があるため、非標準ポインタが参照されると、プロセッサは一般保護違反を発生させる。

一方、システムによっては、アドレスの数よりもメモリ ユニットの数が多いものもあります。この場合、メモリのセグメント化やページングなどのより複雑な方式を採用して、メモリの異なる部分を異なるタイミングで使用します。x86 アーキテクチャの最新のバージョンでは、最大 36 ビットの物理メモリ アドレスがサポートされ、PAEページング メカニズムによって 32 ビットの線形アドレス空間にマップされました。したがって、一度にアクセスできるのは、可能な合計メモリの 1/16 だけです。同じコンピュータ ファミリの別の例としては、80286プロセッサの16 ビット保護モードがあります。このプロセッサは、16 MB の物理メモリしかサポートしていませんが、最大 1 GB の仮想メモリにアクセスできましたが、16 ビットのアドレス レジスタとセグメント レジスタの組み合わせにより、1 つのデータ構造で 64 KB を超えるデータにアクセスするのは面倒でした。

一貫したインターフェイスを提供するために、一部のアーキテクチャではメモリマップド I/Oが提供されており、一部のアドレスはメモリの単位を参照し、他のアドレスはコンピューター内の他のデバイスのデバイス レジスタを参照できます。ファイル オフセット、配列インデックス、リモート オブジェクト参照など、他の種類のオブジェクトのアドレスと同じ目的を果たす類似の概念があります。

ポインタは、 PL/I、C、C++、Pascal、FreeBASICなどの言語では制限なく直接サポートされており、ほとんどのアセンブリ言語では暗黙的にサポートされています。ポインタは主に参照の構築に使用され、参照はほぼすべてのデータ構造の構築の基礎となるほか、プログラムの異なる部分間でデータを渡す場合にも使用されます。

リストに大きく依存する関数型プログラミング言語では、データ参照は、consなどのプリミティブ構造と、対応する要素car および cdr を使用して抽象的に管理されます。これらは、コンスセルの最初と 2 番目のコンポーネントへの特殊なポインターと考えることができます。これにより、関数型プログラミングの慣用的な「特徴」が生まれます。このようなcons リストでデータを構造化することにより、これらの言語では、データの構築と処理の再帰的な手段が容易になります。たとえば、リストのリストの先頭要素と末尾要素に再帰的にアクセスします (例: 「cdr の cdr の car を取得する」)。対照的に、メモリ アドレスの配列の近似値でのポインタ参照解除に基づくメモリ管理により、変数を、命令的にデータを割り当てることができるスロットとして扱うことが容易になります。

配列を扱う場合、重要な検索操作には通常、配列内の目的のデータ要素へのポインターを構築するアドレス計算と呼ばれる段階が含まれます。リンク リストなどの他のデータ構造では、ポインターは構造の 1 つの部分を別の部分に明示的に結び付ける参照として使用されます。

ポインタは、参照によってパラメータを渡すために使用されます。これは、プログラマが関数のパラメータに対する変更を関数の呼び出し元に表示したい場合に便利です。また、関数から複数の値を返す場合にも便利です。

ポインターは、メモリ内の動的変数や配列の割り当てと解放にも使用できます。変数は目的を果たした後は不要になることが多いため、保持しておくのはメモリの無駄です。そのため、不要になった変数は (元のポインター参照を使用して) 解放することをお勧めします。解放しないと、メモリ リークが発生する可能性があります(多数の冗長なメモリ ブロックが蓄積されるため、使用可能な空きメモリが徐々に、または深刻な場合は急速に減少します)。

ポインタを定義する基本的な構文は次の通りである: ^[4]

ポインタ;​​ 

これは、ptr次のタイプのオブジェクトの識別子として宣言します。

• 型のオブジェクトを指すポインタint

これは通常、「 はptrへのポインタですint」と簡潔に表現されます。

C言語では自動記憶域期間のオブジェクトに対して暗黙的な初期化を指定していないため、^{[5] ポインタ}が指すアドレスが有効であることを確認するために注意を払う必要があります。このため、ポインタをヌルポインタptr値に明示的に初期化することが推奨されることがあります。これは、C言語では伝統的に標準化されたマクロで指定されています。^[6]NULL

int * ptr = NULL ;   

C言語でヌルポインタを参照すると未定義の動作が発生し、^[7]壊滅的な結果を招く可能性があります。ただし、ほとんどの実装^{[要出典]では、通常は}セグメンテーション違反により、問題のプログラムの実行が単に停止されます。

ただし、ポインタを不必要に初期化すると、プログラム分析が妨げられ、バグが隠れてしまう可能性があります。

いずれにせよ、ポインタが宣言されたら、次の論理的なステップはそれが何かを指すことです。

int a = 5 ; int * ptr = NULL ;   
   

ポインタ= &a a ;  

aこれは のアドレスの値を に代入しますptr。たとえば、 がaメモリ位置 0x8130 に格納されている場合、代入後の の値はptr0x8130 になります。ポインターを逆参照するには、アスタリスクを再度使用します。

*ポインタ= 8 ;  

ptrこれは、(0x8130)の内容を取得し、メモリ内でそのアドレスを「見つけて」、その値を 8 に設定することを意味します。a後で再度アクセスすると、新しい値は 8 になります。

この例は、メモリを直接調べるとより明確になります。 がaメモリ内のアドレス 0x8130 と 0x8134 にあると仮定しますptr。また、これは 32 ビット マシンであり、int は 32 ビット幅であると仮定します。次のコード スニペットを実行した後、メモリの内容は次のようになります。

int a = 5 ; int * ptr = NULL ;   
   

(ここで示されている NULL ポインタは 0x00000000 です。) のアドレスを に割り当てると、a次のようになりますptr。

ポインタ= &a a ;  

次のメモリ値が生成されます。

次に、ptrコーディングによって逆参照します。

*ポインタ= 8 ;  

ptrコンピュータは(0x8130) の内容を取得し、そのアドレスを「特定」し、その場所に 8 を割り当てて、次のメモリを生成します。

明らかに、前の命令がポインタ を介してaの内容を変更したため、 にアクセスすると値 8 が生成されます。 aptr

リスト、キュー、ツリーなどのデータ構造を設定する場合、構造の実装方法と制御方法を管理するのに役立つポインタが必要です。ポインタの一般的な例としては、開始ポインタ、終了ポインタ、スタックポインタなどがあります。これらのポインタは、絶対ポインタ(実際の物理アドレスまたは仮想メモリ内の仮想アドレス) または相対ポインタ(通常、完全なアドレスよりも少ないビットを使用する絶対開始アドレス (「ベース」) からのオフセットですが、解決には通常 1 つの追加の算術演算が必要です) のいずれかになります。

相対アドレスは手動メモリ分割の一形態であり、その長所と短所の多くを共有しています。16 ビットの符号なし整数を含む 2 バイトのオフセットを使用して、最大 64 KiB (2 ¹⁶バイト) のデータ構造の相対アドレス指定を提供できます。ポイントするアドレスがハーフワード、ワード、またはダブルワード境界に揃えられるよう強制されている場合、このアドレスは 128、256、または 512 KiB に簡単に拡張できます(ただし、ベース アドレスに追加する前に、オフセットを 2、4、または 8 倍に調整するために、1、2、または 3 ビットの追加の「左シフト」ビット演算が必要です)。ただし、一般に、このようなスキームは多くの問題を伴うため、プログラマの利便性のために絶対アドレス (およびその基礎となるフラットアドレス空間) が好まれます。

文字の 16 進ASCII値 (例: X'29')などの 1 バイトのオフセットは、配列内の別の整数値 (またはインデックス) (例: X'01') を指すために使用できます。このようにして、文字を「生データ」から使用可能な連続インデックスに、さらにルックアップ テーブルなしで絶対アドレスに非常に効率的に変換できます。

C言語では、配列のインデックスはポインタ演算によって正式に定義されています。つまり、言語仕様ではがarray[i]と同等であることが求められています*(array + i)。^[8]したがって、C言語では、配列は連続したメモリ領域へのポインタ（ギャップなし）と考えることができます。 ^[8]また、配列にアクセスするための構文は、ポインタを参照解除するために使用できる構文と同じです。たとえば、配列はarray次のように宣言して使用できます。

int array [ 5 ]; /* 5 つの連続した整数を宣言します */ int * ptr = array ; /* 配列はポインターとして使用できます */ ptr [ 0 ] = 1 ; /* ポインターは配列構文でインデックスできます */ * ( array + 1 ) = 2 ; /* 配列はポインター構文で逆参照できます */ * ( 1 + array ) = 2 ; /* ポインターの加算は可換です */ 2 [ array ] = 4 ; /* 添字演算子は可換です */       
     
          
      
      
        

これは 5 つの整数のブロックを割り当て、そのブロックに名前を付けます。これは、ブロックへのポインターとして機能します。ポインターのもう 1 つの一般的な使用法は、 mallocarrayから動的に割り当てられたメモリを指すことです。malloc は、配列として使用できる、要求されたサイズ以上の連続したメモリ ブロックを返します。

配列とポインターのほとんどの演算子は同等ですが、演算子の結果はsizeof異なります。この例では、は(配列のサイズ)sizeof(array)と評価され、 は、つまりポインター自体のサイズ と評価されます。5*sizeof(int)sizeof(ptr)sizeof(int*)

配列のデフォルト値は次のように宣言できます。

int配列[ 5 ] = { 2,4,3,1,5 } ;​​​​​​​       

arrayが32 ビットリトルエンディアンマシンのアドレス 0x1000 から始まるメモリに配置されている場合、メモリには次の内容が含まれます (値はアドレスと同様 に16 進数です)。

ここで表されているのは、2、4、3、1、5 の 5 つの整数です。これらの 5 つの整数はそれぞれ 32 ビット (4 バイト) を占め、最下位バイトが最初に格納され (これはリトルエンディアンCPU アーキテクチャです)、アドレス 0x1000 から連続して格納されます。

ポインターを使用した C の構文は次のとおりです。

• array0x1000を意味します。
• array + 10x1004 を意味します: 「+ 1」はサイズ 1 int、つまり 4 バイトを追加することを意味します。
• *arrayの内容を逆参照することを意味しますarray。内容をメモリアドレス (0x1000) と見なし、その場所 (0x0002) の値を検索します。
• array[i]iは 0 から始まる要素番号 を意味し、arrayに変換されます*(array + i)。

最後の例は、 のコンテンツにアクセスする方法ですarray。詳しく見てみましょう。

• array + iは、i=0から始まる、の(i)^番目の要素のメモリ位置です。array
• *(array + i)そのメモリ アドレスを取得し、それを逆参照して値にアクセスします。

以下はC での リンク リストの定義例です。

/* 空のリンクリストは NULL 
* または他のセンチネル値で表されます */ 
#define EMPTY_LIST NULL

struct link { void * data ; /* このリンクのデータ */ struct link * next ; /* 次のリンク。存在しない場合は EMPTY_LIST */ };  
              
        

このポインタ再帰定義は、 Haskell プログラミング言語の参照再帰定義と本質的に同じです。

 データリンクa = Nil | Cons a (リンクa )    
                 

Nilは空のリストであり、型の別のリンクを持つ型のコンスセルCons a (Link a)です。 aa

ただし、参照を使用した定義は型チェックが行われ、混乱を招く可能性のあるシグナル値は使用されません。このため、C のデータ構造は通常、正確性が慎重にチェックされるラッパー関数を介して処理されます。

ポインターを使用すると、変数をアドレスで渡し、その値を変更することができます。たとえば、次のCコードを考えてみましょう。

/* int n のコピーは、呼び出しコードに影響を与えずに関数内で変更できます */ 
void passByValue ( int n ) { n = 12 ; }   
      


/* 代わりにポインタ m が渡されます。m が指す値のコピーは作成されません */ 
void passByAddress ( int * m ) { * m = 14 ; }   
      


int main ( void ) { int x = 3 ;  
       

    /* x の値のコピーを引数として渡す */ 
passByValue ( x ); // 関数内で値は変更されましたが、ここから x は 3 のままです    
    

    /* x のアドレスを引数として渡す */ 
passByAddress ( & x ); // x は実際には関数によって変更され、ここでは 14 になっています    
    

    0 を返す; } 

一部のプログラムでは、必要なメモリの量はユーザーが入力する内容によって異なります。このような場合、プログラマはメモリを動的に割り当てる必要があります。これは、変数が通常格納されるスタックではなく、ヒープ領域にメモリを割り当てることによって行われます (ただし、変数は CPU レジスタに格納することもできます)。動的なメモリ割り当てはポインターを通じてのみ行うことができ、一般的な変数のように名前を付けることはできません。

ポインタは、動的に割り当てられたメモリ ブロックのアドレスを保存および管理するために使用されます。このようなブロックは、データ オブジェクトまたはオブジェクトの配列を保存するために使用されます。ほとんどの構造化言語およびオブジェクト指向言語は、ヒープまたはフリー ストアと呼ばれるメモリ領域を提供し、そこからオブジェクトが動的に割り当てられます。

以下の C コードの例は、構造体オブジェクトが動的に割り当てられ、参照される方法を示しています。標準 C ライブラリには、ヒープからメモリ ブロックを割り当てる関数が用意malloc()されています。この関数は、割り当てるオブジェクトのサイズをパラメーターとして受け取り、オブジェクトの格納に適した新しく割り当てられたメモリ ブロックへのポインターを返します。割り当てが失敗した場合は、null ポインターを返します。

/* 部品在庫項目 */ 
struct Item { int id ; /* 部品番号 */ char * name ; /* 部品名 */ float cost ; /* コスト */ };  
                  
              
              


/* 新しい Item オブジェクトを割り当てて初期化します */ 
struct Item * make_item ( const char * name ) { struct Item * item ;      
       

    /* 新しい Item オブジェクトにメモリ ブロックを割り当てます */ 
item = malloc ( sizeof ( struct Item )); if ( item == NULL ) return NULL ;       
       
         

    /* 新しいアイテムのメンバーを初期化します */ 
memset ( item , 0 , sizeof ( struct Item )); item -> id = -1 ; item -> name = NULL ; item -> cost = 0.0 ;       
        
      
      

    /* 新しいアイテムに名前のコピーを保存します */ 
item -> name = malloc ( strlen ( name ) + 1 ); if ( item -> name == NULL ) { free ( item ); return NULL ; } strcpy ( item -> name , name );        
        
        
         
    
     

    /* 新しく作成された Item オブジェクトを返します */ 
return item ; }     

以下のコードは、メモリ オブジェクトが動的に割り当て解除される、つまりヒープまたはフリー ストアに返される方法を示しています。標準 C ライブラリには、free()以前に割り当てられたメモリ ブロックの割り当てを解除し、ヒープに戻す関数が用意されています。

/* Item オブジェクトの割り当てを解除します */ 
void destroy_item ( struct Item * item ) { /* null オブジェクト ポインターをチェックします */ if ( item == NULL ) return ;    
    
       
        

    /* アイテム内に保存されている名前文字列を解放します */ 
if ( item -> name != NULL ) { free ( item -> name ); item -> name = NULL ; }        
        
          
    

    /* Itemオブジェクト自体の割り当てを解除します */ 
free ( item ); }    

一部のコンピューティング アーキテクチャでは、ポインターを使用してメモリまたはメモリ マップされたデバイスを直接操作できます。

ポインターにアドレスを割り当てることは、マイクロコントローラーをプログラミングする際に非常に役立つツールです。以下は、int 型のポインターを宣言し、それを定数 0x7FFF の 16 進アドレスに初期化する簡単な例です。

int *ハードウェアアドレス= ( int * ) 0x7FFF ;    

80 年代半ば、BIOS を使用してPC のビデオ機能にアクセスするのは低速でした。ディスプレイを多用するアプリケーションでは、通常、16 進定数 0xB8000 を 80 個の符号なし 16 ビット int 値の配列へのポインターにキャストして、CGAビデオ メモリに直接アクセスしていました。各値は、下位バイトのASCIIコードと上位バイトの色で構成されていました。したがって、行 5、列 2 の文字「A」を青地に明るい白で表示するには、次のようなコードを記述します。

#define VID ((符号なしショート (*)[80])0xB8000)

void foo ( void ) { VID [ 4 ][ 1 ] = 0x1F00 | 'A' ; }  
        

プログラム フローを制御するために使用される制御テーブルでは、通常、ポインタが多用されます。通常、テーブル エントリに埋め込まれるポインタは、たとえば、同じテーブル エントリで定義された特定の条件に基づいて実行されるサブルーチンへのエントリ ポイントを保持するために使用されます。ただし、ポインタは、実際のアドレスの配列またはアドレス自体 (使用可能なプログラミング言語構造によって異なります) で構成される、別の関連するテーブルへのインデックスに過ぎません。また、以前のテーブル エントリを指すために使用したり (ループ処理の場合など)、一部のテーブル エントリをスキップするために前方に移動したり (ループからのスイッチまたは「早期」終了の場合など) するために使用することもできます。後者の目的の場合、「ポインタ」は単にテーブル エントリ番号そのもので、簡単な演算によって実際のアドレスに変換できます。

多くの言語では、ポインタには、ポインタが指すオブジェクトが特定の型であるという追加の制約があります。たとえば、ポインタが整数を指すように宣言されている場合、言語はプログラマが浮動小数点数などの整数ではないオブジェクトを指すことを防止し、一部のエラーを排除しようとします。

例えばCでは

int *お金; char *バッグ; 
 

moneyは整数ポインタで、bagscharポインタになります。次のコードは、GCCでは「互換性のないポインタ型からの代入」というコンパイラ警告を発します。

バッグ=お金;  

moneyと が異なる型で宣言されているためですbags。コンパイラの警告を抑制するには、型キャストによって割り当てを行うことを明示的に指定する必要があります。

バッグ= ( char * )お金;   

これは、 の整数ポインタをmoneychar ポインタにキャストし、 に割り当てることを意味しますbags。

2005年のC標準草案では、ある型から派生したポインタを別の型のポインタにキャストする場合、両方の型のアライメントの正確性を維持する必要があると規定されている（6.3.2.3 ポインタ、第7項）。^[9]

char * external_buffer = "abcdef" ; int * internal_data ;   
 

internal_data = ( int * ) external_buffer ; // 結果のポインタが正しく整列されていない場合は未定義の動作     
                                         

ポインタ演算が可能な言語では、ポインタの演算では型のサイズが考慮されます。たとえば、ポインタに整数を加算すると、その数値に型のサイズを掛けた値だけ大きいアドレスを指す別のポインタが生成されます。これにより、上記の C 配列の例で示したように、特定の型の配列の要素のアドレスを簡単に計算できます。ある型のポインタを異なるサイズの別の型にキャストする場合、プログラマはポインタ演算の計算方法が異なることを想定する必要があります。たとえば、C では、配列moneyが 0x2000 で始まりsizeof(int)4 バイトであるのに対し はsizeof(char)1 バイトである場合、 はmoney + 10x2004 を指しますが、 は0x2001 を指します。キャストのその他のリスクには、「広い」データが「狭い」場所 ( など)bags + 1に書き込まれるときにデータが失われること、値をビットシフトするときに予期しない結果になること、および特に符号付き値と符号なし値の比較の問題などがあります。 bags[0] = 65537;

一般的に、どのキャストが安全かをコンパイル時に判断することは不可能ですが、一部の言語では実行時の型情報が格納されており、これを使用して、実行時にこれらの危険なキャストが有効であるかどうかを確認できます。他の言語では、安全なキャストの保守的な近似値のみを受け入れるか、まったく受け入れません。

C および C++ では、2 つのポインタを比較すると等しいとしても、それが等価であることを意味するわけではありません。これらの言語と LLVMでは、この規則は「2 つのポインタが同じアドレスを指しているからといって、それらが互換的に使用できるという意味で等しいとは限らない」と解釈され、ポインタ間の違いは出所と呼ばれます。 [ ^10]などの整数型へのキャストはuintptr_t実装定義であり、それが提供する比較では、2 つのポインタが互換可能かどうかについてそれ以上の洞察は得られません。さらに、バイトや算術への変換は、ポインタの使用を追跡しようとする最適化プログラムを混乱させますが、この問題は学術研究でまだ解明されていません。^[11]

ポインタはプログラムが定義されていないオブジェクトにアクセスできるようにするため、さまざまなプログラミング エラーの原因となる可能性があります。しかし、ポインタの有用性は非常に高いため、ポインタなしでプログラミング タスクを実行することは困難です。その結果、多くの言語では、ポインタのいくつかの落とし穴 (ポインタハザードとも呼ばれる) を排除して、ポインタの有用な機能の一部を提供するように設計された構造が作成されました。この文脈では、メモリを直接アドレス指定するポインタ (この記事で使用されている) は、スマート ポインターやその他のバリアント とは対照的に、生のポインターです

ポインタに関する大きな問題の 1 つは、数値として直接操作できる限り、未使用のアドレスや他の目的で使用されているデータを指すようにすることができることです。ほとんどの関数型プログラミング言語やJavaなどの最近の命令型言語を含む多くの言語では、ポインタをより不透明なタイプの参照 (通常は単に参照と呼ばれる) に置き換えています。これは、オブジェクトを参照するためにのみ使用でき、数値として操作することはできません。これにより、この種のエラーを防止できます。配列のインデックス付けは、特別なケースとして処理されます。

アドレスが割り当てられていないポインターは、ワイルド ポインターと呼ばれます。このような初期化されていないポインターを使用すると、初期値が有効なアドレスでないか、使用するとプログラムの他の部分が損傷する可能性があるため、予期しない動作が発生する可能性があります。その結果、セグメンテーション違反、ストレージ違反、またはワイルド ブランチ(関数ポインターまたは分岐アドレスとして使用された場合) が発生することがよくあります。

明示的なメモリ割り当てがあるシステムでは、ポインターが指しているメモリ領域を解放することで、ダングリング ポインターを作成することができます。このタイプのポインターは危険で、扱いにくいものです。解放されたメモリ領域には解放前と同じデータが含まれている可能性がありますが、その後、以前のコードには知られていない無関係なコードによって再割り当てされ、上書きされる可能性があります。ガベージ コレクションがある言語では、スコープ内に参照がなくなると解放が自動的に実行されるため、このタイプのエラーを防止できます。

C++などの一部の言語では、スマート ポインタがサポートされています。スマート ポインタは、参照として機能するだけでなく、単純な形式の参照カウントを使用して、動的メモリの割り当てを追跡するのに役立ちます。オブジェクトがスマート ポインタのシーケンスを介して間接的に自身を参照する参照サイクルがない場合、スマート ポインタによって、ぶら下がりポインタやメモリ リークの可能性が排除されます。Delphi文字列は、参照カウントをネイティブにサポートします。

Rustプログラミング言語では、ガベージ コレクションに頼ることなくポインターのバグを排除するために、借用チェッカー、ポインターの有効期間、およびnull ポインターのオプション型に基づく最適化が導入されています。

ヌルポインターには、ポインターが有効なオブジェクトを参照していないことを示すために予約された値があります。ヌル ポインターは、長さが不明なリストの終了や、何らかのアクションの実行の失敗などの状況を表すために日常的に使用されます。このヌル ポインターの使用は、 null 許容型やオプション型のNothing値と比較できます。

ダングリング ポインターとは、有効なオブジェクトを指していないポインターであり、その結果、プログラムがクラッシュしたり、異常な動作をする可能性があります。Pascal または C プログラミング言語では、明示的に初期化されていないポインターは、メモリ内の予測できないアドレスを指す場合があります。

次のサンプルコードは、ダングリング ポインタを示しています。

int func ( void ) { char * p1 = malloc ( sizeof ( char )); /* ヒープ上のどこかの場所の (未定義の) 値 */ char * p2 ; /* ぶら下がっている (初期化されていない) ポインタ */ * p1 = 'a' ; /* malloc() が NULL を返していないと仮定すると、これは問題ありません。 */ * p2 = 'b' ; /* これは未定義の動作を呼び出します */ }  
        
            
            
            

ここで、 はp2メモリ内の任意の場所を指す可能性があるため、割り当てを実行すると、*p2 = 'b';メモリの不明な領域が破損したり、セグメンテーション エラーが発生したりする可能性があります。

ポインターが、何も返さず、初期化されていないか破損しているプログラムまたは関数の開始へのエントリ ポイントのアドレスとして使用されている場合、それでもこのアドレスへの呼び出しまたはジャンプが行われると、「ワイルド ブランチ」が発生したと言われます。言い換えると、ワイルド ブランチとは、ワイルド (ぶら下がっている) な関数ポインターです。

結果は予測不可能な場合が多く、ポインタが「有効な」アドレスであるかどうか、およびそのアドレスに (偶然にも) 有効な命令 (オペコード) があるかどうかによって、エラーはさまざまな形で現れることがあります。ワイルド ブランチの検出は、証拠の多くがすでに事前に破壊されているか、またはブランチ位置で 1 つ以上の不適切な命令が実行されたために破壊されている可能性があるため、最も困難でストレスのかかるデバッグ作業の 1 つになる可能性があります。命令セット シミュレーターが利用できる場合、ワイルド ブランチが有効になる前に検出できるだけでなく、その履歴の完全または部分的なトレースも提供できます。

自動相対ポインタは、その値がポインタ自体のアドレスからのオフセットとして解釈されるポインタです。したがって、データ構造にデータ構造自体の一部を指す自動相対ポインタメンバーがある場合、自動相対ポインタの値を更新することなく、データ構造をメモリ内で再配置できます。^[12]

引用された特許では、自己相対ポインタという用語も同じ意味で使用されています。ただし、この用語の意味は他の意味で使用されています。

• ポインタ自体のアドレスではなく、構造体のアドレスからのオフセットを意味する。^[要出典]
• 独自のアドレスを含むポインタを意味し、メモリの任意の領域で互いを指すデータ構造の集合を再構築するのに役立ちます。^[13]

ベースポインタとは、別のポインタの値からのオフセット値を持つポインタである。これは、ブロックの先頭のアドレスをベースポインタに割り当てることで、データブロックを保存およびロードするために使用できる。^[14]

一部の言語では、ポインタが別のポインタを参照する場合があり、元の値を取得するには複数の間接参照操作が必要になります。間接参照のレベルごとにパフォーマンス コストが追加される可能性がありますが、複雑なデータ構造に適切な動作を提供するために間接参照が必要になる場合があります。たとえば、C では、リストの次の要素へのポインタを含む要素に基づいてリンク リストを定義するのが一般的です。

構造体要素{構造体要素* next ; int値; };  
      
                


構造体要素*ヘッド= NULL ;    

この実装では、リスト全体の代理としてリストの最初の要素へのポインタを使用します。リストの先頭に新しい値が追加された場合は、head新しい要素を指すように変更する必要があります。C 引数は常に値で渡されるため、二重間接参照を使用すると挿入を正しく実装でき、リストの先頭への挿入を処理するための特別なケース コードが不要になるという望ましい副作用があります。

// *head にソートされたリストがある場合、
それより前のすべての要素の値がそれより小さいか等しい最初の位置に要素 item を挿入します。
void insert ( struct element ** head , struct element * item ) { struct element ** p ; // p は要素へのポインターを指しますfor ( p = head ; * p != NULL ; p = & ( * p ) -> next ) { if ( item -> value <= ( * p ) -> value ) break ; } item -> next = * p ; * p = item ; }       
        
              
           
            
    
      
      


// 呼び出し元はこれを実行します: 
insert ( & head , item ); 

この場合、 の値が の値itemより小さい場合head、呼び出し元の はhead新しい項目のアドレスに適切に更新されます。

基本的な例は、C (および C++) の main 関数のargv引数です。これは、プロトタイプで として指定されています。これは、変数自体が文字列の配列 (配列の配列) へのポインターであるため、 は0 番目の文字列 (慣例によりプログラム名) へのポインターであり、 は0 番目の文字列の 0 番目の文字であるためです。 char **argvargv*argv**argv

一部の言語では、ポインターは実行可能コードを参照できます。つまり、関数、メソッド、またはプロシージャを指すことができます。関数ポインターは、呼び出される関数のアドレスを格納します。この機能は関数を動的に呼び出すために使用できますが、ウイルスやその他の悪意のあるソフトウェアの作成者が好んで使用する手法であることがよくあります。

int sum ( int n1 , int n2 ) { // 2つの整数パラメータを持ち、整数値を返す関数return n1 + n2 ; }        
       


int main ( void ) { int a , b , x , y ; int ( * fp )( int , int ); // sum のような関数を指すことができる関数ポインターfp = & sum ; // fp は関数 sum を指すようになりましたx = ( * fp )( a , b ); // 引数 a と b で関数 sum を呼び出しますy = sum ( a , b ); // 引数 a と b で関数 sum を呼び出します}  
        
          
                    
               
                 

二重リンク リストまたはツリー構造では、要素に保持されるバック ポインターは、現在の要素を参照する項目を「ポイントバック」します。これらは、メモリ使用量の増加を犠牲にして、ナビゲーションと操作に役立ちます。

(通常は 1 次元の) 配列へのインデックスを使用して、ポインターの動作をシミュレートすることができます。

主に、ポインタを明示的にサポートしていないが配列をサポートしている言語の場合、配列はメモリ範囲全体 (特定の配列のスコープ内) であるかのように考え、処理することができ、配列へのインデックスはアセンブリ言語の汎用レジスタ(個々のバイトを指すが、実際の値は配列の先頭からの相対値であり、メモリ内の絶対アドレスではない) と同等であると考えることができます。配列が、たとえば連続した 16メガバイトの文字データ構造であると仮定すると、個々のバイト (または配列内の連続するバイトの文字列) は、シミュレートされたポインタとして 31 ビットの符号なし整数を持つ配列の名前を使用して直接アドレス指定および操作できます(これは、上記のC 配列の例と非常によく似ています)。ポインタ演算は、インデックスへの加算または減算によってシミュレートでき、本物のポインタ演算と比較して追加のオーバーヘッドは最小限に抑えられます。

上記のテクニックを適切な命令セットシミュレーターと組み合わせて使用​​すれば、ポインターをまったくサポートしない別の言語 ( Java / JavaScriptなど) の任意 のマシンコードまたは任意のプロセッサ/言語の中間コード (バイトコード) をシミュレートすることも理論的には可能です。これを実現するには、最初にバイナリコードを配列の連続バイトにロードして、シミュレーターが同じ配列に含まれるメモリ内で完全に「読み取り」、解釈、および操作できるようにします。必要に応じて、バッファーオーバーフローの問題を完全に回避するために、通常はコンパイラーで境界チェックを実行できます (または、シミュレーターで手動でコーディングします)。

Ada は、すべてのポインタが型指定され、安全な型変換のみが許可される、強く型付けされた言語です。すべてのポインタはデフォルトで に初期化されnull、nullポインタを介してデータにアクセスしようとすると例外が発生します。Ada のポインタはアクセス型と呼ばれます。Ada 83 ではアクセス型での算術演算は許可されていませんでしたが (多くのコンパイラ ベンダーが非標準機能として提供していますが)、Ada 95 ではパッケージ を介してアクセス型での「安全な」算術演算がサポートされていますSystem.Storage_Elements。

Windows プラットフォーム用のBASICの古いバージョンのいくつかでは、文字列のアドレスを返す STRPTR() と変数のアドレスを返す VARPTR() がサポートされていました。Visual Basic 5 では、オブジェクト インターフェイスのアドレスを返す OBJPTR() と関数のアドレスを返す ADDRESSOF 演算子もサポートされていました。これらすべての型は整数ですが、その値はポインタ型が保持する値と同じです。

ただし、 FreeBASICやBlitzMaxなどのBASICの新しい方言には、完全なポインタ実装があります。FreeBASIC では、ポインタの演算 (C の に相当) は、ポインタがバイト幅であるかのように扱われます。Cのように、ポインタを逆参照することはできません。また、と他の型のポインタ間のキャストでは、警告は生成されません。 ANYvoid*ANYANYANY

dim as integer f = 257 dim as any ptr g = @ f dim as integer ptr i = g assert ( * i = 257 ) assert ( ( g + 4 ) = ( @ f + 1 ) )     
      
      
  
        

CおよびC++では、ポインタはアドレスを格納する変数であり、nullになることもあります。各ポインタには指し示す型がありますが、ポインタ型間では自由にキャストできます (ただし、関数ポインタとオブジェクト ポインタ間ではキャストできません)。「void ポインタ」と呼ばれる特殊なポインタ型を使用すると、任意の (関数以外の) オブジェクトを指すことができますが、直接参照解除できない (キャストする必要がある) という制限があります。アドレス自体は、十分なサイズの整数型との間でポインタをキャストすることで直接操作できることがよくありますが、結果は実装定義であり、未定義の動作を引き起こす可能性があります。以前の C 標準では十分な大きさが保証された整数型はありませんでしたが、C99では で定義されているuintptr_t typedef名が指定されています<stdint.h>が、実装ではそれを提供する必要はありません。

C++ はC ポインターと C 型キャストを完全にサポートします。また、コンパイル時に意図しない危険なキャストを捕捉するのに役立つ新しい型のキャスト演算子のグループもサポートします。C++11 以降、C ++標準ライブラリはスマート ポインター( unique_ptr、 )も提供しており、状況によってはプリミティブ C ポインターのより安全な代替として使用できます。C++ は、ポインターとはまったく異なる別の形式の参照もサポートしており、単に参照または参照型と呼ばれます。 shared_ptrweak_ptr

ポインタ演算、つまり算術演算 (および絶対値比較) を使用してポインタのターゲット アドレスを変更する機能は、言語標準によって、単一の配列オブジェクト (またはその直後) の境界内にとどまるように制限されており、それ以外の場合は未定義の動作が発生します。 ポインタを加算または減算すると、そのデータ型のサイズの倍数だけ移動します。 たとえば、4 バイトの整数値へのポインタに 1 を追加すると、ポインタが指しているバイト アドレスが 4 だけ増加します。 これにより、連続する整数配列の次の要素を指すようにポインタが増加されます。これは、多くの場合、意図した結果です。void 型voidにはサイズがないため、ポインタに対してポインタ演算を実行できず、したがって、指しているアドレスに追加できませんが、gccやその他のコンパイラは、バイト演算を非標準の拡張機能として実行し、 であるかのように扱います。 void*char *

ポインタ演算は、異なる型を処理する単一の方法をプログラマに提供します。char *つまり、実際のバイト単位のオフセットではなく、必要な要素の数を加算および減算することです。(ポインタを使用したポインタ演算では、定義により が 1 であるため、バイト オフセットが使用されます。) 特に、C 定義では、配列 の - 番目の要素であるsizeof(char)構文 が、が指す要素の内容である と同等であることが明示的に宣言されています。これは、 がと同等であり、たとえば または と記述して、配列 の 4 番目の要素に同じようにアクセスできることを意味します。 a[n]na*(a + n)a + nn[a]a[n]a[3]3[a]a

ポインタ演算は強力ですが、コンピュータ バグの原因になることがあります。ポインタ演算は初心者プログラマを混乱させ、異なるコンテキストに強制的に引き込む傾向があります。式は通常の演算式の場合もあれば、ポインタ演算式の場合もあり、ときにはその 1 つをもう 1 つと間違えやすいことがあります。これに対応して、多くの最新の高水準コンピュータ言語 (たとえばJava ) では、アドレスを使用したメモリへの直接アクセスは許可されていません。また、安全な C 方言Cyclone は、ポインタに関する多くの問題に対処しています。詳細については、 C プログラミング言語を参照してください。

ポインタ、または はvoid、void* ANSI C および C++ で汎用ポインタ型としてサポートされています。 へのポインタは、任意のvoidオブジェクト (関数ではない) のアドレスを格納できます。^[a]また、C では、代入時に暗黙的に他のオブジェクト ポインタ型に変換されますが、逆参照する場合は明示的にキャストする必要があります。 K&R C は、char*「型に依存しないポインタ」の目的で使用されていました (ANSI C より前)。

int x = 4 ; void * p1 = & x ; int * p2 = p1 ; // void* は暗黙的に int* に変換されます: C では有効ですが、C++ では有効ではありませんint a = * p2 ; int b = * ( int * ) p1 ; // インラインで逆参照する場合、暗黙的な変換はありません   
   
          
   
     

C++ では、代入の場合でも、他のポインタ型への暗黙的な変換は許可されませんvoid*。これは、不注意なキャストや意図しないキャストを回避するための設計上の決定ですが、ほとんどのコンパイラは他のキャストに遭遇したときにエラーではなく警告のみを出力します。

int x = 4 ; void * p1 = & x ; int * p2 = p1 ; // C++ では失敗します: void* からの暗黙的な変換はありませんint * p3 = ( int * ) p1 ; // C スタイルのキャストint * p4 = reinterpret_cast < int *> ( p1 ); // C++ キャスト   
   
                        
                  
     

void&C++ では、 (void へのポインタ) を補完する(void への参照)は存在しませんvoid*。これは、参照が指す変数へのエイリアスのように動作し、 型が である変数は存在できないためですvoid。

C++では、クラスの非静的メンバーへのポインタを定義できます。クラスにCメンバーがある場合T a、は型の&C::aメンバーへのポインタです。このメンバーはオブジェクトまたは関数です。 [ ^16]これらは演算子の右側で使用して、対応するメンバーにアクセスできます。 aT C::*.*->*

構造体S { int a ; int f () const { return a ;} }; S s1 {}; S * ptrS = & s1 ;  
 
    

 
   

int S ::* ptr = & S :: a ; // S::a へのポインタint ( S ::* fp )() const = & S :: f ; // S::f へのポインタ     
     

s1 . * ptr = 1 ; std :: cout << ( s1 . * fp )() << " \n " ; // 1 を出力ptrS ->* ptr = 2 ; std :: cout << ( ptrS ->* fp )() << " \n " ; // 2 を出力  
     
  
     

これらのポインタ宣言は、ポインタ宣言のほとんどのバリエーションをカバーします。もちろん、トリプルポインタを持つことは可能ですが、トリプルポインタの背後にある主な原則は、ダブルポインタにすでに存在しています。ここで使用されている名前は、g++またはclangをtypeid(type).name()使用するときに、これらの各型の式が等しいものです。^{[17] [18]}

char A5_A5_c [ 5 ][ 5 ]; /* 文字の配列の配列 */ char * A5_Pc [ 5 ]; /* 文字へのポインタの配列 */ char ** PPc ; /* 文字へのポインタへのポインタ（「ダブルポインタ」） */ char ( * PA5_c ) [ 5 ]; /* 文字の配列へのポインタ */ char * FPcvE (); /* 文字へのポインタを返す関数 */ char ( * PFcvE )(); /* 文字を返す関数へのポインタ */ char ( * FPA5_cvE ())[ 5 ]; /* 文字の配列へのポインタを返す関数 */ char ( * A5_PFcvE [ 5 ])(); /* 文字を返す関数へのポインタの配列 */     
         
             
       
          
        
  
  

メンバーへのポインターを含む次の宣言は、C++ でのみ有効です。

class C ; class D ; char C ::* M1Cc ; /* char へのメンバーへのポインタ */ char C ::* A5_M1Cc [ 5 ]; /* char へのメンバーへのポインタの配列 */ char * C ::* M1CPc ; /* char へのポインタへのメンバーへのポインタ */ char C ::** PM1Cc ; /* char へのメンバーへのポインタへのポインタ */ char ( * M1CA5_c ) [ 5 ]; /* char の配列へのメンバーへのポインタ */ char C ::* FM1CcvE (); /* char へのメンバーへのポインタを返す関数 */ char D ::* C ::* M1CM1Dc ; /* メンバーへのポインターからメンバーへのポインター、さらにcharへのポインターへ */ char C ::* C ::* M1CMS_c ; /* メンバーへのポインターからメンバーへのポインター、さらにcharへのポインターへ */ char ( C ::* FM1CA5_cvE ())[ 5 ]; /* char配列へのメンバーへのポインターを返す関数 */ char ( C ::* M1CFcvE )() /* charを返すメンバーへのポインター関数 */ char ( C ::* A5_M1CFcvE [ 5 ])(); /* charを返すメンバーへのポインター関数の配列 */ 
 
                
          
              
              
           
           
         
         
   
          
   

と()は[]よりも優先度が高い*。 ^[19]

C# プログラミング言語では、ポインターは、ポインターを含むコード ブロックをunsafeキーワードでマークするか、ポインター アクセスのusingアセンブリSystem.Runtime.CompilerServices規定によってサポートされます。構文は基本的に C++ と同じで、指し示すアドレスはマネージド メモリでもアンマネージドfixedメモリでもかまいません。ただし、マネージド メモリへのポインター (マネージド オブジェクトへのポインター) はキーワードを使用して宣言する必要があります。これにより、ポインターがスコープ内にある間、ガベージ コレクターがメモリ管理の一環として指し示すオブジェクトを移動することがなくなり、ポインター アドレスが有効なままになります。

ただし、例外として、 構造体を使用する場合があります。これはIntPtrと同等のメモリ管理機能を持ち、キーワードもアセンブリもint*必要ありません。この型は、 のメソッドを使用するときに返されることが多く、次に例を示します。 unsafeCompilerServicesSystem.Runtime.InteropServices

// プロセスのアンマネージメモリから 16
バイトのメモリを取得します。IntPtrポインター= System.Runtime.InteropServices.Marshal.AllocHGlobal ( 16 ) ;   

// 割り当てられたメモリで何かを行う


//割り当てられたメモリを解放しますSystem.Runtime.InteropServices.Marshal.FreeHGlobal ( pointer ) ;

.NETフレームワークSystemには、 およびSystem.Runtime.InteropServices名前空間 ( クラスなどMarshal)に多数のクラスとメソッドが含まれており、これらは .NET 型 ( など) を多数のアンマネージ型およびポインター (や など)System.String間で変換して、アンマネージ コードとの通信を可能にします。このようなメソッドのほとんどは、メモリ内の任意の場所に影響を与える可能性があるため、アンマネージ コードと同じセキュリティ アクセス許可要件を持ちます。 LPWSTRvoid*

COBOLプログラミング言語は、変数へのポインターをサポートします。プログラム内で宣言されたプリミティブまたはグループ (レコード) データ オブジェクトは、本質的にポインター ベースであり、LINKAGE SECTIONプログラム内に割り当てられるメモリは、データ項目のアドレス (通常は 1 つのメモリ ワード) 用のスペースのみです。プログラム ソース コードでは、これらのデータ項目は他のWORKING-STORAGE変数と同じように使用されますが、その内容はポインターを通じて暗黙的に間接的にアクセスされますLINKAGE。

指し示される各データ オブジェクトのメモリ空間は、通常、外部ステートメントを使用するか、またはorステートメントなどの埋め込まれた拡張言語構造を介して動的に割り当てられます。 CALLEXEC CICSEXEC SQL

COBOL の拡張バージョンでは、USAGE IS POINTER句で宣言されたポインタ変数も提供されます。このようなポインタ変数の値は、SETおよびSET ADDRESS文を使用して設定および変更されます。

COBOL の拡張バージョンの中には、実行可能コードのアドレスPROCEDURE-POINTERを格納できる変数を提供するものもあります。

PL /I言語は、すべてのデータ型へのポインタ (構造体へのポインタを含む)、再帰、マルチタスク、文字列処理、および広範な組み込み関数を完全にサポートしています。PL/I は、当時のプログラミング言語と比較して大きな進歩でした。^[要出典] PL/I ポインタは型指定がないため、ポインタの参照解除や代入にキャストは必要ありません。ポインタの宣言構文は でDECLARE xxx POINTER;、これは「xxx」という名前のポインタを宣言します。ポインタはBASED変数とともに使用されます。基底付き変数は、デフォルト ロケータ (DECLARE xxx BASED(ppp);または ( DECLARE xxx BASED;) なしで宣言できます。ここで、xxx は基底付き変数で、要素変数、構造体、または配列のいずれかであり、ppp はデフォルト ポインタです)。このような変数は、明示的なポインタ参照なしでアドレス指定できます ( xxx=1;、またはデフォルト ロケータ (ppp) またはその他のポインタへの明示的な参照を使用してアドレス指定できます ( qqq->xxx=1;)。

ポインタ演算は PL/I 標準の一部ではありませんが、多くのコンパイラでは という形式の式が許可されていますptr = ptr±expression。IBM PL/I には、演算を実行する組み込み関数もありますPTRADD。ポインタ演算は常にバイト単位で実行されます。

IBM Enterprise PL/I コンパイラーには、 と呼ばれる新しい形式の型付きポインターがありますHANDLE。

Dプログラミング言語は C と C++ の派生であり、C ポインターと C 型キャストを完全にサポートします。

Eiffelオブジェクト指向言語は、ポインタ演算を使用せずに値と参照のセマンティクスを採用しています。ただし、ポインタ クラスは提供されています。ポインタ クラスは、ポインタ演算、型キャスト、明示的なメモリ管理、非 Eiffel ソフトウェアとのインターフェイスなどの機能を提供します。

Fortran-90 では、厳密に型指定されたポインター機能が導入されました。Fortran ポインターには、単純なメモリ アドレス以上のものが含まれています。また、配列次元の下限と上限、ストライド (任意の配列セクションをサポートする場合など)、およびその他のメタデータもカプセル化されます。関連付け演算子は、属性を持つ変数に=>を関連付けるために使用されます。Fortran-90ステートメントは、ポインターをメモリ ブロックに関連付ける場合にも使用できます。たとえば、次のコードは、リンク リスト構造を定義および作成するために使用できます。 POINTERTARGETALLOCATE

型real_list_t 
real :: sample_data ( 100 )型( real_list_t )、ポインタ:: next => null ()終了型    
         


型( real_list_t )、ターゲット:: my_real_list型( real_list_t )、ポインタ:: real_list_temp    
    

real_list_temp => my_real_list do   read ( 1 , iostat = ioerr ) real_list_temp % sample_data if ( ioerr /= 0 ) exit   allocate ( real_list_temp % next ) real_list_temp => real_list_temp % next end do  

  
      
 
    

Fortran-2003 では、プロシージャ ポインタのサポートが追加されました。また、 C 相互運用性機能の一部として、Fortran-2003 では、C スタイルのポインタを Fortran ポインタに変換したり、その逆の変換を行う組み込み関数がサポートされています。

Go にはポインタがあります。その宣言構文は C と同等ですが、逆の書き方で、型で終わります。C とは異なり、Go にはガベージ コレクションがあり、ポインタ演算は許可されません。C++ のような参照型は存在しません。マップやチャネルなどの一部の組み込み型はボックス化されており (つまり、内部的には変更可能な構造体へのポインタです)、make関数を使用して初期化されます。ポインタと非ポインタの間で統一された構文へのアプローチとして、矢印 ( ->) 演算子は削除されました。ポインタのドット演算子は、参照解除されたオブジェクトのフィールドまたはメソッドを参照します。ただし、これは 1 レベルの間接参照でのみ機能します。

Javaにはポインタの明示的な表現はありません。代わりに、オブジェクトや配列などのより複雑なデータ構造は参照を使用して実装されます。この言語は明示的なポインタ操作演算子を提供していません。ただし、コードが null 参照 (null ポインタ) を参照解除しようとすることは可能ですが、その結果、実行時例外がスローされます。参照されていないメモリオブジェクトによって占有されている領域は、実行時にガベージコレクションによって自動的に回復されます。 ^[20]

VARポインタは、プロシージャ呼び出しのパラメータと同様に、Pascal とほぼ同じように実装されています。Modula -2 はPascal よりもさらに厳密に型指定されており、型システムから逃れる方法が少なくなっています。Modula-2 のバリアントの一部 ( Modula-3など) には、ガベージ コレクションが含まれています。

Modula-2 と同様に、ポインターが利用可能です。型システムを回避する方法は依然として少ないため、Oberonとその派生版は、ポインターに関しては Modula-2 やその派生版よりも安全です。Modula -3と同様に、ガベージ コレクションは言語仕様の一部です。

ポインターを備えた多くの言語とは異なり、標準ISO Pascal では、ポインターは動的に作成された匿名変数のみを参照でき、標準の静的変数またはローカル変数を参照することはできません。 ^[21]ポインター演算はありません。ポインターには関連付けられた型も必要であり、1 つの型へのポインターは別の型へのポインターと互換性がありません (たとえば、char へのポインターは整数へのポインターと互換性がありません)。これにより、他のポインター実装、特にPL/IまたはCで使用される実装に固有の型セキュリティの問題が排除されます。また、ダングリング ポインターによって引き起こされるリスクもいくつか排除されますが、標準の手順 ( Cにあるライブラリ関数disposeと同じ効果があります)を使用して参照されたスペースを動的に解放する機能は、ダングリング ポインターのリスクが完全に排除されたわけではないことを意味します。^[22]free