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

假设我想为创建一个接口

具有可读取内容的项目

s

项

s，其内容可以写入

项

s，其内容可以读/写

但是，我不想创建3个抽象类，因为我可能希望传递一个

项

，它可以读写到一个只接受可读项的函数

e、 g.您只能阅读

书籍

，因此

书籍

将继承

可读

，而

注释

可以读写，因此它将继承

可读

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

std::string read(Readable& readable) const

或

---

我有一个可读的抽象类

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;
};

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

private:
    WritableType _content;
};

但是现在我想创建一个结合了这些功能的抽象类，名为

readwriteable

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;
};

模板
类可读写：公共可读，公共可写
{
公众：
可读写（可读写类型内容）；
虚拟~可读写（无效）；
使用Writable:：content；
使用可读的内容；
};

这就是问题所在，因为

content（WritableType&content）

使用

Writable:\u content

，而

content（void）

使用

Readable:\u content

如何让他们使用相同的

\u内容

数据成员。如果我能做到，有没有办法删除另一个

---

---

还是我的方法完全错了？我对每一种观点都持开放态度。

我不确定我的问题是否正确，但根据我的理解，您希望让两个单独的类共享相同的数据，并且仍然使用这些共享数据继续它们的功能

我已经用几个组合进行了测试，下面的代码运行良好。然而，我不得不做出一些改变：

#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);   
}

#包括
类可读类型
{
public:int id=0；
int*共享值；
};
类可写类型
{
公共：int id=1；
int*共享值；
};
类可读写类型
{
公共：int id=2；
int*共享值；
可读写类型（int共享）{sharedValue=new int；*sharedValue=share；}；
};
类可读
{
公众：
void content（void）{std:：cout我不确定我的问题是否正确，但根据我的理解，您希望使两个单独的类共享相同的数据，并且仍然使用此共享数据继续其功能

我已经用几个组合进行了测试，下面的代码运行良好。但是我不得不做一些更改：

#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);   
}

#包括
类可读类型
{
public:int id=0；
int*共享值；
};
类可写类型
{
公共：int id=1；
int*共享值；
};
类可读写类型
{
公共：int id=2；
int*共享值；
可读写类型（int共享）{sharedValue=new int；*sharedValue=share；}；
};
类可读
{
公众：
void content（void）{std:：cout如果有一个额外的层，您可以这样做

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;
};

模板
类IReadable
{
公众：
virtual~IReadable（）=默认值；
虚拟常量ReadableType&content（）常量noexcept=0；
};
模板
类IWritable
{
公众：
虚拟~IWritable（）；
虚拟无效内容（可写类型和内容）noexcept=0；
};
模板
类可读：公共IReadable
{
公众：
可读（常量可读类型和内容）；
virtual const ReadableType&content（）const noexcept override；
私人：
常量可读类型_内容；
};
模板
类可写
{
公众：
虚拟无效内容（可写类型和内容）无异常覆盖；
私人：
可写类型\u内容；
};

最后：

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;
};

模板
类可读写：public-IReadable，public-IWritable
{
公众：
可读写（可读写类型内容）；
虚拟无效内容（可写类型和内容）无异常覆盖；
virtual const ReadableType&content（）const noexcept override；
私人：
可读写类型\u内容；
};

您确实需要重新实现
readwriteable:：content
，但代码可能会被分解为
Readable
/
writeable
一个，然后重新使用。
如果有一个额外的层，您可以这样做

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;
};

模板
类IReadable
{
公众：
virtual~IReadable（）=默认值；
虚拟常量ReadableType&content（）常量noexcept=0；
};
模板
类IWritable
{
公众：
虚拟~IWritable（）；
虚拟无效内容（可写类型和内容）noexcept=0；
};
模板
类可读：公共IReadable
{
公众：
可读（常量可读类型和内容）；
virtual const ReadableType&content（）const noexcept override；
私人：
常量可读类型_内容；
};
模板
类可写
{
公众：
虚拟无效内容（可写类型和内容）无异常覆盖；
私人：
可写类型\u内容；
};

最后：

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;
};

模板
类可读写：public-IReadable，public-IWritable
{
公众：
可读写（可读写类型内容）；
虚拟无效内容（可写类型和内容）无异常覆盖；
virtual const ReadableType&content（）const noexcept override；
私人：
可读写类型\u内容；
};

您确实需要重新实现
readwriteable:：content
，但代码可能会被分解为
Readable
/
writeable
一个，然后重新使用。
我不确定我是否正确回答了您的问题-但是您是否已经了解了虚拟基类的概念？这将确保派生的可读写cl中只有一个_content成员assI认为这只适用于基类与基类完全相同的情况，例如，如果我继承了Readable两次。问题不是真的存在重载，而是Readable:：content（）和Writable:：content（）的问题每个都有自己的私有变量
\u content
，它们不会协调分离的接口和实现。接口不应该存储任何状态，您应该在实现中存储所有状态。我认为模板在这种情况下不是更好的用法，您不想创建