Problem with Programming Threads

[thumper]

I'm not trying to dodge it, I was trying to see if you would come to the realisation as I did.

What happens to this code when f() throws?

template <typename Func>
void
unbuffered_io_call(Func f) {
	termio curr, old;
	::ioctl(0, TCGETA, &curr);
	old = curr;

	curr.c_lflag = 0;
	curr.c_iflag = 0;
	curr.c_cc[VMIN] = 1;
	curr.c_cc[VTIME] = 0;	
	::ioctl(0, TCSETA, &curr);

	f();

	::ioctl(0, TCSETA, &old_);
}

That's why we use objects with destructors.

[LordHunter317]

Trivial to correct, you use an object internally, and wrap it's existence in the function. Then you return to syncrhonous mode in all cases, and you get correct scoping.

Yes, that was a bug in my code. However, it's correctable. The scoping issues with your solution are not correctable, without turning your code into my code. They're a design, not an implementation flaw.

[LordHunter317]

To be fair, that flaw does make my code near identical to yours.

However, I still prefer my form, because unlike wrapping someting in a std::auto_ptr, TerminalControl is not inoccuous. It has potential side effects on any function call, while the only side-effect of having a std::auto_ptr wrapped object in scope longer than necessary is excessive memory utilization.

However, it won't break your code. Having TerminalControl is scope longer than necessary will likely break your code (in non-subtle ways, non-obvious ways) so providing a non-member function to control it is worthwhile, as the scope is absolutely critical here.