inicialización del puntero simple

Question

Hacía tiempo que utilizaba punteros y solo quería comprobar rápidamente cómo puedo inicializar un puntero entero?

a) int *tmpPtr = 0; 

b) int *tmpPtr = null; 

c) int a = 0; 
    int *tmpPtr = &a; 

EDITAR

Gracias por todas sus respuestas hasta ahora. Lo curioso es que si intitalizo el puntero de la siguiente manera, entonces la operación mem :: copy funciona bien.

int tmp = 0; 
int *tmpPtr = &tmp; 
Mem::Copy((void*)tmpPtr, basepointer(), sizeof(int)); 

Sin embargo, si lo hago de esta manera:

int *tmpPtr = 0; 
Mem::Copy((void*)tmpPtr, basepointer(), sizeof(int)); 

cuando me siento un accidente durante la mem :: copia ...

extraño!

Answer 1

Puede hacerlo de todas las formas excepto que es NULL no nulo. Prefiero int * p = 0; sobre int * p = NULL;

Para eliminar un poco de confusión lo siento, estableciendo int * p = 0 o estableciendo MyObject * p = 0; da como resultado lo mismo ... un puntero nulo que normalmente bloqueará tu programa si intentas desreferenciarlo, aunque técnicamente es un comportamiento indefinido. El ejemplo que tiene en C es diferente de los demás, porque en realidad se está configurando el puntero para apuntar a un entero establecen como 0.

 
int *pNull = 0; 
int c = *pNull; // Undefined behavior. Most likely crashing your program! 

int a  = 0; 
int *pInt = &a; 

int x = *pInt; // x equals 0 

a = 10; 
int y = *pInt; // y equals 10 

Answer 2

preguntas simples están muy bien, creo que está bien establecido que el SO está destinado a ser para todos los niveles, no solo una élite.

No hay null en C (a menos que usted mismo lo defina). La inicialización de un puntero nulo se puede hacer en una de las dos formas siguientes:

int *p = 0; 
int *p = NULL; 

Si desreferenciar p después de eso, es muy probable que obtener una violación de acceso (yo creo que es un comportamiento no definido de acuerdo a la norma, así que, realmente, podría pasar cualquier cosa, incluso la aniquilación total del universo, incluso podría seguir funcionando bien, pero no confiaría en eso).

para obtener un puntero a un entero real, sólo tiene que utilizar:

int a = 7; 
int *p = &a; 

utilizando el operador de dirección.

Re a su edición, no es raro en absoluto, solo necesita visualizarlo. Imaginemos que todas las variables se crean comenzando en la ubicación de la memoria 100 y los enteros y los punteros tienen una longitud de 4 bytes. Rompiendo sus dos situaciones a su forma más simple:

        int x = 2; 
int *px = 0;      int *px = &x; 

     +-----+       +-----+ 
px(100): | 0 |     x(100) | 2 | 
     +-----+       +-----+ 
            px(104) | 100 | 
              +-----+ 

A continuación, se ejecuta el comando

*px = 7; 

en un intento de cambiar la variable a la que apunta px.

En el lado izquierdo, intentará escribir el valor 7 en la ubicación de memoria 0.Eso es algo malo; muy pocos sistemas le permitirán hacer eso sin fallar, incluso menos lo permitirán sin ningún efecto adverso (algunas versiones de HP-UX realmente funcionaron bien).

En el lado derecho es donde debe pasar. El valor recogido desde px es 100, por lo que el valor 7 se escribe en esa ubicación de memoria, cambiando x según lo previsto.

A menudo encuentro imágenes (incluso las primitivas de arte ASCII, ya que no soy Rubens o Botticelli) ayudan a aclarar los conceptos. Espero que haya aclarado un poco para ti.

Answer 3

No hay null palabra clave en C (al menos en ANSI C99). Puede usar a) o c).

En c) no inicializará el puntero con nulo, lo inicializará con la dirección de la variable local.

Answer 4

Inicialice los punteros que apuntan a nada mediante una constante de puntero nulo. Cualquier expresión constante con valor 0 sirve como una constante de puntero nulo. En C se usa la macro NULL por convención.

Answer 5

respuesta a su pregunta en EDIT:

• Al hacer esto:

  int tmp = 0; 
  int *tmpPtr = &tmp; 
  Mem::Copy((void*)tmpPtr, basepointer(), sizeof(int)); 
  

tmpPtr está apuntando a la dirección de la variable tmp y es en el stack. Y observe que el "área segura" apuntada por tmpPtr es del tamaño de tmp (que es 4 en alguna máquina y 2 en otras). Si tuviera que copiar más de sizeof (int) bytes a tmpPtr, correrá el riesgo de bloquear la pila.

• Al hacer esto:

  int *tmpPtr = 0; 
  Mem::Copy((void*)tmpPtr, basepointer(), sizeof(int)); 
  

El valor de tmpPtr es 0, por lo que obtendrá una segment fault., que es un mecanismo de protección de memoria que ofrece el sistema de operación. Por ejemplo, no está permitido escribir ningún virtual address que sea inferior a 4 K.

Answer 6

La línea

int *tmpPtr = 0; 

inicializa el puntero valor a 0, por lo tmpPtr está apuntando "a ninguna parte"; es decir, no es una ubicación de memoria válida. Primero debe asignar una ubicación de memoria válida al puntero como lo hizo en el fragmento anterior.

Answer 7

Estaba refrescando el conocimiento de mi puntero y tropecé con esto.

int *tmpPtr = 0; 

Me resulta más fácil pensar en ello como esto:

int *tmpPtr ; 

tmpPtr = 0 ; 

I 'creen' las 2 líneas anteriores son equivalentes a los de una línea. , por lo que, básicamente, la dirección a desviar se establece en 0 o NULL.