CODEWITHSUNDEEP
cpointers
johnny
johnny

Reputation: 19745

When using calloc in C what is stored at the address of the pointer?

I'm having a hard time understanding this program to illustrate pointers (from http://theocacao.com/document.page/234):

Below I don't understand why:

int * currentSlot = memoryBlock

isn't using &memoryBlock. I read the comment but don't get it. What is memoryBlock putting in there that &memoryBlock wouldn't? Won't both return the pointer to the set of ints created with calloc (assuming I understand what's been done that is)? What is really in * memoryBlock after calloc?

Then here, *currentSlot = rand();, how does the dereferencing work here? I thought the dereference would stop *currentSlot from giving the value of the memory address (the reference) to the actual value (no longer a reference but the value).

#include <stdio.h>
#include <stdlib.h> // for calloc and free
#include <time.h>   // for random seeding

main ()
{
  const int count = 10; 
  int * memoryBlock = calloc ( count, sizeof(int) );

  if ( memoryBlock == NULL )
  {
    // we can't assume the memoryBlock pointer is valid.
    // if it's NULL, something's wrong and we just exit
    return 1;
  }

  // currentSlot will hold the current "slot" in the,
  // array allowing us to move forward without losing
  // track of the beginning. Yes, C arrays are primitive
  //
  // Note we don't have to do '&memoryBlock' because
  // we don't want a pointer to a pointer. All we
  // want is a _copy_ of the same memory address

  int * currentSlot = memoryBlock;


  // seed random number so we can generate values
  srand(time(NULL));

  int i;    
  for ( i = 0; i < count; i++ )
  {
    // use the star to set the value at the slot,
    // then advance the pointer to the next slot    
    *currentSlot = rand();
    currentSlot++; 
  }

  // reset the pointer back to the beginning of the
  // memory block (slot 0)
  currentSlot = memoryBlock;

  for ( i = 0; i < count; i++ )
  {
    // use the star to get the value at this slot,
    // then advance the pointer
    printf("Value at slot %i: %i\n", i, *currentSlot);
    currentSlot++;
  }

  // we're all done with this memory block so we
  // can free it  
  free( memoryBlock );
}

Thank you for any help.

Upvotes: 1

Views: 1025

Answers (6)

D Stanley
D Stanley

Reputation: 152596

memoryBlock is an array of integers (int*). (technically a pointer to an int but since it was allocated with enough room for 10 integers you can think of it as the start of an array)

*memoryBlock is the integer that memoryBlock is pointing to (the first int in the array). While the notation looks the same as the declariation it is actually dereferencing the value. IMHO it is poorly written as it should be declared

int* currentSlot = memoryBlock;

to make it more clear that it's a pointer to an integer, but that's a style choice.

&memoryBlock is the address of the pointer. 

int * currentSlot = memoryBlock;

stores the pointer to the first slot in currentSlot. The program is then generating random numbers and putting them in each of the 10 clost by incrementing currentSlot (which internally is incrementing the pointer by the length of an integer.

Hope that helps.

Upvotes: 1

cquezel
cquezel

Reputation: 4497

int * memoryBlock;

memoryBlock is a variable which can hold the address of a memory block of integers. The size of the memoryBlock variable is the size of an address. Typically 4 or 8 bytes (sizeof(int*)). Its type is "pointer to int".

memoryBlock = calloc ( 5, sizeof(int) );

the memoryBlock variable is assigned the address of the start of the memory block able to hold 5 integers. The memory block size is 5 * sizeof(int) bytes.

memoryBlock + 1 is the address of the second integer in the block. memoryBlock + 5 is one passed the address of the last integer in the block.

*memoryBlock is the content of the address (the first integer). type is integer.

*(memmoryBlock + 0) = 0;
*(memmoryBlock + 1) = 1;
*(memmoryBlock + 2) = 2;
*(memmoryBlock + 3) = 3;
*(memmoryBlock + 4) = 4;
//    *(memmoryBlock + 5) = 5; illegal

Assigns integers to memory block. Subscipt form same as above.

memmoryBlock[0] = 0;
memmoryBlock[1] = 1;
memmoryBlock[2] = 2;
memmoryBlock[3] = 3;
memmoryBlock[4] = 4;
//    memmoryBlock[5] = 5; illegal

&memoryBlock is the address of the memoryBlock variable. This is not the address of the callocated space. It's type is int** "pointer to pointer to integer" not int*.

int ** pmemoryBlock;

pmemoryBlock is a variable which hold the address of an address of a memory block of integers. The size of pmemoryBlock is the size of an address. Typically 4 or 8 bytes (sizeof(int**)).

pmemoryBlock = &memoryBlock;

pmemoryBlock is assigned the address of a variable which holds the address of the start of the memory block able to hold 5 integers.

*pmemoryBlock is the address of the memory block. **pmemoryBlock is the first integer in the memory block *((*pmemoryBlock) + 0) is the first integer in the memory block *((*pmemoryBlock) + 1) is the seconds integer in the memory block

...

Upvotes: 1

Lloyd Macrohon
Lloyd Macrohon

Reputation: 1462

int * is a pointer, which can be dereferenced. int ** is a pointer to a pointer, which can be dereferenced twice. So what does this mean? Well, a pointer is nothing more than an integer. Memory addresses just start from zero to its max range. For 32-bit systems, its range of addressable memory is 0 to 2^32-1 (or 4294967295). Each of this address has a byte value. If you have an int *, then it will access the address 4-bytes at a time. Also, for simplicity, let's assume this is a virtual address, you can't just access all this memory, some will be protected (system), some are not valid (not committed). To gain more memory you can ask the system to allocate more from this range. sbrk in Linux, VirtualAlloc in Windows but you will be accessing them usually through C's malloc or calloc.

Let's say, you have starting from 0x100: 0x100: 'h', 'e', 'l', 'l', 'o', '\0'

So this string, occupies memory from 0x100 to 0x105 (including the null terminator). If you have a pointer:

char *p = 0x100;

Then you have:

p      // 0x100
*p     // 'h'
p+1    // 0x101
*(p+1) // 'e'
p += 2 // 0x102
*p     // 'l'
p = 0x200;
p      // now points to 0x200 in memory
*p     // contains whatever value is in 0x200

If you have int pointers, then you are accessing memory 4-bytes at a time (or however big an int is on your system).

So with all that background, when you run calloc, it returns the address of the block you've requested.

int *memoryBlock = calloc(count, sizeof(int));
// memoryBlock is an array of int, assuming sizeof(int) == 4, then
// you have 40 bytes of memory starting from the address of what is
// returned by calloc.

memoryBlock++;     // now memoryBlock is at base address + 4
*memoryBlock = 10; // now that address contains the value 10
(*memoryBlock)++;  // now that address contains the value 11
memoryBlock++;     // now memoryBlock is 4 bytes further

Upvotes: 0

Fred Foo
Fred Foo

Reputation: 363737

Below I don't understand why:

int * currentSlot = memoryBlock

isn't using &memoryBlock.

Because both memoryBlock and currentSlot are pointers to int. &memoryBlock would be the address of a pointer to int, i.e. an int **.

What is "in" memoryBlock is a pointer to a block of memory.

Then here, *currentSlot = rand();, how does the dereferencing work here?

This is a rule of C: when a dereferencing expression like this occurs on the left-hand side of an expression, the right-hand side's value is stored in the memory location pointed to by the pointer being dereferenced.

Upvotes: 3

Pete Wilson
Pete Wilson

Reputation: 8694

It's not supposed to use &memoryBlock, which is the (int ** (heh!)) address of the the pointer into the memory you are clearing. In other words, memoryBLock (iff it's not NULL) points to (i.e., holds the address of) the first int in the calloc( )'ed memory. To reference that cleared-to-0 memory, you use *memoryBlock.

If you ever find yourself trying to use &memoryBlock, don't: it's never the right thing to do in the code fragment you posted.

HTH. If it doesn't help, go back to K&R and study pointers some more. Maybe a lot more.

Upvotes: 0

Some programmer dude
Some programmer dude

Reputation: 409356

In the code, memoryBlock is apointer to some memory that stores integers. That is, the actual value of the variable memoryBlock is the address just allocated. If you use &memoryBlock you get the address of where the variable is stored, not what it points to.

Lets take an example:

int foo = 5;
/* the variable "foo" is stored in memory,
   and that memory contains the number 5 */

int bar = 7;
/* the variable "foo" is stored in memory,
   and that memory contains the number 7 */

int *foo_pointer = &foo;
/* the variable "foo_pointer" is stored in memory,
   and that memory contains the address of the variable "foo" */

foo_pointer = &bar;
/* the contents of the variable "foo_pointer" is no longer the address
   of where the variable "foo" is in memory, instead it is the address
   of where the variable "bar" */

I hope this makes some sense, and it helps a little.

Upvotes: 0

Related Questions