What is the bit length of memory address in C?

Question

What is the bit length of memory address in C?

Walkbitterwyrm Lightwarg 20

I want to know what is the bit length of the memory address stored by the pointers in C on 64-bit processor machines and if any pointer needs an identifier as a name then is it also stored with a memory address?

Do pointers also take memory like variables?

David Lowndes 2,640 Reputation points MVP

2023-09-03T22:48:40.23+00:00

It'll be 64-bits!
Pointers are variables like other data types so they will normally be stored in memory though depending on the code, the optimization may be able to keep variables in registers.

2 answers

Your answer

David Lowndes 2,640 Reputation points MVP

2023-09-03T22:48:40.23+00:00

It'll be 64-bits!
Pointers are variables like other data types so they will normally be stored in memory though depending on the code, the optimization may be able to keep variables in registers.

Answer 1

The bit length of a pointer is the number of bytes in the pointer multiplied by the number of bits in a byte. The compiler will tell you the size of a particular pointer if you use the sizeof operator. The number of bits in a byte is provide by the CHAR_BIT macro defined in header limits.h. If you need to, you can compute with

bit_length = sizeof pointer_name * CHAR_BIT;

Like all other variables, pointers require a valid name. The name of your pointer is not present in your executable code. (This is true also for the names of your other variables.) Unless optimized out of memory, a pointer will occupy sizeof pointer bytes. (The same is also true for your other variables.)

While uncommon on most home systems today, it is possible for pointers of different types to have different sizes.

Answer 2

Bruce (SqlWork.com) 77,686 Volunteer Moderator

on a typical 64 bit processor the size of a pointer variable is 64 bits or the same as a long int or 8 bytes.

so in c

int main()
{
    char address = 'A';   // define an 1 bytes address initialsed to 'A' (65)
    char* pointer = &address; // pointer to this address
    long var1;            // variable larger enough to hold addresss
    char var2[4];         // another variable large enough
    
    var1 = (long) pointer;  // copy address to var1 
    
    // buffer copy of pointer value to array of bytes (or use memcpy())
    char* cp1 = (char*)pointer;
    char* cp2 = &var2[0];
    for (int i = 0; i < 4; ++i)
    {
        *cp2++ = *cp1++;
    }
    
    printf("%c %c %c\n", *pointer, *((char*) var1), *((char*) var2));
}

WayneAKing 4,931 Reputation points

2023-09-04T03:29:48.89+00:00
>on a typical 64 bit processor the size of a pointer variable is 64 bits

>or the same as a long int or 8 bytes.

On Win64 pointers are 8 bytes (64 bits) but long ints are 4 bytes (32 bits).

On Win64 a long int is the same size as an int.

Data Type Ranges

https://learn.microsoft.com/en-us/cpp/cpp/data-type-ranges?view=msvc-170

Wayne
WayneAKing 4,931 Reputation points

2023-09-04T03:45:48.25+00:00
>the size of a pointer variable is 64 bits or the same as a long int or 8 bytes.

No.

>so in c

Compile your example as an x64 target using Visual Studio and you will get Warnings about assignments between objects of different sizes. These Warnings will not appear in an x86 (32-bit) Build, as the pointers will be 4 bytes, the same as a long.

Wayne
WayneAKing 4,931 Reputation points

2023-09-04T03:48:23.3566667+00:00
[Duplicate post deleted.]

Wayne
Walkbitterwyrm Lightwarg 20 Reputation points

2023-09-05T11:16:54.0133333+00:00

David Lowndes---64-bits means the length of the memory address?

For instance, if 00000002 is hex address then it's binary 64-bit address would be 0000000000000000000000000000000000000000000000000000000000000010.

If pointers can store addresses like a variable that stores data types, where do pointers store the memory address (value) of the pointing value? That address as a value also need to be stored somewhere in the memory too?

WayneAKing---you are giving the size of the the data types but I was asking about the memory address.
David Lowndes 2,640 Reputation points MVP

2023-09-05T11:41:21.5933333+00:00

I've not got the patience to count all those digits so I'll say yes assuming there are 64 there.
Have a search for "understanding pointers" to see what you can find that way, here's one example.
WayneAKing 4,931 Reputation points

2023-09-05T14:51:36.5233333+00:00
>WayneAKing---you are giving the size of the the data types but I was asking about

>the memory address.

My replies were addressed to the comments made by Bruce, who stated that pointer size was the same as the size of a long int type on 64-bit systems. They're not (on Win64).

There is a positive correlation between memory address size and the size (capacity) of pointer variables in C and C++. A pointer variable must be large enough to hold the maximum size of an address on the platform (hardware/operating system) being used. That's why pointer variables in a 64-bit build are twice the size of pointer variables on a 32-bit build.

So the max number of bits in a C pointer on a 64-bit OS such as Win64 (x64) is 64, the same as the max bits in an address of the platform.

Note that 32-bit programs can run on a Win64 system, so compilers such as VS can build 32-bit programs (x86) as well as 64-bit programs (x64).

Obviously, the address (and pointer) size in a 32-bit program is 32 bits.

Wayne
Bruce (SqlWork.com) 77,686 Reputation points Volunteer Moderator

2023-09-05T15:39:00.9166667+00:00

sorry, I forgot that Microsoft Windows uses 4 byte longs. I use linux and macOS for C code.
Barry Schwarz 3,746 Reputation points

2023-09-05T23:07:24.5333333+00:00
@Walkbitterwyrm Lightwarg Yes, on a 64 bit system, you have expressed the hex representation of that address correctly in binary representation. In that case, a pointer which can store that address will occupy 64 bits (usually 8 bytes) of memory.

A pointer is a variable that holds an address. This is conceptually identical to an int which is a variable that holds an integer. The point that seems to be eluding you is that any variable, no matter what type of data it holds, also has an address. So for any int variable, there is the address where the variable is located in memory and the integer value in memory at that location. Similarly, for any pointer variable, there is the address where the variable is located in memory and the address value it points to at that location

Given the code sequence

int x, *ptr; x = 65; ptr = &x;

integer x will occupy 4 bytes of memory at a location determined by your system. Assume the system puts x at location 0x0000000000024680. On a typical 64-bit system, ptr would be located at 0x0000000000024688. After the first assignment is executed, location 0x0000000000024680-0x0000000000024683 would contain 0x41 0x00 0x00 0x00 which is the little-endian representation of 65. After the second assignment, location 0x0000000000024688-0x000000000001000f would contain 0x80 0x46 0x02 0x00 0x00 0x00 0x00 0x00, the little-endian representation of the address of x.

Notice that ptr is located at 0x0000000000024688 and it contains 0x0000000000024680. Its location and its content are completely independent of each other. You can reassign ptr to point to another int but there is nothing you can do that would cause ptr to move to another location.

Neither x nor ptr keep track of their own address. That is the compiler's job. When the address is needed, the compiler generates the appropriated code to provide it. For example, in order to store the value 65 in x, the compiler needs to generate the code to compute the value 65 and the code to store this value where x is located.

The situation is the same with pointers. In order to store the address of x in ptr, the compiler needs to generate the code to compute the address of x and the code to store this value where ptr is located.

Share via

What is the bit length of memory address in C?

2 answers

Your answer