Questionable programming (QP) in C++

In questionable progamming (QP), there are two kinds of possible return values for non-special member functions; these are bool and void, the two possible return values for non-special member functions.

bool function_name ()
{
  bool result (false);
  set_status (error_function_name_not_implemented);
  return result;
}

Note the structure. This is how all bool-returning functions must be written. They must always assume that the result is false. They must always give feedback. This is a general case because the function is not implemented and has nothing to show for it. Here's a more concrete example on structuring, but not so much on verbosity, but some (reset_error ()).

bool demonstration ()
{
  bool result (false);

  set_status (error_a); // Assumes a will return false.

  if (a ())
  {
    set_status (error_b); // Assumes b will return false.

    if (b ())
    {
      set_status (error_c); // Assumes c will return false..

      if (c ())
      {
        reset_error (); // (set_status (status_none);)
        result = true; // ..unless c doesn't.
      }
    }
  }

  return result;
}

Now, if the purpose of a function is to break a process into smaller pieces, resulting in a program flow which is easier to see, then that's the sole purpose of a function in questionable programming. Combine this with a descriptive use of words for functions, to make their use more clear. Observe that the function of functions is to act as language statements. You can view "if ()" the same way; "if" is a function which takes a bool as its input parameter, but in addition it's a language construct and gets the special treatment that allows the program to be structured in the C and C++ syntax way of things.

(A function that returns bool must work in an if-statement, but one that returns void will break an if-statement. No other return values exist.)

Questionable programming (QP) makes the program flow part clear. It effectively separates most of the data manipulation from the control logic, and it may make programs more verbose (it depends on the author).

So how does one return anything? If you know C++ then you already know; references. To return something you would use a reference. Of course, this is what a member function does; it manipulates internal state. It could also manipulate local state if it was passed a reference as a parameter, but in general, it would modify data members when called, though it is nothing wrong with modifying a parameter.

In summary

class song_t // "a song type (_t)"
{
  public:

    enum status_t // a status type (_t)
    {
status_none
    };

  public:

song_t ()
    : m_status (status_none)
    {
    }

    void set_status (status_t const status)
    {
      m_status = status;
    }

  private:

    status_t m_status;
};

One last thing in general C++ programming; use const wherever possible. The more the compiler knows beforehand..

int main (int const argc, char const * const * const argv)
{
}

LRESULT CALLBACK WindowProcedure
(
  HWND const window,
  UINT const message,
  WPARAM const W,
  LPARAM const L
)
{
  // (...)
}

(PS: The verbosity part could probably need more words.)