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

如何将静态成员的范围限制为n个特定类？例如，如果我创建类A的a1对象和类A的a2对象，我希望这些对象（用A创建的a1，a2）对于它们的静态成员可以具有不同的值，但对于它们的相应派生类也是如此。将静态成员的范围限制为n个特定类

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; 

    }

来源

2013-04-09 user1310873

请写一个正确的问题。不要把整个问题放在一大堆代码中的单个评论中。 – 2013-04-09 15:57:39

为什么你不使用非静态成员变量？ – 2013-04-09 16:08:42

我在基类中有一个映射成员，当构造派生类时，派生类将相同的ID分配给映射，因为它继承该成员。 – user1310873 2013-04-09 16:13:13

的静态成员的全部意义在于，它是“一个到处” [并非没有限制，但让我们忽略了这个问题的目的。

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

来源

2013-04-09 16:37:45

+1“*我很确定你的问题是一个XY问题*”。 – ildjarn 2013-04-19 01:35:54

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

回答

相关问题