Where should I put functions that are not related to a class?

Question

I am working on a C++ project where I have a bunch of math functions that I initially wrote to use as part of a class. As I've been writing more code, though, I've realized I need these math functions everywhere.

Where is the best place to put them? Let's say I have this:

class A{
    public:
        int math_function1(int);
        ...
}

And when I write another class, I can't (or at leat I don't know how to) use that math_function1 in that other class. Plus, I've realized some of this functions are not truly related to class A. They seemed to be at the beginning, but now I can see how they're just math functions.

What is good practice in this situation? Right now I've been copy-pasting them into the new classes, which I'm sure is the worst practice.

Answer 1

C++ can have non-method functions just fine, if they do not belong to a class don't put them in a class, just put them at global or other namespace scope

namespace special_math_functions //optional
{
    int math_function1(int arg)
    {
         //definition 
    }
}

Answer 2

Depends on how the project is organized and what sort of design patterns you are using, assuming this is strictly utility code you have the following options:

• If you don't have to use objects for everything you could do something simple like just putting them all in a file without a class wrapper around them. This could be with or without a namespace although the namespace is recommended to prevent any issues in the future.
• For managed C++ you can create a static class to contain them all; however, this doesn't really work the same as an actual class and my understanding is that it is a C++ anti-pattern.
• If you aren't using managed C++ then you can just make use of static functions to allow you to access them and have them all contained in a single class. This may be useful if there are also other functions that you would want a proper instantiated object for by may also be an anti-pattern.
• If you want to ensure that only one instance of the object containing the functions will exist then you can use the Singleton Pattern for a utility class which also allows you some flexibility in the future as you now have access to non-static attributes. This is going to be of limited use and only really applies if you need an object for some reason. Odds are if you do this you will already know why.

Note that the first option is going to be the best bet and the following three are of limited usefulness. That said though, you might encounter then just due to C# or Java programmers doing some C++ work or if you ever work on C# or Java code where the use of classes is mandatory.

Answer 3

As you already said, copy-pasting the code is the worst form of code reuse. If you have functions that don't belong to any of your classes or may be used in for several scenarios, the best place to put them would a helper or utility class. If they don't use any instance data, they can be made static, so you don't need to create an instance of the utility class to use it.

See here for a discussion of static meber functions in native C++ and here for static classes in managed C++. You could then use this utility class wherever you would have pasted your code.

In .NET for instance, things like Min() and Max() are provided as static members on the System.Math class.

If all your functions are math-related and you would otherwiese have a gigantic Math class, you might want to break it down further and have classes like TrigonometryUtilities, EucledianGeometryUtilities and so on.

Another option would be to put shared functionality into a base class of the classes requiring said functionality. This works well, when the functions in questions need to operate on instance data, however, this approach is also less flexible if you want to avoid multiple inheritance and only stick to one base class, because you would be "using up" your one base class just to get access to some shared functionality.