I did several searches on the _alloca function and it is generally not recommended. I will have a dynamically updated array of strings on which I will have to iterate often. I would like to have each string allocated on the stack to reduce the miss caches as much as possible.

Using _alloca I could create a char* on the stack and put it in the vector. My char will be in a vector which will not impact my stack and I know that the strings will never be big enough to make a stackoverflow when I allocate them on the stack.

Is it a bad thing to use it in this case?

Does the program do what I want it to do?

#include <vector>
#include <cstring>

#ifdef  __GNUC__
# define _alloca(size) __builtin_alloca (size)
#endif /* GCC.  */

std::vector<const char*> vec;

void add(const char* message, int size) {
  char* c = (char*) _alloca (size * sizeof(char*));
  std::memcpy(c, message, sizeof(message));
  vec.push_back(c);
}

int main() {
  const char* c = "OK";
  for (int i = 0; i < 10;   i) {
    add(c, 2);
  }
}

CodePudding user response：

Stack memory allocated by _alloca gets automatically released when the function that calls _alloca returns. The fact that a pointer to it gets shoved someplace (specifically some vector) does not prevent this memory from being released (as you mentioned you assumed would happen, in the comments), that's not how C works. There is no "garbage collection" in C .

Therefore, the shown code ends up storing a pointer to released stack memory. Once add() returns, this leaves a dangling pointer behind, and any subsequent use of it results in undefined behavior.

In other words: yes, it's "a bad thing to use it in this case", because be the shown code will not work.

There are also several other, major, issues with this specific _alloca call, but that's going to be besides the point. This entire approach fails, even if these issues get fixed correctly.