Chúng ta có thể có bao nhiêu cấp con trỏ?

Có bao nhiêu con trỏ ( *) được phép trong một biến?

Hãy xem xét ví dụ sau đây.

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

Tương tự như vậy chúng ta có thể có

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

và như thế.

Ví dụ,

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

Các Cquy định cụ thể tiêu chuẩn giới hạn dưới:

5.2.4.1 Giới hạn dịch

276 Việc triển khai sẽ có thể dịch và thực thi ít nhất một chương trình có ít nhất một phiên bản của mỗi một trong các giới hạn sau: [...]

279 - 12 công cụ khai báo con trỏ, mảng và hàm (trong mọi kết hợp) sửa đổi loại số học, cấu trúc, liên kết hoặc khoảng trống trong một khai báo

Giới hạn trên là thực hiện cụ thể.

Trên thực tế, các chương trình C thường sử dụng cảm ứng con trỏ vô hạn. Một hoặc hai cấp độ tĩnh là phổ biến. Ba lần gián tiếp là hiếm. Nhưng vô hạn là rất phổ biến.

Tất nhiên, việc xác định con trỏ vô hạn đạt được với sự trợ giúp của một cấu trúc, tất nhiên, không phải với một công cụ khai báo trực tiếp, điều này là không thể. Và một cấu trúc là cần thiết để bạn có thể bao gồm các dữ liệu khác trong cấu trúc này ở các cấp độ khác nhau nơi điều này có thể chấm dứt.

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

bây giờ bạn có thể có list->next->next->next->...->next. Đây thực sự chỉ là nhiều chỉ dẫn con trỏ : *(*(..(*(*(*list).next).next).next...).next).next. Và .nextvề cơ bản là noop khi nó là thành viên đầu tiên của cấu trúc, vì vậy chúng ta có thể tưởng tượng điều này là ***..***ptr.

Thực sự không có giới hạn về điều này bởi vì các liên kết có thể được duyệt qua một vòng lặp chứ không phải là một biểu thức khổng lồ như thế này, và hơn nữa, cấu trúc có thể dễ dàng được tạo thành hình tròn.

Do đó, nói cách khác, các danh sách được liên kết có thể là ví dụ cuối cùng về việc thêm một mức độ gián tiếp khác để giải quyết vấn đề, vì bạn đang thực hiện nó một cách linh hoạt với mỗi thao tác đẩy. :)

Về mặt lý thuyết:

Bạn có thể có nhiều cấp độ như bạn muốn.

Thực tế:

Tất nhiên, không có gì tiêu thụ bộ nhớ có thể là vô thời hạn, sẽ có những hạn chế do tài nguyên có sẵn trên môi trường máy chủ. Vì vậy, trên thực tế có giới hạn tối đa đối với những gì một triển khai có thể hỗ trợ và việc thực hiện sẽ ghi lại nó một cách thích hợp. Vì vậy, trong tất cả các tạo tác như vậy, tiêu chuẩn không chỉ định giới hạn tối đa, nhưng nó chỉ định các giới hạn thấp hơn.

Đây là tài liệu tham khảo:

Tiêu chuẩn C99 5.2.4.1 Giới hạn dịch:

- 12 công cụ khai báo con trỏ, mảng và hàm (trong mọi kết hợp) sửa đổi loại số học, cấu trúc, liên kết hoặc khoảng trống trong một khai báo.

Điều này xác định giới hạn thấp hơn mà mọi thực hiện phải hỗ trợ. Lưu ý rằng trong phần chân trang, tiêu chuẩn tiếp tục nói:

18) Việc triển khai nên tránh áp đặt giới hạn dịch cố định bất cứ khi nào có thể.

Như mọi người đã nói, không có giới hạn "về lý thuyết". Tuy nhiên, vì hứng thú, tôi đã chạy nó với g ++ 4.1.2 và nó hoạt động với kích thước lên tới 20.000. Biên dịch khá chậm, vì vậy tôi đã không thử cao hơn. Vì vậy, tôi đoán g ++ cũng không áp đặt bất kỳ giới hạn nào. (Hãy thử cài đặt size = 10và tìm kiếm trong ptr.cpp nếu nó không rõ ràng ngay lập tức.)

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

