如何使继承基类使用公共变量

Question

假设我想为

创建一个界面

Item 具有可以阅读的内容。
Item有可写的内容
Item具有可读a/o可写

但是我不想创建 3 个抽象 classes，因为我可能想传递一个 Item，它对只接受可读项目的函数是可读写的。

例如你只能读取Book，所以Book会继承Readable，而Note可以读取和写入，因此它会继承ReadWritable。

现在我可以创建这样的函数了：

std::string read(Readable& readable) const

或

void take_a_note(Writable& writable)

我有这个Readable摘要class

template <typename ReadableType>
class Readable
{
public:
    Readable(const ReadableType content);
    virtual ~Readable(void);
    virtual auto content(void) const noexcept -> const ReadableType&&;

private:
    const ReadableType _content;
};

还有一个Writable摘要class

template <typename WritableType>
class Writable
{
public:
    Writable(void);
    virtual ~Writable(void);
    virtual void content(WritableType&& content) noexcept;

private:
    WritableType _content;
};

但现在我想创建一个结合了这些功能的抽象 class，称为 ReadWritable

template <typename ReadWritableType>
class ReadWritable: public Readable<ReadWritableType>, public Writable<ReadWritableType>
{
public:
    ReadWritable(ReadWritableType content);
    virtual ~ReadWritable(void);
    using Writable<ReadWritableType>::content;
    using Readable<ReadWritableType>::content;
};

这就是问题所在，因为 content(WritableType&& content) 使用 Writable::_content，而 content(void) 使用 Readable::_content。

如何让它们使用相同的 _content 数据成员。如果我能做到这一点，有没有办法删除另一个？

或者我的完整方法是错误的？我对所有意见持开放态度。

Answer 1

我不确定我是否答对了问题，但根据我的理解，您希望让两个单独的类共享相同的数据并继续使用该共享数据发挥其功能。

我测试了几种组合，下面的代码工作正常。但是我不得不做一些改变：

#include <iostream>

class ReadableType
{
    public: int id=0;
            int* sharedValue;
};

class WritableType
{
    public: int id=1;
            int* sharedValue;
};

class ReadWritableType
{
    public: int id=2;
            int* sharedValue;
            ReadWritableType(int share){sharedValue = new int;*sharedValue = share;};
};

class Readable
{
public:
    void content(void){std::cout << "id: "<<_content->id <<" sharedValue: "<<*_content->sharedValue<<std::endl;};

protected:
    ReadableType *_content;
};


class Writable
{
public:
    void content(WritableType content){std::cout << "id: "<<_content->id <<" sharedValue: "<<*_content->sharedValue<<std::endl;};

protected:
    WritableType *_content;
};


class ReadWritable: public Readable, public Writable
{
public:
    ReadWritable(ReadWritableType* content);
    using Writable::content;
    using Readable::content;
private:
    void makeReadable(ReadWritableType* content);
    void makeWritable(ReadWritableType* content);
};

ReadWritable::ReadWritable(ReadWritableType* content)
{
    makeReadable(content);
    makeWritable(content);
}

void ReadWritable::makeReadable(ReadWritableType* content)
{
    Readable::_content = new ReadableType();
    Readable::_content->sharedValue = content->sharedValue;
}

void ReadWritable::makeWritable(ReadWritableType* content)
{
    Writable::_content = new WritableType();
    Writable::_content->sharedValue = content->sharedValue;
}
int main()
{
    ReadWritable x(new ReadWritableType(5));
    WritableType s;
    x.content();
    x.content(s);   
}

输出是每个 _content 使用一个私有值 (id) 和一个共享值 (sharedValue)，它在两个 _contents 之间共享相同的内存。

Answer 2

多一层就可以了

template <typename ReadableType>
class IReadable
{
public:
    virtual ~IReadable() = default;
    virtual const ReadableType& content() const noexcept = 0;
};

template <typename WritableType>
class IWritable
{
public:
    virtual ~IWritable();
    virtual void content(WritableType&& content) noexcept = 0;
};

template <typename ReadableType>
class Readable : public IReadable
{
public:
    Readable(const ReadableType& content);
    virtual const ReadableType& content() const noexcept override;
private:
    const ReadableType _content;
};

template <typename WritableType>
class Writable
{
public:
    virtual void content(WritableType&& content) noexcept override;
private:
    WritableType _content;
};

最后：

template <typename ReadWritableType>
class ReadWritable: public IReadable<ReadWritableType>, public IWritable<ReadWritableType>
{
public:
    ReadWritable(ReadWritableType content);

    virtual void content(WritableType&& content) noexcept override;
    virtual const ReadableType& content() const noexcept override;
private:
    ReadWritableType _content;
};

您确实需要重新实现 ReadWritable::content，但代码可以分解为 Readable/Writable 并重新使用。

如何使继承基类使用公共变量

How to make inherited base classes use a common variable

c++

inheritance

multiple-inheritance

base-class

如何使继承基 类 使用公共变量

How to make inherited base classes use a common variable

c++

inheritance

multiple-inheritance

base-class

如何使继承基类使用公共变量