How widely used is alloca in the real world? Should I teach my students to use alloca when it makes sense? Or should I teach them never to use it? Coming from a C++ RAII background, the idea of not having to call free manually sounds promising, especially in functions with multiple exit points.

Many good questions generate some degree of opinion based on expert experience, but answers to this question will tend to be almost entirely based on opinions, rather than facts, references, or specific expertise.
If this question can be reworded to fit the rules in the help center, please edit the question.

@cnicutar alloca() is implementation-dependent but at least many implementations return NULL on failure. C99 VLAs have no way to indicate failure.
–
Complicated see bioOct 25 '11 at 13:53

2

@sbi: For SO this is an open-ended question that doesn't really fit the format of what the closers think SO posts ought to be. It is too subjective, there is no clear cut answer, merely opinion. Which is fine but not for SO. Notice also that out of respect for the OP's rep no one is down voting, we're just closing this question as off topic.
–
Paul SasikOct 25 '11 at 13:54

1

@PascalCuoq You shouldn't be allocating a lot with alloca / VLAs anyway. If unsure what "a lot" is in the current context, use malloc.
–
cnicutarOct 25 '11 at 13:56

6 Answers
6

If you are holding a course in general C programming, you shouldn't teach them a thing that is not in the standard. Beginner programmers needlessly writing non-standard and/or non-portable code because they were taught that way, has been a huge problem for the software industry during the past 20-30 years or so. The cost for not teaching them the standard and nothing but the standard is likely astronomic.

If you are holding a more advanced course in algorithms or application programming, it might be good to mention it. On the other hand, I have programmed everything from hard realtime embedded apps to Windows application fluff for 15 years without ever using that function.

The only use I've seen where it wouldn't be better done another way was doing stack smash detection on some versions of Windows, where a failure to alloca indicated insufficient space left — or maybe it just had some gnarly ASM to catch the crash; it's been a while since I looked at that code. It worked, but was a bit of a horror.
–
Donal FellowsOct 29 '13 at 9:43

The answer to this question should be based on what your objectives are in the first place.

Do you want to teach someone who already knows how to program how to write C and work with existing C code in the wild? If so, tell about alloca and anything else you want.

On the other hand, if you are teaching an introductory course that only is using C by coincidence (and because C is a very small language and so on) you should focus on the important parts (writing modular programs, subroutines, collections, ...).
From a student's perspective, alloca is a bir redundant since malloc is enough in most cases and from a good-code perspective you are better off explicitely mentioning how manual memory management is annoying and how other languages deal with this problem After all, there are more things to memory management then alloca or RAII so you really shouldn't restrict yourself to these and as you mentioned already, its much easier to understand the purpose of alloca if you compare it to other "more standard" ways to do things in other languages (or C99...)

The only reason a C programmer should even be aware of alloca's existence is to understand and fix legacy code that's using it.

Any use of alloca is either

Useless, i.e. it could trivially be replaced by fixed-size variables of automatic storage duration, OR

A dangerous stack overflow waiting to happen.

Aside from a few thought experiments for which I have never found any real-world examples, there is no usage case for alloca (or VLA's) that's not either useless or vulnerable (one of the above 2 cases).

The only "responsible" use of alloc is 100% equivalent to fixed-size automatic arrays, and less portable.
–
R..Oct 25 '11 at 19:52

I guess, then, that nobody could ever want to allocate some dynamic amount, say, a few kilobytes which would never overflow. Or call some OS API function which will tell them how much is available. Or just increase the stack size to a lot.
–
DeadMGOct 25 '11 at 22:50

If it's a few KB and you're confident you have a few KB, you can just use T foo[5000]; or whatever.
–
R..Oct 26 '11 at 1:14

Only if T has a trivial default constructor. If I was performance-needy, even simple zeroing of memory might cost me. But other types can have even more complex default-construction logic. If I wanted to, for example, dynamically create an array of std::mutex, I might invoke a kernel call and context switch for five thousand mutexes. Not cheap. Not to mention the additional cache cost of placing local variables after the array.
–
DeadMGOct 26 '11 at 1:20

The GCC documentation has a couple practical pros and cons on alloca(). From a practical perspective, a decent amount of free software uses it, so it's good to be understand how it works and where it's used in existing code.

Passing -Wl,-stack=new-stack-size to gcc increases the maximum stack size; you'll need to do this if your project uses alloca(), or allocates large temporary arrays or uses recursion past a certain context-dependent depth.