tạo.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;
}

Âm thanh thú vị để kiểm tra.

• Visual Studio 2010 (trên Windows 7), bạn có thể có các cấp 1011 trước khi gặp lỗi này:

  lỗi nghiêm trọng C1026: lỗi trình phân tích cú pháp tràn, chương trình quá phức tạp

• gcc (Ubuntu), 100k + *mà không gặp sự cố! Tôi đoán phần cứng là giới hạn ở đây.

(được thử nghiệm chỉ với một khai báo biến)

Không có giới hạn, kiểm tra ví dụ ở đây .

Câu trả lời phụ thuộc vào ý của bạn về "mức độ con trỏ". Nếu bạn có nghĩa là "Bạn có thể có bao nhiêu mức độ gián tiếp trong một khai báo?" câu trả lời là "Ít nhất là 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 */

Nếu bạn có nghĩa là "Bạn có thể sử dụng bao nhiêu cấp con trỏ trước khi chương trình khó đọc", thì đó là vấn đề của hương vị, nhưng có một giới hạn. Có hai cấp độ gián tiếp (một con trỏ đến một con trỏ tới một cái gì đó) là phổ biến. Bất kỳ nhiều hơn thế sẽ khó khăn hơn một chút để suy nghĩ về dễ dàng; đừng làm điều đó trừ khi sự thay thế sẽ tồi tệ hơn

Nếu bạn có nghĩa là "Bạn có thể có bao nhiêu cấp độ của con trỏ trong thời gian chạy" thì không có giới hạn. Điểm này đặc biệt quan trọng đối với danh sách vòng tròn, trong đó mỗi nút trỏ đến điểm tiếp theo. Chương trình của bạn có thể theo con trỏ mãi mãi.

Nó thực sự thậm chí còn buồn cười hơn với con trỏ đến các chức năng.

#include <cstdio>

typedef void (*FuncType)();

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

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

Như được minh họa ở đây, điều này mang lại:

Chào thế giới!
Chào thế giới!
Chào thế giới!

Và nó không liên quan đến bất kỳ chi phí thời gian chạy nào, vì vậy bạn có thể xếp chúng nhiều như bạn muốn ... cho đến khi trình biên dịch của bạn cuộn lại trên tệp.

Không có giới hạn . Một con trỏ là một đoạn bộ nhớ có nội dung là một địa chỉ.
Như bạn đã nói

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

Một con trỏ tới một con trỏ cũng là một biến chứa địa chỉ của một con trỏ khác.

int **q = &p;

Đây qlà con trỏ tới con trỏ đang giữ địa chỉ pđã giữ địa chỉ của a.

Không có gì đặc biệt về một con trỏ đến một con trỏ.
Vì vậy, không có giới hạn đối với chuỗi poniter đang giữ địa chỉ của một con trỏ khác.
I E.

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

được cho phép.

Mọi nhà phát triển C ++ nên nghe về lập trình viên ba sao nổi tiếng (trong)

Và thực sự có một số "rào cản con trỏ" ma thuật phải được ngụy trang

Trích dẫn từ C2:

Lập trình viên ba sao

Một hệ thống đánh giá cho các lập trình viên C. Con trỏ của bạn càng gián tiếp (tức là càng nhiều "*" trước các biến của bạn), danh tiếng của bạn sẽ càng cao. Các lập trình viên C không có ngôi sao hầu như không tồn tại, vì hầu như tất cả các chương trình không tầm thường đều yêu cầu sử dụng con trỏ. Hầu hết là các lập trình viên một sao. Vào thời xưa (tốt, tôi còn trẻ, vì vậy ít nhất chúng trông giống như thời xưa), thỉnh thoảng người ta sẽ tìm thấy một đoạn mã được thực hiện bởi một lập trình viên ba sao và rùng mình sợ hãi. Một số người thậm chí tuyên bố họ đã nhìn thấy mã ba sao với các con trỏ hàm liên quan, trên nhiều cấp độ của sự gián tiếp. Nghe có vẻ như thật với UFO đối với tôi.

