Instead of merely testing a boolean expression, you can assign the expression to a variable that makes the implication of the test unmistakable.

The following code was my first try, not employing the tip.

void CETabWidget::wheelEvent(QWheelEvent *e)
{
  QTabBar *tabs = tabBar();
  if (e->y() < tabs->y() || e->y() > (tabs->y() + tabs.height())) {
    e->ignore();
    return;
  }
 
  // handle wheel event
}

Even though I wrote the code myself, I have problems understanding it. And making sure it’s correct takes more than a quick glance. If you want to understand this code in six months, you have to add a comment. So let us take a look at the same code rewritten to use two extra booleans.

void CETabWidget::wheelEvent(QWheelEvent *e)
{
  QTabBar *tabs = tabBar();
  const bool cursorAboveTabBar = (e->y() < tabs->y());
  const bool cursorBelowTabBar = (e->y() > (tabs->y() + tabs->height()));
  if (cursorAboveTabBar || cursorBelowTabBar) {
    e->ignore();
    return;
  }
 
  // handle wheel event
}

Now you can quickly figure out that the wheel event is only handled if the cursor is inside the tabBar. And it’s actually possible to take a quick look and be sure that the code is doing what it’s supposed to.

Of course, for this to be of any good, you need to give the boolean variables meaningful names. Naming them a and b wouldn’t help a bit.

The best thing with this approach? You don’t have to write comments and still get code that people can understand. Ah, the joy!

First: “the named return value extension”. The idea is to avoid creating a temporary variable that’s assigned a value and then returned by value, thus creating an unnecessary copy. A small example:

std::list<int> foo(int j) return l();
{
  l.push_back(j);
}

This example will create just one list and append j to that. Without this extension a local list needs to be created, j appended to that and the copy constructor invoked when returning. This extension is deprecated in g++ 3.3 and removed in g++ 4.0.

My other example is the “min and max operators”. No, this is not about min and max macros nor the std::min and std::max functions. This is the min and max operators.

int min = x <? y;
int max = x >? y;

There is of course also a short-hand version for assigning one of the variables the smallest (or biggest) value of the two.

x <?= y;
x >?= y;

They are all deprecated in g++ 4.0.

std::list<std::string> myStrings;

The only problem with this is that you need to remember to call delete on every element in that list before myStrings goes out of scope. That’s not a big problem you may argue, just iterate trough the whole list and delete them.

std::list<std::string *>::iterator it = myStrings.begin();
std::list<std::string *>::const_iterator end = myStrings.end();
while (it != end) delete *it++;

But when you have many containers with pointers, this duplication of code tends to become tedious. This is where templates and for_each comes into play. Add the following code to a header filer.

/// A function with the sole purpose of deleting @a ptr
template<typename T>
inline void deletePtr(const T& ptr) { delete ptr; }
 
/// Calls delete on every element in @a container
template<typename T>
inline void deleteAllPtr(const T& container)
{
  std::for_each(container.begin(), container.end(),
                deletePtr<typename T::value_type>);
}

Then, when you wish to delete a container with pointers, just include the header file and call

deleteAllPtr(myStrings);

Simply beautiful