Berapa banyak level pointer yang bisa kita miliki?

Berapa banyak pointer ( *) yang diizinkan dalam satu variabel?

Mari kita perhatikan contoh berikut ini.

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

Demikian pula yang bisa kita miliki

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

dan seterusnya.

Sebagai contoh,

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

The Cmenspesifikasikan standar batas bawah:

5.2.4.1 Batas terjemahan

276 Implementasi harus dapat menerjemahkan dan menjalankan setidaknya satu program yang mengandung setidaknya satu instance dari setiap batasan berikut: [...]

279 - 12 pointer, array, dan deklarator fungsi (dalam kombinasi apa pun) yang memodifikasi tipe aritmatika, struktur, gabungan, atau batal dalam deklarasi

Batas atas adalah implementasi khusus.

Sebenarnya, program C umumnya menggunakan tipuan pointer tak terbatas. Satu atau dua level statis adalah umum. Tiga tipuan jarang terjadi. Tetapi tak terbatas sangat umum.

Peniruan penunjuk tak terbatas dicapai dengan bantuan struct, tentu saja, tidak dengan deklarator langsung, yang tidak mungkin dilakukan. Dan sebuah struct diperlukan agar Anda dapat memasukkan data lain dalam struktur ini pada level yang berbeda di mana ini dapat berakhir.

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

sekarang kamu bisa punya list->next->next->next->...->next. Ini benar-benar hanya beberapa indirections pointer: *(*(..(*(*(*list).next).next).next...).next).next. Dan pada .nextdasarnya adalah noop ketika itu adalah anggota pertama dari struktur, jadi kita bisa membayangkan ini sebagai ***..***ptr.

Sebenarnya tidak ada batasan untuk ini karena tautan dapat dilalui dengan loop daripada ekspresi raksasa seperti ini, dan terlebih lagi, struktur dapat dengan mudah dibuat melingkar.

Dengan demikian, dengan kata lain, daftar tertaut dapat menjadi contoh utama untuk menambahkan tingkat tipuan lain untuk menyelesaikan masalah, karena Anda melakukannya secara dinamis dengan setiap operasi push. :)

Secara teoretis:

Anda dapat memiliki banyak tingkat tipuan yang Anda inginkan.

Praktis:

Tentu saja, tidak ada yang mengkonsumsi memori yang tidak dapat ditentukan, akan ada keterbatasan karena sumber daya yang tersedia di lingkungan host. Jadi praktis ada batas maksimum untuk apa suatu implementasi dapat mendukung dan implementasi harus mendokumentasikannya dengan tepat. Jadi dalam semua artefak tersebut, standar tidak menentukan batas maksimum, tetapi menentukan batas bawah.

Inilah rujukannya:

C99 Standar 5.2.4.1 Batas terjemahan:

- 12 pointer, array, dan deklarator fungsi (dalam kombinasi apa pun) yang memodifikasi tipe aritmatika, struktur, gabungan, atau batal dalam deklarasi.

Ini menentukan batas bawah yang harus didukung oleh setiap implementasi . Perhatikan bahwa dalam catatan kaki standar lebih lanjut mengatakan:

18) Implementasi harus menghindari memaksakan batas terjemahan tetap bila memungkinkan.

Seperti yang dikatakan orang, tidak ada batasan "dalam teori". Namun, karena ketertarikan saya menjalankan ini dengan g ++ 4.1.2, dan bekerja dengan ukuran hingga 20.000. Kompilasi cukup lambat, jadi saya tidak mencoba lebih tinggi. Jadi saya kira g ++ juga tidak menetapkan batas apa pun. (Coba pengaturan size = 10dan cari di ptr.cpp jika tidak segera jelas.)

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;
}

Kedengarannya menyenangkan untuk diperiksa.

• Visual Studio 2010 (pada Windows 7), Anda dapat memiliki level 1011 sebelum mendapatkan kesalahan ini:

  kesalahan fatal C1026: stack overflow parser, program terlalu kompleks

• gcc (Ubuntu), 100k + *tanpa crash! Saya kira perangkat keras adalah batasannya di sini.

(diuji hanya dengan deklarasi variabel)

Tidak ada batasan, periksa contoh di sini .

Jawabannya tergantung pada apa yang Anda maksud dengan "level pointers." Jika Anda maksudkan, "Berapa tingkat tipuan yang dapat Anda miliki dalam satu deklarasi?" jawabannya adalah "Setidaknya 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 */

Jika Anda maksudkan, "Berapa banyak level pointer yang dapat Anda gunakan sebelum program sulit dibaca," itu masalah selera, tetapi ada batasnya. Memiliki dua tingkat tipuan (pointer ke pointer ke sesuatu) adalah umum. Lebih dari itu semakin sulit untuk dipikirkan dengan mudah; jangan lakukan itu kecuali jika alternatifnya akan lebih buruk.

Jika Anda maksudkan "Berapa banyak tingkat tipuan pointer yang dapat Anda miliki saat runtime," tidak ada batasan. Titik ini sangat penting untuk daftar bundar, di mana setiap titik menunjuk ke yang berikutnya. Program Anda dapat mengikuti petunjuk selamanya.

Ini sebenarnya lebih lucu dengan pointer ke fungsi.

#include <cstdio>

typedef void (*FuncType)();

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

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

Seperti diilustrasikan di sini, ini memberi:

Halo Dunia!
Halo Dunia!
Halo Dunia!

