通过引用授予子级访问父级成员的权限 - 可以吗？

Question

C++新手问题。 请验证我做得是否正确。

我有一个全局应用程序类生成它的小孩子，我需要让孩子们访问一些应用程序设施。 所以我决定把它们传给孩子们参考。

我测试了这个想法，如下所示。 看起来效果很好。 我只是想确保我没有做危险的事情。 可能有我忽略的陷阱吗？

爸爸创造了孩子并给了他们他的车钥匙：

#include <iostream>
using namespace std;

class CCarKeys
{
    public:
        CCarKeys(const string& Name) : _Name(Name) {}
        string _Name;
};

class CChild
{
    public:
        CChild(CCarKeys& CarKeys) : _Name("Child"), _CarKeys(CarKeys) {}
        string _Name;
        CCarKeys& _CarKeys;
        void TestHasKeys() {cout << "I got " << _CarKeys._Name << endl;}
};

class CDad
{
    public:
        CDad() : _Name("Dad"), _HondaCarKeys("Honda keys"), _ChevyCarKeys("Chevy keys") {}
        string _Name;
        CCarKeys _HondaCarKeys;
        CCarKeys _ChevyCarKeys;
        CChild *_Boy;
        CChild *_Girl;
        void MakeBoy() {_Boy= new CChild(_HondaCarKeys);}
        void MakeGirl() {_Girl= new CChild(_ChevyCarKeys);}
};

int main ()
{
    CDad Dad;

    Dad.MakeBoy();
    Dad.MakeGirl();
    Dad._Boy->TestHasKeys();
    Dad._Girl->TestHasKeys();
}

Answer 1

通过引用传递与通过指针传递完全相同，除了语义之外，以及如果通过引用传递，您无法对指针本身执行任何操作。

你的代码没问题。

Answer 2

在您的特定情况下，汽车钥匙不太可能被永久授予，而是根据需要进行请求并根据每个请求授予。 因此，

class Dad
{
   /** may return NULL if no keys granted */
   CarKeys *requestKeys(CChild forChild);
}

在主应用程序类和子级的更一般情况下，如何在 main() 中创建由应用程序和子级共享的数据对象，并将引用传递给每个人。

Answer 3

这是可能的，并且在您的代码中不会造成伤害。 但这很危险，因为如果复制 CDad，那么键和指针也会随之复制。 但是，指针指向的对象以及这些对象内部的引用将保持不变。 如果原始 CDad 对象超出范围，则指针引用的对象中的引用将悬空，不再引用有效对象。

也许你可以逆转生命周期：在堆上创建键，并将孩子作为类中的普通成员。 因此，如果你复制爸爸，孩子们就会被复制，但钥匙不会。 我认为密钥是不可变的，因此您可以在多个孩子之间共享相同的密钥。

这引出了另一点：如果您的密钥相当小（读：不是很大）并且不可变（因此，如果您更改一个密钥而不是其他密钥，则不会出现更新异常），请考虑创建它不 也在堆上 - 所以它们也会自动复制，并在孩子们需要密钥时将它们传递给他们。 你可以让它们成为孩子们的普通指针，但我认为这很丑陋，因为孩子不包含钥匙 - 但使用它。 因此，指针/引用或函数参数很适合，但不是“真正的”数据成员。

如果您要使用共享密钥和堆上密钥，您应该使用智能指针 - 因为您必须跟踪所有孩子和爸爸。 如果最后一个孩子/爸爸超出了范围，您必须再次删除该密钥。 为此，您可以使用 boost::shared_ptr ：

class CCarKeys
{
    public:
        CCarKeys(const string& Name) : _Name(Name) {}
        string _Name;
};

class CChild
{
    public:
        CChild(boost::shared_ptr<CCarKeys> const& CarKeys) 
            : _Name("Child"), _CarKeys(CarKeys) {}
        string _Name;
        boost::shared_ptr<CCarKeys> _CarKeys;
        void TestHasKeys() {cout << "I got " << _CarKeys._Name << endl;}
};

class CDad
{
    public:
        // NOTE: null the kid pointers *if* you use raw pointers, so you can check whether
        // a boy or girl is present. Without nulling them explicitly, they have 
        // indeterminate values. Beware. shared_ptr's however will automatically
        // initialized to default "null" values
        CDad() : 
            _Name("Dad"), 
            _HondaCarKeys(new CCarKeys("Honda keys")), 
            _ChevyCarKeys(new CCarKeys("Chevy keys")) {}
        string _Name;

