How to create a dynamic array inside a structure?

Question

0.00/5 (No votes)

See more:

How to create a dynamic array inside a structure?
Can I do the following inside a structure?
Int *p=(int*)malloc(sizeof(int));

What I have tried:

I have tried but it shows some error .

Posted 17-Aug-20 18:20pm

RAJESH1601105065

Updated 26-Aug-20 3:49am

Add a Solution

Comments

Rick York 18-Aug-20 2:34am

Try something more useful. Allocating a single integer is virtually never done because the pointer is the same size as the value in a 32-bit world and it is smaller in a 64-bit world. Try allocating an array of something or an entire structure. That will be much more realistic.

3 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Sandeep Mewara · Answer 1 · 2020-08-17T18:28:00

Reference: pointers - How to include a dynamic array INSIDE a struct in C? - Stack Overflow[^]
Putting what's there here for quick view:

C++

#include <stdlib.h>

struct my_struct {
    int n;
    char s[];
};

When you allocate space for this, you want to allocate the size of the struct plus the amount of space you want for the array:

C++

struct my_struct *s = malloc(sizeof(struct my_struct) + 50);

In this case, the flexible array member is an array of char, and sizeof(char)==1, so you don't need to multiply by its size, but just like any other malloc you'd need to if it was an array of some other type:

C++

struct dyn_array { 
    int size;
    int data[];
};

struct dyn_array* my_array = malloc(sizeof(struct dyn_array) + 100 * sizeof(int));

There are more discussions on web for it.

Rick York · Answer 2 · 2020-08-18T05:10:00

On the rare occasions I must use calloc and free I like to use two helpful macros :

C++

   // allocate memory of a given type - must use free to release it

#define AllocateMemory(count,type)   (type*)calloc(count,sizeof(type))

    // free an object and null it

#define ReleaseMemory(ptr)           { if(ptr) { free(ptr); ptr=nullptr; } }

I always use calloc because it zeros the memory also so it saves a step. I use the macros because I think they make the code more clear and eliminate a cast. Here is a sample of them in use - allocating an array of integers.

C++

int * integerArray = NULL;
integerArray = AllocateMemory( 1024, int );

// do something with the array here

ReleaseMemory( integerArray );

It is very important to always release any memory that you allocate. When you don't it results in a memory leak and those are a very bad thing. If you write software that has to run for months and months leaks can cause crashes and those are very, very bad.

CPallini · Answer 3 · 2020-08-26T03:49:00

As direct answer to your question, try

C

#include <stdio.h>
#include <stdlib.h>

struct Foo
{
  // other members here
  int * p;
};


int main()
{
  const size_t ITEMS = 10;

  struct Foo foo;

  foo.p = (int*) malloc( sizeof(int) * ITEMS);

  printf("%p\n", foo.p);

  size_t n;
  for (n = 0; n<ITEMS; ++n)
    foo.p[n]  = n*n;


  for (n = 0; n<ITEMS; ++n)
    printf("foo.p[%lu]=%d\n", n, foo.p[n]);

  free(foo.p);

  return 0;
}

Anyway, note that, as Sandeep Mewara suggested, the 'dynamic array' in the struct it is frequently accompained by another member indicating the size of the array itself. This is useful when passing the struct as argument to a function. For instance:

C

#include <stdio.h>
#include <stdlib.h>

struct DynArray
{
  size_t items;
  int *p;
};


void print_dynarray(struct DynArray da)
{
  size_t n;
  for (n = 0; n < da.items; ++n)
    printf("item[%lu] = %d\n", n, da.p[n]);
}

int main()
{

  const size_t ITEMS = 10;

  struct DynArray da;

  da.items = ITEMS;
  da.p = (int*) malloc( sizeof(int) * da.items);

  size_t n;
  for (n = 0; n<ITEMS; ++n)
    da.p[n]  = n*n;

  print_dynarray( da );

  free(da.p);
  da.items = 0;

  return 0;
}

How to create a dynamic array inside a structure?

3 solutions

Solution 1

Solution 2

Solution 4

Add your solution here

Preview 0