A pointer in c which has not been initialized is known as wild pointer.

 int main(int argc, char *argv[])

 {

     int *p;

     return (*p & 0x7f); /* XXX: p is a wild pointer */

 }

 $ gcc -Wall -g -m32 -o foo foo.c

 foo.c: In function ‘main’:

 foo.c::: warning: ‘p’ is used uninitialized in this function [-Wuninitialized]

   return (*p & 0x7f); /* XXX: p is a wild pointer */

           ^

If a pointer still references the original memory after it has been freed, it is called a dangling pointer.

1 #include <stdlib.h>

2 int main(int argc, char *argv[])

3 {

4         int *p1 = (int *)malloc(sizeof (int));

5         int *p2 = p1;        /* p2 and p1 are pointing to the same memory */

6         free(p1);            /* p1 is       a dangling pointer, so is p2  */

7         p1 = NULL;           /* p1 is not   a dangling pointer any more   */

8         return (*p2 & 0x7f); /* p2 is still a dangling pointer            */

9 }

Anything at all can happen; the Standard imposes no requirements. The program

may fail to compile, or it may execute incorrectly (either crashing or silently

generating incorrect results), or it may fortuitously do exactly what the

programmer intended.

ADI (Application Data Integrity) is a software layer built on
MCD (Memory Corruption Detection), a SPARC hardware feature that provides
statistical protection against memory corruption errors such as buffer
overflows, use-after-frees, and use-after-reallocs.

KADI allows kernel memory to use ADI.

Smart pointers eliminate dangling pointers by postponing destruction until

an object is no longer in use.

Reference counting is a technique of storing the number of references,

pointers, or handles to a resource such as an object, block of memory,

disk space or other resource.

 $ stat foo | egrep Inode

 Device: 23000000002h/2405181685762d     Inode:    Links: 

 $ ln foo foo9 && stat foo  | egrep Inode

 Device: 23000000002h/2405181685762d     Inode:    Links: 

 $ rm -f foo   && stat foo9 | egrep Inode

 Device: 23000000002h/2405181685762d     Inode:    Links: 

 #include <stdio.h>

 #include <stdlib.h>

 typedef struct proxy_s {

     int *object;

     int refcnt;

 } proxy_t;

 static int *create(proxy_t **proxy)

 {

     if (*proxy == NULL) {

         proxy_t *p = (proxy_t *)malloc(sizeof (proxy_t));

         p->object = (int *)malloc(sizeof (int));

         p->refcnt = ;

         *proxy = p;

     } else {

         ((*proxy)->refcnt)++;

     }

     return (*proxy)->object;

 }

 static void destroy(proxy_t *proxy)

 {

     (proxy->refcnt)--;

     if (proxy->refcnt == ) {

         free(proxy->object);

         free(proxy);

     }

 }

 static void dump(proxy_t *proxy, int i)

 {

     printf("%02d\tobject: %p (0x%02x) refcnt: %d\n", i,

         proxy->object, *(proxy->object), proxy->refcnt);

 }

 int main(int argc, char *argv[])

 {

     proxy_t *proxy = NULL;

 #define NEW()        create(&proxy)

 #define DELETE(p)    do { destroy(proxy); p = NULL; } while (0)

 #define DUMP(i)      dump(proxy, i)

     int *p1 = NEW();

     int *p2 = NEW();

     *p1  = 0xab; DUMP();

     DELETE(p1);  DUMP();

     *p2 += 0x21; DUMP();

     DELETE(p2);  DUMP();

     return ();

 }

$ gcc -Wall -m32 -g -o foo3 foo3.c

$ ./foo3

    object: 0x8d0d018 (0xab) refcnt:

    object: 0x8d0d018 (0xab) refcnt:

    object: 0x8d0d018 (0xcc) refcnt:

    object: 0x8d0d010 (0x00) refcnt: 

A dangling pointer is a pointer that used to point to a valid address but now

no longer does. This is usually due to that memory location being freed up and

no longer available. There is nothing wrong with having a dangling pointer

unless you try to access the memory location pointed at by that pointer.

It is always best practice not to have or leave dangling pointers.

A wild pointer is a pointer that has not been correctly initialized and

therefore points to some random piece of memory.

It is a serious error to have wild pointers.