<p>Suppose <code>a</code> and <code>b</code> are both of type <code>int</code>, and <code>b</code> is nonzero.  Consider the result of performing <code>a/b</code> in the following cases:</p>

<ol>
<li><code>a</code> and <code>b</code> are both nonnegative.</li>
<li><code>a</code> and <code>b</code> are both negative.</li>
<li>Exactly one of them is negative.</li>
</ol>

<p>In Case 1 the result is rounded down to the nearest integer.  But what does the standard say about Cases 2 and 3?  An old draft I found floating on the Internet indicates that it is implementation dependent (yes, even case 2) but the committee is leaning toward making it always 'round toward zero.'  Does anyone know what the (latest) standard says?  Please answer only based on the standard, not what makes sense, or what particular compilers do.</p>

According to the May 2008 revision,
You're right:
The binary / operator yields the quotient, and the binary % operator yields the remainder from the division of the first expression by the second. If the second operand of / or % is zero the behavior is undefined; otherwise (a/b)*b + a%b is equal to a. If both operands are nonnegative then the remainder is nonnegative; if not, the sign of the remainder is implementation-defined75).
Note 75 says:
According to work underway toward the revision of ISO C, the preferred algorithm for integer division follows the rules defined in the ISO Fortran standard, ISO/IEC 1539:1991, in which the quotient is always rounded toward zero.
Chances are that C++ will lag C in this respect.  As it stands, it's undefined but they have an eye towards changing it.
I work in the same department as Stroustrup and with a member of the committee.  Things take AGES to get accomplished, and its endlessly political.  If it seems silly, it probably is.