++(variable) vs. (variable)++

Okay, I've been thinking about how (variable)++ works for a while. This is what I'm thinking:

Code:

(type) temp = (the_value);
(the_value) = (the_value) + 1;
return temp;

And this is my idea of how ++(variable) works:

Code:

(the_value) = (the_value) + 1;
return the_value;

Am I right, or at least close to right? And if so, wouldn't (variable)++ be slower?

++ is the same and += 1

Yes, you're right. Infact, this is exactly how it works in operator overloading. Oh; and yes it is slower.. for obvious reasons.

As an example:

Code:

// Postincrement eg. type++;
const bit bit::operator++(int)
{
	bit returnBit = *this;
	if (m_bit >= 32)
		throw(std::out_of_range("bit::prev(), max already attained!"));	

	++m_bit;
	return returnBit;
};

// Preincrement eg. ++type;
const bit bit::operator++()
{
	if (m_bit >= 32)
		throw(std::out_of_range("bit::prev(), max already attained!"));	

	++m_bit;
	return *this;
}

Ok, thanks My instructor guy told me that he always uses the pre-increment type in for loops since it's faster (marginally), but since most people around seem use the post-increment type, I sort of wondered.

Well in theory ++variable is faster, but keep in mind your compiler has the final word about this situation. I just played around with this (trying some code using both techniques) and the assembler that the compiler created for variable++ and ++variable was identical.

Yeah I dont think it matters that much in loops however makes a big difference in statements.

Also thats where C++ comes from ... an increment to C

Thought I'd share that

the assembler that the compiler created for variable++ and ++variable was identical.

there goes my theory! lol oh well, I'll stick to ++variable anyways, just in case

Also thats where C++ comes from ... an increment to C

If it were up to me, I'd make it ++C

Originally posted by Hunter2

If it were up to me, I'd make it ++C

lol

i perfer to use ++variable as it is slightly faster and matters in some applications i feel i might as well make it my habit.

Originally posted by Hunter2
there goes my theory! lol oh well, I'll stick to ++variable anyways, just in case

Not really, it's up to the compiler to do these optimizations for you. Use preincrement when possible, don't leave it up to the compiler to fix your code for you.

Ok

But then, maybe the compiler screwed ++variable up instead improving variable++