ポインタにはいくつのレベルがありますか？

ポインタの数（*1つの変数でいくつの）を使用できますか？

次の例を考えてみましょう。

int a = 10;
int *p = &a;

同様に、

int **q = &p;
int ***r = &q;

等々。

例えば、

int ****************zz;

C標準の指定下限：

5.2.4.1翻訳の制限

276実装は、次の制限のすべての少なくとも1つのインスタンスを含む少なくとも1つのプログラムを変換および実行できる必要があります：[...]

279 —宣言の算術型、構造体、共用体、またはvoid型を変更する12個のポインター、配列、および関数宣言子（任意の組み合わせ）

上限は実装固有です。

実際、Cプログラムは通常、無限ポインターの間接参照を使用します。1つまたは2つの静的レベルが一般的です。三重の間接参照はまれです。しかし、無限は非常に一般的です。

無限ポインターの間接指定は、構造体を使用して実現されます。もちろん、直接宣言子を使用するのではありません。これは不可能です。また、構造体が必要になる可能性があるさまざまなレベルでこの構造体に他のデータを含めることができるように、構造体が必要です。

struct list { struct list *next; ... };

今、あなたは持つことができますlist->next->next->next->...->next。これは実際には単なる複数のポインタの間接化です*(*(..(*(*(*list).next).next).next...).next).next。そして、.next構造体の最初のメンバーの場合、これは基本的に何もしないので、と想像でき***..***ptrます。

リンクはこのような巨大な式ではなくループでトラバースできるため、これに本当に制限はありません。さらに、構造を簡単に円形にすることができます。

したがって、言い換えると、リンクされたリストは、すべてのプッシュ操作で動的に実行しているため、問題を解決するために別のレベルの間接参照を追加する究極の例になる可能性があります。:)

理論的には：

間接参照のレベルはいくつでも持つことができます。

実際には：

もちろん、メモリを消費するものは不定ではありません。ホスト環境で利用可能なリソースにより制限があります。したがって、実際には実装がサポートできるものには上限があり、実装はそれを適切に文書化する必要があります。したがって、そのようなすべてのアーティファクトでは、標準は最大制限を指定していませんが、下限を指定しています。

ここに参照があります：

C99標準5.2.4.1翻訳制限：

—宣言内の算術型、構造体、共用体、またはvoid型を変更する12個のポインター、配列、および関数宣言子（任意の組み合わせ）。

これは、すべての実装がサポートする必要のある下限を指定します。脚注で、標準はさらに次のように述べていることに注意してください：

18）実装では、可能な限り、固定された翻訳制限を課さないようにする必要があります。

人々が言っ​​たように、「理論上」制限はありません。しかし、興味があるため、私はこれをg ++ 4.1.2で実行し、最大20,000のサイズで動作しました。コンパイルはかなり遅いので、もっと高くはしませんでした。したがって、g ++も制限を課さないと思います。（size = 10すぐにわからない場合は、ptr.cppを設定して調べてみてください。）

g++ create.cpp -o create ; ./create > ptr.cpp ; g++ ptr.cpp -o ptr ; ./ptr

create.cpp

#include <iostream>

int main()
{
    const int size = 200;
    std::cout << "#include <iostream>\n\n";
    std::cout << "int main()\n{\n";
    std::cout << "    int i0 = " << size << ";";
    for (int i = 1; i < size; ++i)
    {
        std::cout << "    int ";
        for (int j = 0; j < i; ++j) std::cout << "*";
        std::cout << " i" << i << " = &i" << i-1 << ";\n";
    }
    std::cout << "    std::cout << ";
    for (int i = 1; i < size; ++i) std::cout << "*";
    std::cout << "i" << size-1 << " << \"\\n\";\n";
    std::cout << "    return 0;\n}\n";
    return 0;
}

チェックするのは楽しいですね。

• Visual Studio 2010（Windows 7）では、このエラーが発生する前に1011レベルが存在する可能性があります。

  致命的なエラーC1026：パーサースタックオーバーフロー、プログラムが複雑すぎます

• gcc（Ubuntu）、*クラッシュなしの100k + ！ここではハードウェアが限界だと思います。

（変数宣言のみでテスト済み）

制限はありません。ここで例を確認してください。

答えは、「ポインタのレベル」が何を意味するかによって異なります。「1回の宣言で間接参照のレベルをいくつ持つことができますか？」答えは「少なくとも12」です。

int i = 0;

int *ip01 = & i;

int **ip02 = & ip01;

int ***ip03 = & ip02;

int ****ip04 = & ip03;

int *****ip05 = & ip04;

int ******ip06 = & ip05;

int *******ip07 = & ip06;

int ********ip08 = & ip07;

int *********ip09 = & ip08;

int **********ip10 = & ip09;

int ***********ip11 = & ip10;

int ************ip12 = & ip11;

************ip12 = 1; /* i = 1 */

「プログラムが読みにくくなるまでに使用できるポインタのレベル数」というのは好みの問題ですが、制限があります。2レベルの間接指定（何かへのポインターへのポインター）が一般的です。それ以上だと、簡単に考えるのが少し難しくなります。代替案がさらに悪化しない限り、それを行わないでください。

「実行時にポインタインダイレクションのレベルをいくつ持つことができるか」という意味であれば、制限はありません。この点は、各ノードが次を指す循環リストの場合に特に重要です。プログラムはポインタを永久にたどることができます。

