I have a struct called Student and one of its elements is an array that will have a max of 40000 elements, so i built it like this:
I have a method that adds a new student but the number of elements in the number array can vary between 0 and 40000 so i never know the size of the array.Code:typedef struct{ int number; int grades [40000]; }Student;
What should i do? Should i change the element grades to a pointer? I know once i declare the array to have 40000 elements i can't change its size.
The real answer depends on how much memory you are using.
I think you can get away with leaving it the way it is, but if there are 40000 Student instances too, not so much.
The grades alone require like 160KB per student so you can use that to figure out roughly how much memory you are going to use on the stack. If it ends up being a lot you will need to make the change.
I'm sorry I think I explained it wrong... Basically I'm working with hashtables and I have a function that adds a new Student to the hashtable,something like this:
So I never know the size of the grades array, only that the max will be 40000, so, when I declared the struct I made the grades array have 40000 elements.Code:void addsStudent(int number, int grades [ ]){ Student st; st.number = number; /*Adds grades array to st*/ insert(st); /*Adds student to hashtable*/ }
My issue is how do I add the grades array not knowing its size, do I just add them to the 40000 array? Do I use pointers?
The cheapest version of what you want is something like this:
Problems:Code:#include <stdio.h> #include <stdlib.h> typedef struct { int id; int size; // size of grades array int *grades; } Student; int main() { Student s; s.size = 0; s.grades = NULL; int n; while (scanf("%d", &n) == 1) { // ctrl-d (ctrl-z on windows) to quit s.grades = realloc(s.grades, ++s.size * sizeof(*s.grades)); s.grades[s.size-1] = n; } for (int i = 0; i < s.size; i++) printf("%d\n", s.grades[i]); return 0; }
* no error checking: in particular if realloc fails you lose the pointer to previously allocated memory.
* inefficient: it's more efficient to increase the array size by doubling (or increasing by at least 50%) when you are out of space. But then you need to keep track of the "capacity" (total number of elements allocated) as well as the "size" (number of elements in use).
A little inaccuracy saves tons of explanation. - H.H. Munro
And will that work in a function? Because in the signature i haveand i never know how many elements that array has, only that it has no more than 9000. Should i change the struct element grades and the addsStudent signature to a pointer?Code:void addsStudent(int id, int array) [])
Same idea: instead of reading from standard input, you're processing the elements of an array. However, you do need to "know" how many elements the array has in use, typically by having another parameter for the number of elements in use. Otherwise, knowing that the array has a maximum size of 9000 is still no good because if it only has 100 elements in use, you should only loop over those 100 elements and leave the remaining 8900 untouched. (I note you mentioned a maximum of 40000 elements earlier, so it is actually a maximum of 9000?)Originally Posted by MMG
With a parameter for the number of elements, you can then malloc exactly that number at one go instead of incrementally doing malloc calls to expand the dynamic array.
Your "array parameter" for grades is already a pointer, just with array rather than pointer syntax, but it remains a pointer parameter either way. I would expect the function to look like this:
where HASHTABLE is replaced by the declaration of a pointer parameter designating the hash table of students so that you can add the new student record to it.Code:void addsStudent(HASHTABLE, int id, int *grades, int num_grades)
Look up a C++ Reference and learn How To Ask Questions The Smart Way
