Floor Division in C++: Integer / Truncates Toward Zero, Not Toward -∞
C++ integer division with / truncates toward zero — it does not floor toward negative infinity. For positive numbers this is identical to floor division, so the difference is invisible until negative numbers appear. For float floor division, use std::floor() from <cmath>. Understanding this prevents subtle off-by-one bugs in algorithms, circular indexing, and anything involving negative offsets.
Integer /: Truncation Toward Zero (C++11 Guaranteed)
// Positive: integer / gives the integer quotient directly
std::cout << 10 / 3 << "\n"; // 3
std::cout << 15 / 4 << "\n"; // 3
std::cout << 20 / 3 << "\n"; // 6
// Negative: truncates toward ZERO, not toward -∞
std::cout << -10 / 3 << "\n"; // -3 (truncation: -3.33 → -3)
// Python: -10 // 3 = -4 (floor: -3.33 → -4)
// C++ truncates; Python floors — they differ for negative operands
std::floor() for True Floor Division
To get floor semantics (round toward −∞), use std::floor() from <cmath> for floats, or a helper for integers:
#include <cmath>
// True floor division for integers:
int floorDiv(int a, int b) {
int q = a / b; // truncates toward zero
// If signs differ and there's a remainder, subtract 1 to floor
if ((a ^ b) < 0 && q * b != a) q--;
return q;
}
std::cout << 10 / 3 << "\n"; // 3 (truncation)
std::cout << floorDiv(10, 3) << "\n"; // 3 (floor — same for positives)
std::cout << -10 / 3 << "\n"; // -3 (truncation)
std::cout << floorDiv(-10, 3) << "\n"; // -4 (floor — matches Python)
// For floats, std::floor() directly:
std::cout << std::floor(-10.0 / 3) << "\n"; // -4.0
The % Operator: Remainder, Not Modulo
C++'s % is a remainder operator — its sign follows the dividend (like Java, unlike Python):
// Positive: fine
std::cout << 10 % 3 << "\n"; // 1
// Negative dividend: remainder is negative
std::cout << -10 % 3 << "\n"; // -1 (C++ — sign follows -10)
// Python: -10 % 3 = 2 (Python — sign follows 3)
// Python-style always-non-negative modulo in C++:
auto pyMod = [](int a, int b) { return ((a % b) + b) % b; };
std::cout << pyMod(-10, 3) << "\n"; // 2 — matches Python
Quotient and Remainder (Positive Values)
#include <iostream>
using namespace std;
int main() {
int dividend = 26;
int divisor = 3;
int quotient = dividend / divisor; // 8
int remainder = dividend % divisor; // 2
cout << "Quotient: " << quotient << "\n"; // 8
cout << "Remainder: " << remainder << "\n"; // 2
cout << (quotient * divisor + remainder == dividend) << "\n"; // 1 (true)
return 0;
}
Real-World Patterns
// 1. Convert seconds to minutes and seconds:
int totalSeconds = 137;
int minutes = totalSeconds / 60; // 2
int seconds = totalSeconds % 60; // 17
cout << minutes << "m " << seconds << "s\n"; // "2m 17s"
// 2. Binary search midpoint (no overflow):
int left = 0, right = INT_MAX - 1;
int mid = left + (right - left) / 2;
// 3. Total pages needed (ceiling division):
int totalItems = 95, perPage = 10;
int pages = (totalItems + perPage - 1) / perPage; // 10
cout << pages << " pages\n";
// 4. Distribute items into rows:
int items = 29, perRow = 4;
int fullRows = items / perRow; // 7
int leftover = items % perRow; // 1
cout << fullRows << " full rows, " << leftover << " left over\n";
Key Takeaways
- C++ integer
/truncates toward zero — not floor. Differs from Python's//for negative operands (C++11 guarantees this). - For true floor division, use
std::floor(a / b)for floats, or implement afloorDiv()helper for integers. - C++
%can be negative when the dividend is negative — use((a % b) + b) % bfor always-non-negative modulo. - For positive inputs only, plain
/and%work exactly as expected.
What to Learn Next
With integer division solid, explore C++'s <cmath> functions: std::ceil() for ceiling division, std::round() for nearest-integer rounding, and std::abs() for absolute value. Apply modulo to algorithm problems: checking even/odd (n % 2 == 0), circular array indexing (with the pyMod pattern above), and hash table implementations where negative indices must wrap correctly.
