Question

如何将静态成员的范围限制为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;

    }

Answer 1

静态成员的全部意义在于它是“无处不在的”[不是没有限制，但为了这个问题的目的，我们忽略它]。

在您的示例代码中，您似乎希望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的正确方法。

将静态成员的范围限制为n个特定类

1 个答案: