¿Cuántos niveles de punteros podemos tener?

¿Cuántos punteros ( *) están permitidos en una sola variable?

Consideremos el siguiente ejemplo.

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

Del mismo modo podemos tener

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

y así.

Por ejemplo,

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

El Cestándar especifica el límite inferior:

5.2.4.1 Límites de traducción

276 La implementación podrá traducir y ejecutar al menos un programa que contenga al menos una instancia de cada uno de los siguientes límites: [...]

279 - 12 indicadores de puntero, matriz y función (en cualquier combinación) que modifiquen un tipo aritmético, estructura, unión o vacío en una declaración

El límite superior es específico de la implementación.

En realidad, los programas en C suelen utilizar la indirecta de puntero infinito. Uno o dos niveles estáticos son comunes. La triple indirección es rara. Pero infinito es muy común.

La indirección de puntero infinito se logra con la ayuda de una estructura, por supuesto, no con un declarador directo, lo que sería imposible. Y se necesita una estructura para que pueda incluir otros datos en esta estructura en los diferentes niveles donde esto puede terminar.

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

ahora puedes tener list->next->next->next->...->next. Esto es realmente sólo múltiples indirecciones puntero: *(*(..(*(*(*list).next).next).next...).next).next. Y .nextes básicamente un noop cuando es el primer miembro de la estructura, por lo que podemos imaginar esto como ***..***ptr.

Realmente no hay límite para esto porque los enlaces se pueden atravesar con un bucle en lugar de una expresión gigante como esta, y además, la estructura se puede hacer fácilmente circular.

Por lo tanto, en otras palabras, las listas vinculadas pueden ser el mejor ejemplo de agregar otro nivel de indirección para resolver un problema, ya que lo está haciendo dinámicamente con cada operación de inserción. :)

Teóricamente:

Puede tener tantos niveles de indirecciones como desee.

Prácticamente:

Por supuesto, nada que consuma memoria puede ser indefinido, habrá limitaciones debido a los recursos disponibles en el entorno del host. Por lo tanto, prácticamente existe un límite máximo para lo que una implementación puede soportar y la implementación debe documentarlo adecuadamente. Entonces, en todos estos artefactos, el estándar no especifica el límite máximo, pero sí especifica los límites inferiores.

Aquí está la referencia:

Estándar C99 5.2.4.1 Límites de traducción:

- 12 indicadores de puntero, matriz y función (en cualquier combinación) que modifiquen un tipo aritmético, estructura, unión o vacío en una declaración.

Esto especifica el límite inferior que toda implementación debe soportar. Tenga en cuenta que en una nota a pie de página el estándar dice además:

18) Las implementaciones deben evitar imponer límites de traducción fijos siempre que sea posible.

Como la gente ha dicho, no hay límite "en teoría". Sin embargo, por interés, ejecuté esto con g ++ 4.1.2, y funcionó con un tamaño de hasta 20,000. Sin embargo, la compilación fue bastante lenta, así que no intenté más alto. Así que supongo que g ++ tampoco impone ningún límite. (Intente configurar size = 10y buscar en ptr.cpp si no es inmediatamente obvio).

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

Suena divertido comprobarlo.

• Visual Studio 2010 (en Windows 7), puede tener niveles de 1011 antes de recibir este error:

  error fatal C1026: desbordamiento de la pila del analizador, programa demasiado complejo

• gcc (Ubuntu), 100k + *sin un bloqueo! Supongo que el hardware es el límite aquí.

(probado con solo una declaración variable)

No hay límite, consulte el ejemplo aquí .

La respuesta depende de lo que quiere decir con "niveles de punteros". Si quiere decir "¿Cuántos niveles de indirección puede tener en una sola declaración?" la respuesta es "Al menos 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 */

Si quiere decir "cuántos niveles de puntero puede usar antes de que el programa se vuelva difícil de leer", eso es cuestión de gustos, pero hay un límite. Tener dos niveles de indirección (un puntero a un puntero a algo) es común. Más de eso se vuelve un poco más difícil de pensar fácilmente; no lo hagas a menos que la alternativa sea peor.

Si quiere decir "Cuántos niveles de indirección de puntero puede tener en tiempo de ejecución", no hay límite. Este punto es particularmente importante para las listas circulares, en las que cada nodo apunta al siguiente. Su programa puede seguir los punteros para siempre.

En realidad, es aún más divertido con el puntero a las funciones.

#include <cstdio>

typedef void (*FuncType)();

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

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

Como se ilustra aquí, esto da:

¡Hola Mundo!
¡Hola Mundo!
¡Hola Mundo!

