我有一个对象作为接口(interface)的引用/指针呈现。如果存在该方法，我想在具体对象上调用该方法，而不更改接口(interface)、破坏封装或编写任何可怕的 hack。怎么做到的？

这是一个例子。

我有一个界面:

class IChatty
{
public:
    virtual ~IChatty() {};
    virtual std::string Speak() const = 0;
};

以及该接口(interface)的多个具体实现:

class SimpleChatty : public IChatty
{
public:
    ~SimpleChatty() {};

    virtual std::string Speak() const override
    {
        return "hello";
    }
};

class SuperChatty : public IChatty
{
public:
    void AddToDictionary(const std::string& word)
    {
        words_.insert(word);
    }
    virtual std::string Speak() const override
    {
        std::string ret;
        for(auto w = words_.begin(); w != words_.end(); ++w )
        {
            ret += *w;
            ret += " ";
        }
        return ret;
    }
private:
    std::set<std::string> words_;
};

SuperChatty::AddToDictionary 方法不在抽象的 IChatty 接口(interface)中，尽管它可以包含在另一个新接口(interface)中。

在现实世界中，这些对象是通过工厂构建的，它们本身是抽象接口(interface)的具体实例。然而，出于我们的目的，这与手头的问题是正交的:

int main()
{
    IChatty* chatty = new SuperChatty;
    chatty->AddToDictionary("foo");
    std::cout << chatty->Speak() << std::endl;
}

因为 AddToDictionary 不是 IChatty 接口(interface)的一部分(而且不能是它的一部分)，我不能调用它。

如何在 chatty 指针上调用 AddToDictionary 而不破坏封装、编写一些可怕的 hack 或采用任何其他设计快捷方式？

注意:在现实世界中，字典是 SuperChatty 对象本身的一部分，不能与其分离。

注意2:我不想向下转换为具体类型。

最佳答案

让字典成为一个可以被SuperChatty更新和引用的对象:

class Dictionary {
public:
    void add(const std::string& word);
    const std::set<std::string>>& words() const;
    //..
};

class SuperChatty : public IChatty
{
public:
    SuperChatty(Dictionary& dictionary) :
    dictionary(dictionary) {
    }

    virtual std::string Speak() const override
    {
        auto words = dictionary.words();
        ostringstream oss;
        copy(words.begin(), words.end(),
             ostream_iterator<string>(oss, " "));
        return oss.str();
    }
};

用法:

int main()
{   
    Dictionary dictionary;
    IChatty* chatty = new SuperChatty(dictionary);
    dictionary.add("foo");
    std::cout << chatty->Speak() << std::endl;
}

编辑

好吧，问题变了。

如果您正确地执行此操作，则需要将自己与不良的底层系统隔离开来:

struct Dictionary {
    virtual ~Dictionary () {}
    virtual void add(const std::string& word) = 0;
};

struct Instrumenter {
    virtual ~Instrumenter () {}
    virtual void addDictionary(Dictionary& dictionary) = 0;
};

struct Chatter {
    virtual ~Chatter() {}
    virtual string speak() const = 0;
    virtual void instrument(Instrumenter& instrumenter) = 0;
};

这些实现为:

class BasicChatter : public Chatter {
    virtual string speak() const {
        return chatty.Speak();
    }
    virtual void instrument(Instrumenter& instrumenter) {
        // do nothing
    }
private:
    SimpleChatty chatty;
};

class SuperChatter : public Chatter {
    SuperChatter () : dictionary(chatty);

    virtual void instrument(Instrumenter& instrumenter) {
        instrumenter.addDictionary(dictionary);
    }

    virtual string speak() const {
        return chatty.Speak();
    }
private:
    SuperChatty chatty;
    DictionaryImpl dictionary;
};

关于c++ - 在不更改接口(interface)的情况下向对象添加功能，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/15361374/