        boost::shared_ptr<CCarKeys> _HondaCarKeys;
        boost::shared_ptr<CCarKeys> _ChevyCarKeys;

        // also use shared_ptr for the kids. try to avoid raw pointers. 
        boost::shared_ptr<CChild> _Boy;
        boost::shared_otr<CChild> _Girl;

        void MakeBoy() {_Boy.reset(new CChild(_HondaCarKeys));}
        void MakeGirl() {_Girl.reset(new CChild(_ChevyCarKeys));}
};

// main can be used unchanged

当然，您可以通过使 CDad 类不可复制来避免所有这些复杂性。 然后您可以使用原来的解决方案，只需让孩子们使用shared_ptr并使孩子们也不可复制。 理想情况下，应该使用非共享指针，例如auto_ptr，但是auto_ptr也有一些陷阱，而shared_ptr都避免了：

class CCarKeys
{
    public:
        CCarKeys(const string& Name) : _Name(Name) {}
        string _Name;
};

class CChild
{
    public:
        CChild (CCarKeys& CarKeys) 
            : _Name("Child"), _CarKeys(CarKeys) {}
        string _Name;
        CCarKeys &_CarKeys;
        void TestHasKeys() {cout << "I got " << _CarKeys._Name << endl;}
    private:
        CChild(CChild const&); // non-copyable
        CChild & operator=(CChild const&); // non-assignable
};

class CDad
{
    public:
        CDad() : 
            _Name("Dad"), 
            _HondaCarKeys("Honda keys"), 
            _ChevyCarKeys("Chevy keys") {}
        string _Name;

        CCarKeys _HondaCarKeys;
        CCarKeys _ChevyCarKeys;

        // also use shared_ptr for the kids. try to avoid raw pointers. 
        boost::shared_ptr<CChild> _Boy;
        boost::shared_otr<CChild> _Girl;

        void MakeBoy() {_Boy.reset(new CChild(_HondaCarKeys));}
        void MakeGirl() {_Girl.reset(new CChild(_ChevyCarKeys));}
private:
    CDad(CDad const&); // non-copyable
    CDad & operator=(CDad const&); // non-assignable
};

如果我必须实现这样一个类层次结构，我会这样做解决方案，或者只是将密钥作为成员删除，并在需要时将它们传递/创建给子级。 关于代码的其他一些注意事项：

• 最好删除成员中的“_”或将它们放在末尾或使用其他符号。 以下划线开头并后跟大写字母的名称由 C++ 实现（编译器、C++ std lib ...）保留。
• 我个人觉得成员名称和变量以大写字母开头很令人困惑。 我只见过很少的情况。 但这没什么好关心的，只是个人风格而已。
• 有一条著名的规则（零一无限）规定当你得到以下两件事时某事，你通常应该能够拥有其中的任意许多东西。 因此，如果您可以生两个孩子，为什么不生很多孩子呢？ 两个似乎是一个任意的选择。 但在你的情况下它可能有一个很好的理由 - 所以当在你的情况下它有意义时忽略它。

Answer 4

对我来说看起来不错（如果他们只需要钥匙的话）。 他们可能需要爸爸提供一些稍后请求的其他服务 - 例如：

Wallet += MyDad.GasMoney(REQUEST_MAX_AND_PROMISE_TO_BE_HOME_BY_10PM) ;

但他们没有爸爸的参考资料，所以他们无法做到这一点。 所以我会让 CChild 构造函数也采用 this 引用。

class ICashProvider {
public:
  virtual money Request(IPerson,CashRequestFlags) ;
};

class IChaffeur {
public:
  virtual void Drive(IPerson[]) ;
};

然后

，CChild 构造函数需要采用 ICashProvider 和 IChaffeur，CWife 和 CGirlfriend 也是如此（也许还有CBoyfriend）。 此时，我想您可能会意识到，面对 Dad 的职责，这种粒度级别毫无意义，您只需将 this 交给每个人，然后让 Dad 通过强制调用者在某些方法上发送自己的 this 来验证请求，这样您就不会让 Dad 执行乱伦或更改 CWife代码>的尿布。