实现没有作用域解析运算符的类？

Question

If I declare my class in a header file, is there any way to implement the class without all those annoying scope resolution operators? I don't like rewriting the class name for each member. I think I have tried to do it like this before:

In Ah

#if !defined(a_h)
#define a_h
class A {
    int function (int);
    int foo (void);
};
#endif

In A.cpp

#include "A.h"
class A { 
     int function (int number) {
         return 2* number;
     }
    int foo (void){
        return 2;
    }
}

but got some error (unable to test it now unfortunately).

Answer 1

You can use pre-processor macros to make it easier.

#include "A.h"
#ifdef _
#undef _
#endif
#define _(fun) A::fun

int _(function)(int number)
{
   return 2* number;
}

int _(foo)(void)
{
   return 2;
}

However ...

You shouldn't necessarily do something just because you can.

Using a preprocessor macro to hide an important construct of the language is ill-advised. Here are some things to think about before you go down that path.

1. The time spent writing <ClassName>:: fades in comparison to the amount time spent in writing rest of the code in any program that does something useful.

2. The amount of time you will spend in debugging and maintaining a program will be much much higher than the amount of time you'll spend in writing <ClassName>:: .

3. When you have multiple classes in a .cpp file, you will have a hard time clearly seeing which function corresponds to which class if you adopt the same policy for all classes.

4. When you are debugging, you will be frustrated that you won't be able to see the fully qualified function name when you step into a function.

5. The loss of clarity is too expensive a price to pay in exchange for saving a few key strokes while implementing the member functions of a class.

I am speaking from experience. I work in a project where one of the class names is INR_DynamicallyTypedLowFidelityLeafComponentRepresentation . I wouldn't use a preprocessor macro to hide even that long a name.