Defensive Programming with Assertions

Defensive programming is a style of programming that anticipates potential errors and takes steps to prevent or mitigate them. Assertions are a key tool in defensive programming, as they allow you to express and validate assumptions about your code.

Here are some ways to use assertions for defensive programming:

Example 1: Check function preconditions:

1int strlen(const char* str) {
2  assert(str != nullptr);// ...
3}

Example 2: Validate function postconditions:

1int pop(std::stack<int>& s) {
2  assert(!s.empty());
3  int top = s.top();
4  s.pop();
5  assert(top == s.top());
6  return top;
7}

Example 3: Verify loop invariants:

1int sum(const std::vector<int>& v) {
2  int total = 0;
3  for (size_t i = 0; i < v.size(); ++i) {
4    total += v[i];
5    assert(total >= 0);
6  }
7  return total;
8}

Example 4: Check switch cases and if-else chains:

1char to_lower(char c) {
2  switch (c) {
3    case 'A': return 'a';
4    case 'B': return 'b';
5// ...
6    default:
7      assert(false && "Invalid character");
8  }
9}

Example 5: Test user input:

1void save_preferences(int pref) {
2  assert(pref >= 0 && pref < 10);// ...
3}

Some tips for effective defensive programming with assertions:

• Be liberal with assertions. It's better to have too many than too few.
• Assert as close to the source of the error as possible.
• Don't use assertions as a substitute for error handling. Assertions are for detecting bugs, not for expected error conditions.
• Leave assertions enabled in debug builds to catch problems early.
• Consider writing unit tests to exercise assertions and edge cases.

Remember, the goal of defensive programming is to make your code fail quickly and visibly when something goes wrong, rather than silently producing incorrect results. Assertions help you achieve this by making your assumptions explicit and verifiable.