Is there any way by which we can de-reference a memory address in C?

Question

I am understanding the working of pointers in C. Pointers basically stores the address of the memory (say addr1) and de-referencing the pointers gives us the value stored at that memory address addr1. Is there any possible way by which we can directly de-reference the memory address addr1 to get the value stored at that location?

I know how to use a pointer. I just want to know what actually happens behind. I tried to create the same scenario of how the pointer works in the below code using memory address. Although I am stuck in getting the value from a pointer. With this example, I want to know how the de-referencing of a pointer works.

For example:

#define LOCATION 0x68feac //Assuming that the memory location is available

int main()
{
    int a = 10;
    *(int *)LOCATION = (int)&a;
    printf("%x\n", (*(int*)(LOCATION)));    //It gives me the address of a
    printf("%x\n", *((*(int*)(LOCATION)))); /* I thought it would de-refer but
                                                it gives me compile time error 
                                                "invalid type argument of unary 
                                                '*'" */

}

I tried using

How to de-reference LOCATION so that we can get value 10? Any ideas or suggestions would help.

Answer 1

What you are asking for is:

printf("%x\n", *((int *)(*(int*)(LOCATION))));

Because you need to convert the int value retrieved from *(int*)(LOCATION) to a pointer before de-referencing it.

But you really do not do that! It is an ugly syntax, and C compilers are great in optimizing out useless variables. So do yourself a favour and name the intermediary pointers:

#define LOCATION 0x68feac //Assuming that the memory location is available

int main()
{
    int a = 10;
    int **loc = (int **)LOCATION;  // BEWARE only make sense in very special use cases!
    *loc = &a;
    printf("%p\n", *loc);    //It gives me the address of a
    printf("%x\n", **loc);
    return 0;
}

Anyway, using an arbitrary memory location is seldom used in C, because the compiler (and linker) will use addresses that you can hardly guess. The only use case I know, is accessing well known physical addresses in embedded system or in kernel modules

Answer 2

Very common in all embedded uC development (do not forget the volatile keyword).

*(volatile int *)LOCATION = a;

and how to print it

printf("a is : %d\n, *(volatile int *)LOCATION); 

---

or if you want to store the address of a

*(volatile int **)LOCATION = &a;

and how to print it

printf("Address if a is : %p, a is: %d\n, (void *)*(volatile int **)LOCATION, **(volatile int **)LOCATION); 

Real life example:

#define GPIOA_BASE 0x40000000

#define GPIOA ((GPIO_TypeDef *) GPIOA_BASE)

{
  __IO uint32_t MODER;        /*!< GPIO port mode register,                                  Address offset: 0x00 */
  __IO uint16_t OTYPER;       /*!< GPIO port output type register,                           Address offset: 0x04 */
  uint16_t RESERVED0;         /*!< Reserved,                                                                 0x06 */
  __IO uint32_t OSPEEDR;      /*!< GPIO port output speed register,                          Address offset: 0x08 */
  __IO uint32_t PUPDR;        /*!< GPIO port pull-up/pull-down register,                     Address offset: 0x0C */
  __IO uint16_t IDR;          /*!< GPIO port input data register,                            Address offset: 0x10 */
  uint16_t RESERVED1;         /*!< Reserved,                                                                 0x12 */
  __IO uint16_t ODR;          /*!< GPIO port output data register,                           Address offset: 0x14 */
  uint16_t RESERVED2;         /*!< Reserved,                                                                 0x16 */
  __IO uint32_t BSRR;         /*!< GPIO port bit set/reset registerBSRR,                     Address offset: 0x18 */
  __IO uint32_t LCKR;         /*!< GPIO port configuration lock register,                    Address offset: 0x1C */
  __IO uint32_t AFR[2];       /*!< GPIO alternate function low register,                Address offset: 0x20-0x24 */
  __IO uint16_t BRR;          /*!< GPIO bit reset register,                                  Address offset: 0x28 */
  uint16_t RESERVED3;         /*!< Reserved,                                                                 0x2A */
}GPIO_TypeDef;

and usage:

GPIOA -> MODER = value; 

__IO is defined as volatile

#define __IO volatile

Answer 3

To dereference an int from a given location:

int val = *((int*) LOCATION);

((int*) LOCATION) gives you the LOCATION casted to an int pointer, so the last step is to dereference it.

Example (where an exact LOCATION is specified as an existing pointer to integer, but it would work the same):

#include <stdio.h>

#define LOCATION ((void*) &a)

int main(void){
    int a = 123;
    printf("a=%d, &a=%p\n", a, &a);

    printf("*LOCATION=%d, LOCATION=%p\n", *((int*) LOCATION), LOCATION);
}

Answer 4

You do things mostly correctly, but a pointer isn't just another integer, and you can't use arbitrary values, you have to use some that are allocated (i.e. given by the OS) to the program.

1. To be able to dereference a pointer, we store the type of value stored in memory. That means that instead of a define you should declare int *LOCATION; to state that you want to point to a memory location where an integer is stored.

2. In consequence, you shouldn't cast a pointer to int, because &a is already of the same type : a pointer to an int.

   Furthermore, you can't assign values to something you define. A define is not a type -- I'm sure you can find another question about what it is exactly.

3. Getting the address of a before dereferencing it is correct, so do not assign arbitrary values to LOCATION ahead of time. At best, assign it NULL, to signify the pointer is not initialized.

Your code then becomes :

int* LOCATION = NULL;
int main()
{
    int a = 10;
    LOCATION = &a;
    printf("address of a: %lx\n", LOCATION);    // accessing the pointer accesses the memory address
    printf("value of a: %x\n", *LOCATION); // dereferencing the pointer with * gives the value stored at that address
} 

---

Now if you're using a memory-mapped peripheral, for example as @P__J__ suggests some hardware register with a fixed address, you need to cast the address to the right type.

#define LOCATION_ADDR 0x68feac
int volatile * const LOCATION = (int *) LOCATION_ADDR; 

• volatile here means that the memory stored at that location may change due to factors external to the program. This changes compiler optimizations, for example a loop that reads this location until it changes would be removed without volatile.
• const here means the pointer location won't change, though the data it contains might (different from const int !).
• Once you're comfortable with this, you might use this in the define directly, i.e. #define LOCATION ((volatile int*)0x68feac)

---

If you want the hardware register to contain a pointer to an int, simply add another *.

#define LOCATION 0x68feac //Assuming that the memory location is available

int main()
{
    int a = 10;
    // dereferencing the address at LOCATION, storing into it the address of a
    *((volatile int **)LOCATION) = &a;
    printf("%p\n", *((volatile int **)LOCATION));
    printf("%x\n", **((volatile int **)LOCATION));
    return 0;
}