Can't use "static" keyword on a static method in a c++ class implementation file (.cpp)

Question

Consider:

// In Vector2.h

class Vector2
{
    public:
        // returns the degrees in radians
        static double calcDir(double x, double y);
}

// In Vector2.cpp

double Vector2::calcDir(double x, double y)
{
    double rad = ...;
    return rad;
}

Why isn't the keyword static required in the signature in Vector2.cpp? When I try this, it produces an error:

static double Vector2::calcDir(double x, double y)

It seems inconsistent to me. All other parts of the method signature are required to be repeated in the .cpp file (return type, method name (duh), names and types of args, const-ness). I don't like not knowing at a glance whether a method is static or not (when looking at the implementation).

Is there a reason this is not only not required, but forbidden?

Answer 1

It's because static has a special meaning when used in a class definition. In a class definition it identifies the function as a static member function which means it doesn't operate on a class instance but can be called independently.

Outside of a class static gives a function internal linkage but this is illegal on (even static) member functions because class members must have the same linkage as the class of which they are a member (almost always external, and certainly external in cases where you can defined member functions outside of the class definition).

From a language point of view, the declaration of members inside a class definition follows one set of language rules where static has its special class meaning. Outside of a class definition, all function definitions - members and non-members - follow the same set of rules where static has it's other meaning which is not valid for members of classes with external linkage.

Answer 2

This is probably to reduce confusion. At file scope, 'the keyword static is (confusingly) used to mean "use internal linkage" (TC++PL p.200). It could imply that the function, though a member of a class, was only visible inside the current translation unit. Allowing the static specifier there would be more confusing.

Note that using static to denote internal linkage is no longer recommended, and that anonymous namespaces should be preferred to achieve that.

Answer 3

It is annoying that keyword wound up invoking two very different functionalities (global-to-all-class-instances vs. local-to-file) but the following small header may be of use. The macro just expands to an empty string meaning you can tack it in front of the declarations of methods in the implementation file and coming back to your code a year later you'll avoid pouring through a 2000-line "boost-esque" header to find out why the compiler won't let you use this.

staticmethod.h:

/*
** macro sugar for maintaining readability
** of static methods in implementation files
*/
#ifndef STATICMETHOD
#define STATICMETHOD

In your .cpp files you could then use:

#include "staticmethod.h"
STATICMETHOD double Vector2::calcDir(double x, double y)
{
    double rad = ...;
    return rad;
}