c++ - 声明抽象类型的字段？更喜欢指针还是引用？

Question

我有一个看起来像这样的抽象类

class Protocol
{
public:
    // format the string to json or xml depending on impl
    virtual std::string& format(Message& msg) = 0;
    // parse the message from json or xml depending on impl
    virtual Message& parse(std::string& str) = 0;
}

用于格式化从/到 std::string 的 structure Message 解析

struct Message
{
    unsigned long id;
    unsigned char command;
    unsigned int value;

    /* some more fields */
}

现在我有另一个类 `` 通过拥有该类型的成员来依赖该类。当然这个成员应该是 Calculator

的子类型

// client.h
class Client
{
public:
    Client(Protocol& protocol);

    /* some methods, e.g. */
    void request(unsigned int amout);

private:
    /* this is what the question below refers to */
    Protocol* pProtocol;   // will compile
    Protocol  cProtocol;   // won't compile (see below)
    Protocol& rProtocol;   // what does this mean?
}

// client.cpp

Client::Client(Protocol& protocol) :  
    // depending on the member
    pProtocol(&protocol) // or
    cProtocol(protocol)  // or
    rProtocol(protocol)
{
}

void Client::request(unsigned int amount)
{
    Message msg;
    msg.id = 1234;
    msg.command = 100;
    msg.value = amount;

    std::string str = 
    // depending on the member
                      pProtocol->format(msg);  // or
                      cProtocol.format(msg);   // or
                      rProtocol.format(msg);

    // some more code to send the string to the server
}

所以这是我的问题:

• 我知道我应该更喜欢像 cProtocol 这样的类类型的成员，因为像 pProtocol 这样的指针可能是 NULL

  /li>

• 不幸的是，这不会与消息一起编译

  cannot declare field 'Client::cProtocol' to be of abstract type 'Protocol'
  

  我明白了，因为抽象类 Protocol 无法实例化。

• 那么我应该选择什么？引用成员还是指针成员？

• 这 3 个选项之间有什么区别？特别是 cProtocol 和 rProtocol 之间( 除外。与 -> 以及指针可能为 NULL 的事实

• 如果我不在构造函数中初始化 rProtocol 会怎样？ 这会编译吗？它包含什么？既然不能用默认值实例化!？

Answer 1

I know I should prefer members of class type like cProtocol since pointers like pProtocol may be NULL

通常，您更喜欢对象而不是指针，因为该语言通过调用析构函数来帮助您管理资源。但是，您可以使用智能指针实现相同的效果，例如 std::shared_ptr<T>或 std::unique_ptr<T> .

unfortunately this won't compile with the message "cannot declare field Client::cProtocol to be of abstract type Protocol" which I understand, since the abstract class Protocol cannot be instantiated.

这不是正确的原因:它是因为 object slicing 而完成的，因为不允许将对象分解为抽象类型。

So what should I prefer? A reference member or a pointer member?

要使用引用，需要三个条件:

• 引用的对象必须在构造函数中可用
• 引用对象的存在是强制性的(因为您不能设置对 NULL 的引用)，并且
• 您不需要将引用的对象重新指向其他某个对象，或者在以后的某个时间“清除”该引用。

如果满足这三个条件，就可以使用引用了。这告诉代码的读者，由于上述三个条件，您的类实例与引用的实例有很强的界限。

What are the differences between the 3 options? Especially between cProtocoland rProtocol (except . vs. -> and the fact that the pointer may be NULL)

cProtocoland制作一个拷贝(如果它不是抽象的，它会)并切掉所有派生的功能。 rProtocol使用其他一些对象，并保持它的多态性。 pProtocol让您更灵活地分配或重新分配它，以及分配 NULL秒。作为交换，您需要 NULL - 检查指针，并有选择地在复制构造函数、赋值运算符等中管理与其关联的资源。

What if I don't initialize rProtocol in the constructor? Will this compile? What would it contain? Since it cannot be instantiated with a default value!?

如果无法在构造函数中初始化引用，则根本无法使用该成员的引用:指针成为您唯一的选择。