What's the best way to force the user of a C++ function to acknowledge the semantic meaning of parameters that are numerical constants?

I'd like to write function interfaces that force the user to acknowledge the semantic meaning of built-in constants. For example, I'd like to take

void rotate(float angle); // Rotate the 开发者_运维知识库world by an angle in radians.

and change it to

void rotate(Radians angle);

Am I right in believing that the problem with making a Radians class is that it adds code and makes the program slower. Is there a better way to do this?

No, it is possible to make a Radians class that should be optimized by most decent compilers into something that's no slower than a plain float. You might be interested in boost.units.

In fact, with boost.units you can even set it up so that if someone wants to pass in an angle in degrees it will automatically be converted to radians before being passed to the function. That will possibly slow things down a bit, but it arranges it so you can change what units a function wants without having to go back and edit a whole ton of code.

And, when you finally do want to go and edit all the code, you can temporarily fix it so the conversion doesn't work and let the compiler find it for you.

Being able to make the compiler enforce constraints like this for you with no runtime penalty and possibly even write all the conversion code for you (at a very tiny runtime penalty) is one of the really neat things about C++ and makes it worth the added complexity over C.

Here is a really simple version of what this class might look like if you hand coded it:

#include <cmath>

// This class is tiny enough because it has no virtual functions and only one
// data member that it's likely more efficient to pass by value than by
// reference.
class Radians {
 public:
   // If you don't put in explicit, the compiler will automatically convert a
   // float to a Radians for you and undo all of the hard work you did to make
   // sure callers express their intentions.
   explicit Radians(float radians) : value_(radians) {}

   float getValue() const { return value_; }
   void setValue(float radians)  { value_ = radians; }

   float asDegrees() const { return value_ * 180 / M_PI; }

   // This allows you to say Radians r = Radians::fromDegrees(something);
   static Radians fromDegrees(float degrees) {
      return Radians(degrees * M_PI / 180);
   }

 private:
   float value_;
};

Notice how all of the functions are declared in the class body. This makes them all implicitly have the inline keyword. A good compiler will optimize all of those functions out of existence. Of course, the conversion functions will generate the code to do the conversion, but otherwise it'll be the same as having a bare float.

The key to this constraint is to declare your constructor explicit:

class Radians
{
public:
  explicit Radians(float value) : m_value(value) {}
private:
  float m_value;
};

That way your user can't type rotate(4.5). They'll have to type rotate(Radians(4.5)).

This is the perfect way to do this. Thats what makes C into C++. Using classes where you need them and encapsulate data. It does not make program any notable slower, since compiler does all the optimizations.

It does not need to be slower.

The Ogre3d library have a Radian class. The assembly generated is exactly the same as that of using a float directly(atleast when I last tested under gcc with optimization enabled)

It is absolutely possible to write OOP code that is as efficient as the procedural code. Even more, sometimes you can gain surprising speedups if you take advantage of the added semantics or class-based code. One of the great examples of such an advantage is std::swap. Yes, use templates ;).

What makes it possible to write an effective Radian class is inlining. However, use it wisely!

Checklist:

• read about efficient inlining
• take care to have an explicit constructor
• take care to properly use the keyword const where applicable
• read about Optimizing C++
• finally, if you do a lot of expressions involving your class, google up about Expression Templates

With the simplest versions (a typedef, a class with one member attribute and inlined accessors) the compiler can make it just as fast the plain float version.

Also consider using some metaprogramming library like boost.units.

Slower is in the eye of the beholder. How often do you call this code? Yes, you'll be creating bigger items on the stack when passing a Radians class than a primitive float.

void rotate(float radians);

void rotate(const Radians &angle);

which would presumably be faster than passing by value.