Сколько уровней указателей мы можем иметь?

Сколько указателей ( *) разрешено в одной переменной?

Давайте рассмотрим следующий пример.

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

Точно так же мы можем иметь

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

и так далее.

Например,

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

В Cстандарт устанавливает нижний предел:

5.2.4.1 Пределы перевода

276 Реализация должна иметь возможность переводить и выполнять по крайней мере одну программу, которая содержит по крайней мере один экземпляр каждого из следующих ограничений: [...]

279 - 12 указателей, массивов и функций объявления (в любых комбинациях), изменяющих арифметический, структурный, объединенный или пустой тип в объявлении

Верхний предел зависит от реализации.

На самом деле, программы на C обычно используют бесконечное указание на указатель. Один или два статических уровня являются общими. Тройная косвенность редка. Но бесконечность очень распространена.

Бесконечная косвенность указателя достигается с помощью структуры, конечно, а не с помощью прямого декларатора, что было бы невозможно. И структура необходима для того, чтобы вы могли включить другие данные в эту структуру на разных уровнях, где это может закончиться.

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

Теперь вы можете иметь list->next->next->next->...->next. Это действительно просто несколько indirections указатель: *(*(..(*(*(*list).next).next).next...).next).next. И, в .nextсущности, это первый шаг, когда он является первым членом структуры, поэтому мы можем представить это как ***..***ptr.

На самом деле нет никаких ограничений в этом, потому что ссылки можно обходить с помощью цикла, а не гигантского выражения, подобного этому, и, кроме того, структуру можно легко сделать круглой.

Таким образом, другими словами, связанные списки могут быть окончательным примером добавления другого уровня косвенности для решения проблемы, поскольку вы делаете это динамически с каждой операцией push. :)

Теоретически:

Вы можете иметь столько уровней косвенности, сколько захотите.

Практически:

Конечно, ничто из того, что потребляет память, не может быть неопределенным, будут ограничения из-за ресурсов, доступных в среде хоста. Таким образом, практически существует максимальный предел того, что может поддерживать реализация, и реализация должна надлежащим образом это документировать. Таким образом, во всех таких артефактах стандарт не определяет максимальный предел, но он определяет нижние пределы.

Вот ссылка:

Стандарт С99 5.2.4.1 Пределы перевода:

- 12 описателей указателей, массивов и функций (в любых комбинациях), изменяющих арифметику, структуру, объединение или тип void в объявлении.

Это определяет нижний предел, который должна поддерживать каждая реализация . Обратите внимание, что в футоне примечание гласит:

18) Реализации должны по возможности избегать введения фиксированных лимитов перевода.

Как уже говорили люди, нет предела «в теории». Однако из интереса я запустил это с g ++ 4.1.2, и он работал с размером до 20000. Компиляция была довольно медленной, поэтому я не пытался выше. Так что я думаю, что 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), 100к + *без сбоев! Я предполагаю, что аппаратное обеспечение - предел здесь.

(проверено только с объявлением переменной)

Там нет предела, посмотрите пример здесь .

Ответ зависит от того, что вы подразумеваете под «уровнями указателей». Если вы имеете в виду «Сколько уровней косвенности вы можете иметь в одной декларации?» ответ "По крайней мере, 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 */

Если вы имеете в виду «Сколько уровней указателя вы можете использовать, прежде чем программа станет трудной для чтения», это вопрос вкуса, но есть предел. Наличие двух уровней косвенности (указатель на указатель на что-то) является распространенным явлением. Более того, об этом легко подумать; не делайте этого, если альтернатива не будет хуже.

Если вы имеете в виду «Сколько уровней косвенного обращения к указателю вы можете иметь во время выполнения», то здесь нет предела. Этот пункт особенно важен для круговых списков, в которых каждый узел указывает на следующий. Ваша программа может следовать указателям навсегда.

Это даже смешнее с указателем на функции.

#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.

В указателе на указатель нет ничего особенного.
Таким образом, нет никакого ограничения на цепочку понитеров, которые содержат адрес другого указателя.
то есть.

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

позволено.

Каждый разработчик C ++ должен был услышать о (не) известном Трехзвездочном программисте

И действительно, кажется, есть какой-то волшебный «барьер указателя», который нужно замаскировать

Цитата из C2:

Трехзвездочный Программист

Система рейтинга для C-программистов. Чем более косвенными являются ваши указатели (т.е. чем больше «*» перед вашими переменными), тем выше будет ваша репутация. Си-программистов без звезд практически не существует, так как практически все нетривиальные программы требуют использования указателей. Большинство из них - программисты одной звезды. В старые времена (ну, я молодой, так что, по крайней мере, для меня это похоже на старые времена), иногда можно было бы найти кусок кода, сделанный трехзвездным программистом, и дрожать от страха. Некоторые люди даже утверждали, что видели трехзвездочный код с задействованными указателями на более чем один уровень косвенности. Для меня это звучало так же реально, как НЛО.

Обратите внимание, что здесь есть два возможных вопроса: сколько уровней косвенности указателей мы можем достичь в типе C, и сколько уровней косвенности указателей мы можем поместить в один декларатор.

Стандарт C позволяет наложить максимум на первый (и дает минимальное значение для этого). Но это можно обойти с помощью нескольких объявлений typedef:

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

В конечном счете, это проблема реализации, связанная с представлением о том, насколько большой / сложной может быть C-программа, прежде чем она будет отклонена, что очень сильно зависит от компилятора.

Я хотел бы отметить, что создание типа с произвольным числом * - это то, что может произойти с метапрограммированием шаблона. Я забыл, что именно делал, но мне было предложено создать новые отдельные типы, имеющие мета-маневрирование между ними, используя рекурсивные типы T *.

Шаблон метапрограммирования - это медленное погружение в безумие, поэтому нет необходимости оправдываться при генерации типа с несколькими тысячами уровней косвенности. Это просто удобный способ отобразить целые числа peano, например, на расширение шаблона в качестве функционального языка.

Правило 17.5 стандарта MISRA C 2004 года запрещает более 2 уровней косвенного обращения к указателю.

Нет такой вещи, как реальный лимит, но существует лимит. Все указатели являются переменными, которые обычно хранятся в стеке, а не в куче . Стек, как правило, небольшой (можно изменить его размер во время некоторых ссылок). Допустим, у вас есть стек 4 МБ, что вполне нормально. И скажем, у нас есть указатель размером 4 байта (размеры указателя не совпадают в зависимости от архитектуры, назначения и настроек компилятора).

В этом случае 4 MB / 4 b = 1024максимально возможное максимальное число будет 1048576, но мы не должны игнорировать тот факт, что некоторые другие вещи находятся в стеке.

Однако некоторые компиляторы могут иметь максимальное количество цепочек указателей, но пределом является размер стека. Так что если вы увеличиваете размер стека во время соединения с бесконечностью и имеете машину с бесконечной памятью, на которой работает ОС, которая обрабатывает эту память, то у вас будет неограниченная цепочка указателей.

Если вы используете 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.

КСТАТИ. Он использует 92Kоперативную память, поэтому просто представьте, как глубоко вы можете зайти.