Question

Earlier，我问了一个关于如何调用静态成员的成员函数的问题，以便在实际使用静态对象之前对其进行初始化。然后，我意识到我可能以错误的方式使用静态成员，这导致了这个问题：

给定一个特定的类MyClass，我们可以通过多少种方式设计代码，以便MyClass可以访问另一个类YourClass的成员函数？ [注：假设MyClass在MyClass.h中声明MyClass.cpp并在YourClass中定义，以及YourClass类似的一般情况。]

我能想到一些，但远非专家，我猜你可以说出其他几个：

遏制：这可以有几种'风格'，直接包含class MyClass { public: // Some MyClass members... private: YourClass instance; // or YourClass* instance / YourClass& instance; // Some other MyClass members... };对象是一个选项，而包含对象的指针或引用是另一种选择：< / p>

YourClass

a）当然，直接遏制很方便，但我可以想到一个直接的缺点：如果MyClass在内存要求方面有点大，而且你有几个{ {1}}实例（如在我的链接问题中），直接包含对象将是不可能的。此外，有一个关系并不总是有意义的。

b）在这种情况下，拥有指针或对象的引用可能更有意义。使用引用的问题是，您最终可能会引用一个不再存在的对象，因此您必须确保YourClass对象在MyClass对象存在的持续时间内存在

c）对于指针，上面的问题仍然存在，但您可以更轻松地将指针重新分配给新对象。

继承：可以从YourClass对象继承，以便继承成员，例如：

class MyClass : public YourClass
{
public:
  // Some MyClass members...
private:
  // Some other MyClass members...
};

a）设置几个类也很简单，但对于一般用途可能会变得难以处理。例如，如果YourClass是一个随机数生成器，那么说MyClass 是一个随机数生成器并不一定有意义。当然可以为随机数生成器定义一个包装类，比如称之为Randomizable，然后MyClass可以从Randomizable继承，这很有道理。

我个人希望更多地了解静态成员，全局对象，单例以及如何正确使用它们的优缺点。那么，从“元”的角度来看，还有哪些其他方法或模式可行？

PS。虽然我从C ++的角度提问，但我想可以说同样适用于许多其他面向对象的语言，所以不要担心用其他语言提供示例。

Answer 1

有关于C ++类成员资格访问的基础知识。

您可以访问自己的直接成员（公共，受保护或私有）

class Foo {
public:
     int fooMember;
};

int main() {
     Foo foo;
     foo.fooMember = 1;
}

您可以在子类中访问父类的保护和公共成员，然后根据子类声明中的继承指示符将父成员传递给public，next-child或保持私密

class Animal { 


protected:
     int feet;
     int age;
public:
    enum color { blue, red, green, pink } color;


 Animal(int feet) { this->feet = feet; }
 bool getFeet() { return feet; }
 void setAge(int a) { age = a; }


};


class Elephant: public Animal {


public:


 Elephant(void):Animal(4) { }
 int hasFeet(void) { return (feet > 0); }


};


// Here you can override stuff too so:


class Fish: protected Animal {
public: 
        int teeth;
        enum Type { freshWater, saltWater } type;
    Fish(void):Animal(0) { }
};


class Mackerel: private Fish {


public:
        Mackerel(): Fish() { teeth = 12; } /* compiles */
};


class SubMackerel: public Mackerel { 
public:         
  SubMackerel() { teeth = 8; } /* does not compile teeth not accessible here */
} ;


int main() {
     Elephant pink;
        Fish fishy;
        Mackerel mack;
        pink.color = Animal::blue;
        // this won't compile since color is protected in Fish
        // fishy.color = green;
        fishy.type = freshWater;
        // mack.type = saltWater; // will fail
}

最后一种方式是宣布朋友。朋友类可以访问所有类的公共和私人成员。

这应该是一个开始......你可以read more about it

Answer 2

我一直在寻找关于同样事情的答案，并降落在这里。反正买，至少我应该告诉你到目前为止我对这个问题的了解。

避免使用另一个类作为数据成员，如果不是这种情况并且您必须使用它，则使用指向另一个类的指针。
现在，如果你使用指向另一个类的指针，总是深拷贝，所以你必须提供一个带有深拷贝的拷贝构造函数，以避免无效的地址分配。
或者只是使用智能指针。

一个类可以以什么方式访问另一个类的成员？

2 个答案: