CODEWITHSUNDEEP
cdata-structures
antonpug
antonpug

Reputation: 14286

How to access allocated memory in C?

After using malloc() to initialize 5000 bytes of memory, how would I reference the bytes in this memory space? For example, if I need to point to a starting location of data within the memory, how would I go about that?

EDIT: Does it matter what I use to point to it? I mean I am seeing people use bytes/int/char? Is it relevant?

Error I get: enter image description here

Upvotes: 0

Views: 2117

Answers (6)

AndersK
AndersK

Reputation: 36082

After using malloc() to initialize 5000 bytes of memory, how would I reference the bytes in this memory space? For example, if I need to point to a starting location of data within the memory, how would I go about that?

Does it matter what I use to point to it? I mean I am seeing people use bytes/int/char? Is it relevant?

as you have seen malloc allocates a block of memory counted in bytes, you can assign a pointer to that block and depending on the pointer type the compiler knows how to reference individual elements:

unsigned char *memblob = malloc( 1024 );
short* pshort = (short*)memblob;

now if you reference the second short value i.e. *(pshort + 1) or pshort[1] the compiler knows that it needs to add 2 bytes (sizeof(short)) in order get the next element.

float* pfloat = (float*)memblob;

now if you reference the second float value i.e. *(pfloat + 1) or pfloat[1] the compiler knows that it needs to add 4 bytes (sizeof(float)) in order get the next element.

same with own defined data types:

typedef struct s
{
  short a;
  long  b;
} mystruct_t;

mystruct_t* pstruct = (mystruct_t*)memblob;

pstruct + 1 accesses the struct at offset sizeof(mystruct_t)

so it is really up to you how you want to use the allocated memory

Upvotes: 0

TTimo
TTimo

Reputation: 1396

malloc() returns a pointer to the allocated memory:

typedef unsigned char byte;
byte * mem = malloc( 5000 );

byte val = mem[1000]; /* gets the 1000th byte */

Upvotes: 0

Iskar Jarak
Iskar Jarak

Reputation: 5325

As has been mentioned by others, you could do something like this:

int nbytes = 23; // number of bytes of space to allocate
byte *stuff = malloc(nbytes * sizeof stuff[0]);

stuff[0] = 0; // set the first byte to 0
byte x = stuff[0]; // get the first byte

int n = 3;
stuff[n] = 0; // set the nth byte to 0
x = stuff[n]; // nth byte, or in the case of some other type, nth whatever - just make sure it's a safe value, from 0 (inclusive) to the number (nbytes here) of things you allocated (exclusive)

However, a couple of things to note:

  1. malloc will not initialise the memory, but calloc will (as mentioned by Prasoon Saurav)
  2. You should always check to see if the memory allocation failed (see below for an example)
int nbytes = 23; // or however many you want  
byte *stuff = malloc(nbytes * sizeof stuff[0]);

if (NULL == stuff) // memory allocation failed!
{
 //handle it here, e.g. by exiting the program and displaying an appropriate error message
}

stuff[0] = 0; // set the first byte to 0
byte x = stuff[0]; // get the first byte

int n = 3;
stuff[n] = 0; // set the nth byte to 0
x = stuff[n]; // nth byte, or in the case of some other type, nth whatever

Upvotes: 0

justin
justin

Reputation: 104698

You can use the subscript array[n] operator to access the index you are interested in reading/writing, like so:

uint8_t* const bytes = (uint8_t*)malloc(5000);

bytes[0] = UINT8_MAX; // << write UINT8_MAX to the first element
uint8_t valueAtIndexZero = bytes[0]; // << read the first element (will be UINT8_MAX)
...
free(bytes), bytes = 0;

Upvotes: 1

Prasoon Saurav
Prasoon Saurav

Reputation: 92864

Malloc doesn't initialize the bits allocated by it. Use calloc() rather.

int *p = malloc (5000); // p points to the start of the dynamically allocated area.

Upvotes: 0

Thomas Eding
Thomas Eding

Reputation: 1

char * buffer = malloc(5000);

buffer[idx] = whatever;

char * p = buffer + idx;
*p = whatever;

Upvotes: 1

Related Questions