将静态成员的作用域限制为n个特定的类

Limiting the scope of a static member to n specific classes

本文关键字：静态成员 作用域      更新时间：2023-10-16

如何将静态成员的作用域限制为n个特定的类?例如，如果我创建类A的a1对象和类A的a2对象，我希望这些对象(用A创建的a1, a2)的静态成员可以有不同的值，但对应的派生类可以有相同的值。

  class A{
    public:
           A(int member){
               A::mMember=member;}
           void set(int member){
               A::mMember=member;}
           int get(){
               return A::mMember;}
        protected:
           static int mMember;
    };
    int A::mMember;
    class B:public A{
    public:
        B(int member):A(member){};
    };
    class C:public A{
        C(int member):A(member){};
    };
    int main()
    {   
      A * a1= new A(1);
         std::cout<<"a1: "<< a1->get()<<std::endl;
         B * b1= new B(2);
         std::cout<<"a1: "<< a1->get()<<std::endl;
         // How to make a1 continue be a1=2 and a2 = 5. I mean how to limit a static member     
         //to  only its derivated class
         A * a2 = new A(5);
         std::cout<<"a1: "<< a1->get()<<std::endl;
         std::cout<<"a2: "<< a2->get()<<std::endl;
    }

静态成员的全部意义在于它"在任何地方都是一个"[不是没有限制，但为了这个问题的目的，让我们忽略这一点]。

在您的示例代码中，似乎您希望b1 = B(2)改变A值，但a2具有mMember的新值。这在使用静态成员时是不可能的。

对我来说，似乎你真正想要的是一个工厂函数，它知道什么时候需要一个新对象，什么时候不需要，并在相关的构造函数中传递对该对象的引用，或者某种存储(通过a中的静态成员函数)。

在第一种情况下，它看起来像这样:

class A
{
    public:
       A(int member, int &ref_member) : mref_member = ref_member
       {
           A::mMember=member;
       }
       void set(int member)
       {
           A::mMember=member;
       }
       int get(){
           return A::mMember;
       }
    protected:
       static int mMember;
};
int A::mMember;
class B : public A
{
    public:
        B(int member, int &ref_member) : A(member,ref_member)
        {
        };
};

A* maker(int v, bool needs_new_ref, char type)
{
     static int *ref = NULL;
     if (needs_new_ref || !ref)
     {
        ref = new int;
     } 
     switch(type)
     {
         case 'A':
             return new A(v, ref);
             break;
         case 'B':
             return new B(v, ref);
             break;
     }
 }

第二个选项涉及如下函数:

 int& ref(int id)
 {
    static map<int, int> refs;
    return refs[id];
 }

需要引用时调用ref(id)。你需要找到一种方法来生成"id"。

根据你想要达到的目标，可能有很多其他的解决方案。我很确定你的问题是一个XY问题——你问如何做Y，因为你认为这是实现x的正确方法。

相关文章：