c++ - 设计延迟加载

Question

我很难弄清楚如何设计无法在构造函数中初始化所有内部成员的类。我知道这应该是一些基本的东西并且在整个网络上都在讨论，但我不确定要寻找什么。因此，例如，请考虑以下代码:

#include <iostream>

class Workhorse
{
public:
    void SetData (const int &data)
    {
        this->data = data;
    }

    int GetData () const
    {
        return this->data;
    }

private:
    int data;
};

class Worker
{
public:
    Worker ()
    {
    }
    void Initialize (const int &data)
    {
        horse.SetData(data);
    }
    void Action () const
    {
        std::cout << horse.GetData() << std::endl;
    }

private:
    Workhorse horse;
};

int main ()
{
    Worker worker;
    worker.Initialize(3);
    worker.Action();
    return 0;
}

我想防止工作人员在未先调用 Initialize() 的情况下调用任何方法。外行的实现是在 Worker 类中添加一个 isInitialized 标志，在 Initialize() 中将其设置为 true 并在每个公共(public)方法的开头对其进行测试(如果我们引入一些继承，也可能在 protected /私有(private)方法中进行测试？) .不幸的是，这似乎有点麻烦且难以维护。此外，在所有方法中重复 if 语句也很糟糕。我什至还没有开始思考线程安全问题，但是，现在，我只是在实现一个单线程应用程序。有没有更聪明的设计方法？

---

编辑:好的，我选择了一个愚蠢的设计作为例子，这确实是有缺陷的。让我试着更清楚地描述我所拥有的:

#include <iostream>

class PublicKeyCryptoProvider
{
public:
    struct PublicKey
    {
        int shared;
    };
    struct PrivateKey
    {
        int secret;
    };

    int Encrypt (const int &plaintext) const
    {
        int ciphertext;
        //apply encryption algorithm on plaintext
        ciphertext = plaintext * this->pk.shared;
        return ciphertext;
    }

    int Decrypt (const int &ciphertext) const
    {
        int plaintext;
        //apply decryption algorithm on ciphertext
        plaintext = ciphertext / this->sk.secret;

        return plaintext;
    }

    void GenerateKeys ()
    {
        this->pk.shared = 4;
        this->sk.secret = 4;
        //generate pk and sk
    }

    void SetPublicKey (const PublicKey &pk)
    {
        this->pk = pk;
    }

    const PublicKey &GetPublicKey () const
    {
        return this->pk;
    }

private:
    PublicKey pk;
    PrivateKey sk;
};

int main ()
{
    /* scenario 1: */
    PublicKeyCryptoProvider cryptoProvider;
    cryptoProvider.GenerateKeys();
    std::cout << cryptoProvider.Decrypt(cryptoProvider.Encrypt(3)) << std::endl;
    /* /scenario 1: */

    /* scenario 2: */
    PublicKeyCryptoProvider cryptoProvider1;
    cryptoProvider1.GenerateKeys();

    PublicKeyCryptoProvider cryptoProvider2;
    cryptoProvider2.SetPublicKey(cryptoProvider1.GetPublicKey());

    int ciphertext = cryptoProvider2.Encrypt(3);
    std::cout << cryptoProvider1.Decrypt(ciphertext) << std::endl;

    //now let's do something bad...
    std::cout << cryptoProvider2.Decrypt(ciphertext) << std::endl;
    /* /scenario 2: */

    return 0;
}

显然，您可以想象场景 2 完全有效的现实生活示例。鉴于上述情况，有没有比在 PublicKeyCryptoProvider 类中添加 canDecrypt 标志更好的选择，该标志在生成 key 时设置为 true，然后在 decrypt 方法开始时进行测试？我必须提到这是一个非常简单的例子，因为在我的例子中，如果 PublicKeyCryptoProvider 是 key 的所有者并且它有更多的公共(public)方法，它可以执行更快的加密，所以我注定要测试标志不止几次......另外，我有一个客户端 - 服务器模型场景，其中服务器为客户端公开了一堆公共(public)方法，但客户端只能在调用 Initialize() 方法后调用这些方法服务器...

Answer 1

我会做以下事情:

    class Worker
{
public:
    Worker (const int& data)
    {
        horse.SetData(data);
    }

    void Action () const
    {
        std::cout << horse.GetData() << std::endl;
    }

private:
    Workhorse horse;
};

由于您显然不希望 Worker 对象在未初始化的情况下存在，因此它的初始化应该是其构造的一部分，并且应该在没有此初始化的情况下对其进行实例化，因为没有它就无法工作。