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

Closed. This question needs details or clarity。它当前不接受答案。
                            
                        
                    
                
                            
                                
                
                        
                            
                        
                    
                        
                            想改善这个问题吗？添加详细信息并通过editing this post阐明问题。
                        
                        5年前关闭。
                                                                                            
                
        
如何将静态成员的范围限制为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的正确方法。

关于c++ - 将静态成员的范围限制为n个特定的类，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/15906751/