Lưu ý rằng có hai câu hỏi có thể có ở đây: chúng ta có thể đạt được bao nhiêu cấp độ của con trỏ trong một loại C và bao nhiêu cấp độ của con trỏ mà chúng ta có thể đưa vào một bộ khai báo.

Tiêu chuẩn C cho phép áp dụng tối đa cho cái trước (và đưa ra giá trị tối thiểu cho điều đó). Nhưng điều đó có thể được phá vỡ thông qua nhiều khai báo typedef:

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

Vì vậy, cuối cùng, đây là một vấn đề triển khai liên quan đến ý tưởng về việc một chương trình C lớn / phức tạp có thể được thực hiện như thế nào trước khi nó bị từ chối, rất cụ thể về trình biên dịch.

Tôi muốn chỉ ra rằng việc tạo ra một loại với số lượng * tùy ý là điều có thể xảy ra với siêu lập trình mẫu. Tôi quên chính xác những gì tôi đang làm, nhưng có ý kiến ​​cho rằng tôi có thể tạo ra các loại khác biệt mới có một số loại meta cơ động giữa chúng bằng cách sử dụng đệ quy T * .

Lập trình siêu mẫu là một sự chậm chạp đến điên rồ, vì vậy không cần thiết phải đưa ra lời bào chữa khi tạo ra một loại với hàng ngàn mức độ gián tiếp. Đó chỉ là một cách thuận tiện để ánh xạ các số nguyên đậu phộng, ví dụ, lên mở rộng mẫu như một ngôn ngữ chức năng.

Quy tắc 17,5 của tiêu chuẩn MISRA C năm 2004 nghiêm cấm hơn 2 cấp độ của con trỏ.

Không có một thứ như giới hạn thực sự nhưng giới hạn tồn tại. Tất cả các con trỏ là các biến thường được lưu trữ trong stack không heap . Ngăn xếp thường nhỏ (có thể thay đổi kích thước của nó trong một số liên kết). Vì vậy, giả sử bạn có stack 4MB, kích thước khá bình thường. Và giả sử chúng ta có con trỏ có kích thước 4 byte (kích thước con trỏ không giống nhau tùy thuộc vào cài đặt kiến ​​trúc, mục tiêu và trình biên dịch).

Trong trường hợp này, 4 MB / 4 b = 1024số lượng tối đa có thể là 1048576, nhưng chúng ta không nên bỏ qua thực tế là một số nội dung khác đang được xếp chồng lên nhau.

Tuy nhiên, một số trình biên dịch có thể có số chuỗi con trỏ tối đa, nhưng giới hạn là kích thước ngăn xếp. Vì vậy, nếu bạn tăng kích thước ngăn xếp trong quá trình liên kết với vô cực và có máy có bộ nhớ vô cực chạy HĐH xử lý bộ nhớ đó, do đó bạn sẽ có chuỗi con trỏ không giới hạn.

Nếu bạn sử dụng int *ptr = new int;và đặt con trỏ của bạn vào heap, đó không phải là cách giới hạn thông thường sẽ là kích thước heap, không phải stack.

EDIT Chỉ cần nhận ra rằng infinity / 2 = infinity. Nếu máy có nhiều bộ nhớ hơn thì kích thước con trỏ tăng. Vì vậy, nếu bộ nhớ là vô cùng và kích thước của con trỏ là vô cùng, thì đó là tin xấu ... :)

Nó phụ thuộc vào nơi bạn lưu trữ con trỏ. Nếu chúng ở trong ngăn xếp bạn có giới hạn khá thấp . Nếu bạn lưu trữ nó trong đống, bạn giới hạn cao hơn nhiều.

Nhìn vào chương trình này:

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

Nó tạo ra các con trỏ 1M và tại các điểm cho thấy điểm nào dễ nhận thấy chuỗi nào đi đến biến đầu tiên number.

BTW. Nó sử dụng 92KRAM để chỉ cần tưởng tượng bạn có thể đi sâu đến mức nào.