For now i have passed the grid size through template variables, assuming higher performance, but then i thought that ill probably need to have the ability to create one with a run time defined size. That requires passing the size in the constructor. Is there a way to allocate a member array of size determined by the constructor passed variable(s) on the stack?
something like
class MyClass
{
MyClass(int x){};
array[x] MyArray;
};
with a bunch of keywords here and there.
Is this even possible?
If i want to use runtime defined size, do i need to allocate on the heap?
Should i allocate on the heap anyways (should large allocations on the stack be avoided?)?
EDIT: using full editor got rid of all enter spacing and collapsed the whole post into a text wall :c
Allocating array of runtime defined size on the stack?
Stack allocators exists, but they're non-standard and you shouldn't mess with a custom allocator unless you really know what you're doing. Sounds like you're trying to optimize in the wrong place.
Just allocate on the heap. Large objects on the stack should be avoided because the stack is usually pretty small (when compared to the heap) so it's easy to run out of space, especially if you ever do anything recursive.
Why do you have an aversion to allocating on the heap in this situation? The stack isn't magically faster than the heap. It's all just stored in your RAM. Putting too much on the stack, or in the wrong order, may mess with your cache hit/miss rate, too.
Author
By allocating on the stack i meant for example passing the size as a template variable like i do now, but id like to do that without template variables.<br /><br />But now that i think about it, it wouldnt be possible, since if it were i could have 2 objects of the same type but with a different size.<br /><br />Ill just create different classes for heap and stack allocated arrays (grids in my case)
I know that the stack as memory isnt any faster, but if i were to have a small array as a part of a object that is initialized a lot, it would probably be more efficient to have it be a part of the object instead of each object pointing to a random location in RAM.
I know that the stack as memory isnt any faster, but if i were to have a small array as a part of a object that is initialized a lot, it would probably be more efficient to have it be a part of the object instead of each object pointing to a random location in RAM.
Author
<blockquote class="ipsBlockquote" data-author="ultramailman" data-cid="5014001"><p>Maybe what you are looking for is static variables in the class scope?</p></blockquote><br />nope.<br /><br />I realized the reason i originally used template variables instead of ones passed through a method was to give the responsibility of allocation outside the class, not inside, so that i can decide wether i want the array as a part of the object or as a pointer to the heap.<br /><br />Now i made it StackGrid and HeapGrid, but i guess it should actually be HeapGrid(StackGrid), DynamicGrid, where HeapGrid is simply an additional layer over StackGrid to allocate it on the heap (HeapGrid and StackGrid having a predefined size, and dynamicgrid a runtime defined size)
There is a C idiom for this kind of thing called the "struct hack" that was widespread enough that the C99 spec made it part of the language. Basically you make the last member of the struct an array with 1 element or 0 elements if the compiler supports it. Then when creating the object you allocate room for the struct header and the array. For example:
struct String {
size_t length;
char data[];
};
String * create_string(const char * str) {
size_t length = strlen(str);
String * new_string = malloc(sizeof(String) + length);
new_string->length = length;
memcpy(new_string->data, str, length);
return new_string;
}
Author
<blockquote class="ipsBlockquote" data-author="SiCrane" data-cid="5014024"><p>There is a C idiom for this kind of thing called the "struct hack" that was widespread enough that the C99 spec made it part of the language. Basically you make the last member of the struct an array with 1 element or 0 elements if the compiler supports it. Then when creating the object you allocate room for the struct header and the array. For example:</p><pre class="_prettyXprint _lang-code _linenums:0">
struct String {
size_t length;
char data[];
};
String * create_string(const char * str) {
size_t length = strlen(str);
String * new_string = malloc(sizeof(String) + length);
new_string->length = length;
memcpy(new_string->data, str, length);
return new_string;
}
</pre>Some C++ compilers support flexible array members as an extension as well.<br /> <br /><p><br /></p></blockquote><br />Wouldnt that also work by specifying the array lenght using a template variable?
struct String {
size_t length;
char data[];
};
String * create_string(const char * str) {
size_t length = strlen(str);
String * new_string = malloc(sizeof(String) + length);
new_string->length = length;
memcpy(new_string->data, str, length);
return new_string;
}
</pre>Some C++ compilers support flexible array members as an extension as well.<br /> <br /><p><br /></p></blockquote><br />Wouldnt that also work by specifying the array lenght using a template variable?
Wouldnt that also work by specifying the array lenght using a template variable?The problem with that is that template parameters are compile time constants. What SiCrane posted works at runtime.
This topic is closed to new replies.
Advertisement
Popular Topics
Advertisement
