C++ 如何使函数/变量局部于命名空间？

Question

I want to neatly declare functions and variables local to a namespace, so only namespace members can access them.

In lua, I would use a "local" keyword to do this (in a file/function). Is anything related possible in C++?

EDIT

Here's a pseudo-c++ sample of my code:

namespace wld {
    const int wldDivis = 4;
    void myFunc(){
        // wldDivis constant used here
    }
    void myFunc2(){
        // wldDivis also used here
    }
}

// Somewhere later
wld::myFunc();
wld::myFunc2();

The variable "wldDivis" is only ever used in namespace wld. How do I localize/"make it invisible" to outside namespace wld, as a "enforced opacity" if others might screw with the inner workings of my functions? Is a namespace well suited?

IE cannot be accessed outside the namespace ?

Answer 1

Variables declared in a namespace are accessible from the outside using qualifiers (mynamespace::myvariable). This is the way you can access std::cout, for example.

Access can be controlled within classes via the public , private and protected keywords.

A possible (and clumsy) fix would be to put your "globals" inside a class with private access and then make this class friend with the other classes and functions in the namespace. Not only is this a nightmare to maintain, but will also make impossible to access these globals if not from a friend .

On the other hand, clever declaration of your functions (so they operate on classes defined in the namespace and perform only related functionality) will instantly solve the problem: everything is accessible because it needs to be so.

Of course, there are far more experienced coders around so maybe someone can chip in with file level visibility, the "extern" keyword and such (I remember these were a thing in old C). In any case, is it possible that you provide us with a sample of your code to have a better view on the subject?.

Answer 2

AFAIK there is no access restriction in namespaces in C++.

namespace foo {
    void local_func() {}

    // local_func can be accessed inside the namespace

    void global_func() { local_func(); }
}

// ...

foo::local_func(); // local_func can be accessed outside the namespace

You can achieve something close with static member functions inside a class definition:

class foo {
    private:
        static void local_func() {}

    public:
        // local_func can be accessed inside the "namespace" of the class

        void global_func() { local_func(); }
};

// ...

foo::local_func(); // error : local_func is private to the class