Dan itu tidak melibatkan overhead runtime, jadi Anda mungkin dapat menumpuknya sebanyak yang Anda inginkan ... sampai kompiler Anda tersedak file.

Tidak ada batasan . Pointer adalah sepotong memori yang isinya adalah alamat.
Seperti yang Anda katakan

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

Penunjuk ke penunjuk juga merupakan variabel yang berisi alamat penunjuk lain.

int **q = &p;

Berikut qini adalah pointer ke pointer memegang alamat pyang sudah memegang alamat a.

Tidak ada yang khusus tentang pointer ke pointer.
Jadi tidak ada batasan pada rantai ponitor yang memegang alamat pointer lain.
yaitu.

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

Diperbolehkan.

Setiap pengembang C ++ seharusnya sudah mendengar tentang programmer Bintang Tiga yang terkenal

Dan tampaknya benar-benar ada "penghalang penunjuk" ajaib yang harus disamarkan

Kutipan dari C2:

Pemrogram Tiga Bintang

Sistem penilaian untuk programmer-C. Semakin banyak pointer tidak langsung Anda (yaitu semakin "*" sebelum variabel Anda), semakin tinggi reputasi Anda. Programer C-bintang tidak ada secara virtual, karena hampir semua program non-sepele memerlukan pointer. Sebagian besar adalah programmer satu bintang. Di masa lalu (yah, saya masih muda, jadi ini terlihat seperti masa lalu bagi saya setidaknya), orang kadang-kadang akan menemukan sepotong kode yang dilakukan oleh seorang programmer bintang tiga dan menggigil dengan kagum. Beberapa orang bahkan mengklaim telah melihat kode bintang tiga dengan fungsi pointer yang terlibat, pada lebih dari satu tingkat tipuan. Terdengar senyata UFO bagiku.

Perhatikan bahwa ada dua pertanyaan yang mungkin di sini: berapa banyak tingkat tipuan pointer yang dapat kita capai dalam tipe C, dan berapa banyak tingkat tipuan pointer yang dapat kita masukkan ke dalam satu deklarator tunggal.

Standar C memungkinkan maksimum untuk dikenakan pada yang pertama (dan memberikan nilai minimum untuk itu). Tapi itu bisa dielakkan melalui beberapa deklarasi typedef:

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

Jadi pada akhirnya, ini adalah masalah implementasi yang terhubung dengan gagasan tentang seberapa besar / kompleks sebuah program C dapat dibuat sebelum ditolak, yang merupakan kompiler yang sangat spesifik.

Saya ingin menunjukkan bahwa memproduksi suatu tipe dengan jumlah * yang sewenang-wenang adalah sesuatu yang dapat terjadi dengan metaprogramming template. Saya lupa persis apa yang saya lakukan, tetapi disarankan agar saya dapat menghasilkan tipe berbeda baru yang memiliki beberapa jenis meta manuver di antara mereka dengan menggunakan tipe T * rekursif .

Templat Metaprogramming adalah keturunan yang lambat menuju kegilaan, jadi tidak perlu membuat alasan ketika membuat suatu tipe dengan beberapa ribu level tipuan. Ini hanya cara praktis untuk memetakan bilangan bulat kacang polong, misalnya, ke ekspansi templat sebagai bahasa fungsional.

Peraturan 17.5 dari standar MISRA C 2004 melarang lebih dari 2 level tipuan pointer.

Tidak ada yang namanya batas nyata tetapi ada batas. Semua pointer adalah variabel yang biasanya disimpan dalam stack, bukan heap . Tumpukan biasanya kecil (dimungkinkan untuk mengubah ukurannya selama beberapa penautan). Jadi katakanlah Anda memiliki tumpukan 4MB, apa ukuran yang cukup normal. Dan katakanlah kita memiliki pointer yang berukuran 4 byte (ukuran pointer tidak sama tergantung pada pengaturan arsitektur, target dan kompiler).

Pada kasus ini 4 MB / 4 b = 1024 jumlah maksimum yang memungkinkan adalah 1048576, tetapi kita tidak boleh mengabaikan fakta bahwa beberapa hal lain ada di tumpukan.

Namun beberapa kompiler mungkin memiliki jumlah maksimum rantai penunjuk, tetapi batasnya adalah ukuran tumpukan. Jadi, jika Anda meningkatkan ukuran tumpukan selama menghubungkan dengan infinity dan memiliki mesin dengan memori infinity yang menjalankan OS yang menangani memori itu sehingga Anda akan memiliki rantai penunjuk yang tidak terbatas.

Jika Anda menggunakan int *ptr = new int;dan meletakkan pointer Anda ke tumpukan, itu tidak batas cara biasa akan menjadi ukuran tumpukan, bukan tumpukan.

EDIT Sadarilah itu infinity / 2 = infinity. Jika mesin memiliki lebih banyak memori maka ukuran pointer bertambah. Jadi jika memori tak terhingga dan ukuran penunjuk adalah tak terhingga, maka itu adalah berita buruk ... :)

Itu tergantung pada tempat Anda menyimpan pointer. Jika mereka berada di tumpukan Anda memiliki batas yang cukup rendah . Jika Anda menyimpannya di tumpukan, batas Anda jauh lebih tinggi.

Lihatlah program ini:

#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;
}

Ini menciptakan pointer 1M dan pada titik menunjukkan ke apa mudah untuk melihat apa rantai pergi ke variabel pertama number.

BTW. Ini menggunakan 92KRAM jadi bayangkan seberapa dalam Anda bisa melangkah.