Y no implica ninguna sobrecarga de tiempo de ejecución, por lo que probablemente pueda apilarlos tanto como desee ... hasta que su compilador se ahoga en el archivo.

No hay limite . Un puntero es una porción de memoria cuyo contenido es una dirección.
Como dijiste

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

Un puntero a un puntero también es una variable que contiene una dirección de otro puntero.

int **q = &p;

Aquí qhay un puntero a puntero que contiene la dirección de la pcual ya contiene la dirección de a.

No hay nada particularmente especial sobre un puntero a un puntero.
Por lo tanto, no hay límite en la cadena de poniters que contienen la dirección de otro puntero.
es decir.

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

esta permitido.

Todos los desarrolladores de C ++ deberían haber oído hablar del (in) famoso programador de tres estrellas

Y realmente parece haber alguna "barrera de puntero" mágica que debe camuflarse

Cita de C2:

Programador de tres estrellas

Un sistema de calificación para programadores en C. Cuanto más indirectos sean sus punteros (es decir, más "*" antes de sus variables), mayor será su reputación. Los programadores C sin estrellas son prácticamente inexistentes, ya que prácticamente todos los programas no triviales requieren el uso de punteros. La mayoría son programadores de una estrella. En los viejos tiempos (bueno, soy joven, así que al menos me parecen viejos tiempos), de vez en cuando uno encontraba un código hecho por un programador de tres estrellas y temblaba de asombro. Algunas personas incluso afirmaron haber visto un código de tres estrellas con punteros de función involucrados, en más de un nivel de indirección. Me pareció tan real como los ovnis.

Tenga en cuenta que aquí hay dos posibles preguntas: cuántos niveles de indirección de puntero podemos lograr en un tipo C y cuántos niveles de indirección de puntero podemos meter en un solo declarador.

El estándar C permite imponer un máximo al primero (y le da un valor mínimo para eso). Pero eso se puede evitar a través de múltiples declaraciones typedef:

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

Así que, en última instancia, este es un problema de implementación relacionado con la idea de cuán grande / complejo puede hacerse un programa C antes de ser rechazado, lo cual es muy específico del compilador.

Me gustaría señalar que producir un tipo con un número arbitrario de * es algo que puede suceder con la metaprogramación de plantillas. Olvidé lo que estaba haciendo exactamente, pero se sugirió que podría producir nuevos tipos distintos que tengan algún tipo de meta maniobra entre ellos mediante el uso de tipos T * recursivos .

La metaprogramación de plantillas es un lento descenso a la locura, por lo que no es necesario poner excusas al generar un tipo con varios miles de niveles de indirección. Es solo una forma práctica de mapear enteros peano, por ejemplo, en la expansión de plantillas como lenguaje funcional.

La regla 17.5 de la norma MISRA C 2004 prohíbe más de 2 niveles de puntero indirecto.

No existe el límite real, pero el límite existe. Todos los punteros son variables que generalmente se almacenan en la pila, no en el montón . La pila suele ser pequeña (es posible cambiar su tamaño durante algunos enlaces). Entonces, digamos que tiene una pila de 4 MB, lo que es un tamaño bastante normal. Y digamos que tenemos un puntero que tiene un tamaño de 4 bytes (los tamaños del puntero no son los mismos dependiendo de la arquitectura, el destino y la configuración del compilador).

En este caso, el 4 MB / 4 b = 1024número máximo posible sería 1048576, pero no debemos ignorar el hecho de que hay otras cosas en la pila.

Sin embargo, algunos compiladores pueden tener un número máximo de cadena de puntero, pero el límite es el tamaño de la pila. Entonces, si aumenta el tamaño de la pila durante el enlace con infinito y tiene una máquina con memoria infinita que ejecuta el SO que maneja esa memoria, tendrá una cadena de puntero ilimitada.

Si usa int *ptr = new int;y coloca el puntero en el montón, esa no es la forma habitual de limitar el tamaño del montón, no la pila.

EDITAR Solo date cuenta de eso infinity / 2 = infinity. Si la máquina tiene más memoria, entonces el tamaño del puntero aumenta. Entonces, si la memoria es infinita y el tamaño del puntero es infinito, entonces son malas noticias ... :)

Depende del lugar donde guarde los punteros. Si están en la pila, tienes un límite bastante bajo . Si lo almacena en el montón, el límite es mucho más alto.

Mira este programa:

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

Crea punteros de 1M y en los espectáculos qué punto a qué es fácil notar qué va la cadena a la primera variable number.

Por cierto. Utiliza 92KRAM, así que imagina cuán profundo puedes llegar.