corrupt function parameters question

I have two large arrays of structures I could not declare as arrays (array too big error) but could allocate dynamically

n[138] and p[317]
and am trying to pass them as parameters to a function.

void create_reports (n_t n[], p_t p[]);

int main(void)
{

n_t *n;
p_t *p;

n = calloc(138,sizeof(n_t));
p = calloc(317,sizeof(p_t));
...
create_reports(n,p);

return(0);
}

The program works fine with smaller arrays but seems to pass the function garbled values with the full sized arrays. Am I running out of memory? Is it being passed by value and not address?

> I have two large arrays of structures I could not declare as
> arrays (array too big error) but could allocate dynamically

Get rid of your old 16-Bit compiler.

Quzah.

>arrays (array too big error) but could allocate dynamically


How do you know? I don't see any error checking to see if the calloc() call was successful. In which case you're writing all over your RAM!

...
hth

Depends what n_p and n_t types are - if they're large structures, could be a problem

n[138] and p[317]
and am trying to pass them as parameters to a function.

void create_reports (n_t n[], p_t p[]);

Code:

// this is on the stack, which is a real problem for old compilers on old OS, with very small stacks
int main(void)  { 
  n_t n[138];
  p_t p[317];
  // blah
}

// these are not on the stack, but in the normal data segment, but their scope is still within main
int main(void)  { 
  static n_t n[138];
  static p_t p[317];
  // blah
}

Your prototype for your solution is
    void create_reports (n_t *n, p_t *p);

And the call is
    create_reports(n,p);

Forgot to include the error checking, but it is in place:

if (!p)
exit(1);
if (!n)
exit(1);

Will try them as static, but I thought static variables could not be changed?

I appreciate the responses.

>but I thought static variables could not be changed?
Static variables that are local in scope retain their value when they go out of scope. Constant variables are variables that can't be changed (technically they can, but you'd pretty much have to be deliberately going around it, so const protects against accidental modification). So you can change the value of a local static variable.

-Prelude