関数へのポインタを使用すると、さらにおもしろくなります。

#include <cstdio>

typedef void (*FuncType)();

static void Print() { std::printf("%s", "Hello, World!\n"); }

int main() {
  FuncType const ft = &Print;
  ft();
  (*ft)();
  (**ft)();
  /* ... */
}

ここに示されているように、これは次のようになります。

こんにちは世界！
こんにちは世界！
こんにちは世界！

また、ランタイムのオーバーヘッドは発生しないため、コンパイラがファイルを窒息させるまで、必要なだけスタックすることができます。

制限はありません。ポインタは、内容がアドレスであるメモリのチャンクです。
あなたが言ったように

int a = 10;
int *p = &a;

ポインターへのポインターは、別のポインターのアドレスを含む変数でもあります。

int **q = &p;

ここでqのアドレス保持ポインタへのポインタでp、すでにのアドレスを保持しているがa。

ポインターへのポインターについては、特別なことは何もありません。
したがって、別のポインターのアドレスを保持しているponiterのチェーンに制限はありません。
すなわち。

 int **************************************************************************z;

許可されている。

すべてのC ++開発者は、（有名な）有名な3つ星プログラマについて聞いたことがあるはずです

本当にカモフラージュしなければならない魔法の「ポインターバリア」があるようです

C2からの引用：

3つ星プログラマ

Cプログラマのための評価システム。ポインタが間接的であるほど（つまり、変数の前の「*」が多いほど）、評判は高くなります。スターのないCプログラマーは、事実上すべての重要なプログラムがポインターの使用を必要とするため、事実上存在しません。ほとんどが1つ星のプログラマーです。昔（そうですね、私は若いので、少なくとも私には昔のように見えます）、3つ星のプログラマーによって行われたコードの一部を時々見つけ、畏敬の念を抱きました。一部の人々は、複数レベルの間接参照で、関数ポインターが含まれる3つ星のコードを見たとさえ主張しました。私にはUFOと同じくらいリアルに聞こえました。

ここでは2つの可能な質問があることに注意してください。C型で達成できるポインター間接参照のレベル数と、単一の宣言子に詰め込むことができるポインター間接参照のレベル数です。

C規格では、前者に最大値を課すことができます（その最小値を指定します）。しかし、それは複数のtypedef宣言によって回避できます。

typedef int *type0;
typedef type0 *type1;
typedef type1 *type2; /* etc */

結局のところ、これは拒否される前にCプログラムをどのくらい大きく/複雑にできるかという考えに関連する実装の問題であり、これは非常にコンパイラー固有です。

任意の数の*で型を作成することは、テンプレートのメタプログラミングで発生する可能性があることを指摘しておきます。私は正確に何をしていたのか忘れてしまいましたが、再帰的な T *タイプを使用することで、ある種のメタ操作を行う新しい特殊タイプを作成できることが示唆されました。

テンプレートメタプログラミングは狂気へのゆっくりとした降下なので、数千レベルの間接参照を持つ型を生成するときに言い訳をする必要はありません。これは、たとえばペアノ整数を関数型言語としてのテンプレート展開にマッピングするための便利な方法です。

2004年MISRA C規格のルール17.5は、2レベルを超えるポインターの間接参照を禁止しています。

本当の限界のようなものはありませんが、限界は存在します。すべてのポインタは、通常ヒープではなくスタックに格納される変数です。スタックは通常小さい（リンク中にサイズを変更することが可能）。それでは、4MBのスタックがあるとしましょう。これはかなり通常のサイズです。そして、4バイトのサイズのポインターがあるとします（ポインターのサイズは、アーキテクチャー、ターゲット、およびコンパイラーの設定によって異なります）。

この場合4 MB / 4 b = 1024、可能な最大数は1048576ですが、他のものがスタックにあるという事実を無視してはなりません。

ただし、一部のコンパイラーはポインター・チェーンの最大数を持っている場合がありますが、制限はスタック・サイズです。したがって、無限大とのリンク中にスタックサイズを増やし、そのメモリを処理するOSを実行する無限メモリを備えたマシンを使用すると、無制限のポインタチェーンが得られます。

int *ptr = new int;ポインターを使用してヒープ内に配置する場合、これは通常の方法ではなく、スタックではなくヒープサイズが制限されます。

編集ただそれを理解してくださいinfinity / 2 = infinity。マシンのメモリが多い場合は、ポインタサイズが増加します。したがって、メモリが無限大でポインタのサイズが無限大の場合、それは悪いニュースです... :)

ポインタを格納する場所によって異なります。それらがスタックにある場合、あなたはかなり低い制限を持っています。ヒープに保存すると、制限ははるかに高くなります。

このプログラムを見てください：

#include <iostream>

const int CBlockSize = 1048576;

int main() 
{
    int number = 0;
    int** ptr = new int*[CBlockSize];

    ptr[0] = &number;

    for (int i = 1; i < CBlockSize; ++i)
        ptr[i] = reinterpret_cast<int *> (&ptr[i - 1]);

    for (int i = CBlockSize-1; i >= 0; --i)
        std::cout << i << " " << (int)ptr[i] << "->" << *ptr[i] << std::endl;

    return 0;
}

これは1Mのポインタを作成し、最初の変数にチェーンが行くのがわかりやすいポイントを示していますnumber。

ところで。それは92KRAMを使用するので、どれだけ深く行くことができるか想像してみてください。