Question

我有以下函数原型：

virtual CBuffer& GetData(unsigned int& samples, unsigned int& stride);

这将返回对我的类的私有成员的CBuffer对象的引用。

问题是如果写入以下内容，则将重新分配该方法返回的内部私有成员。

CBuffer& CPlug::ProcessData(unsigned int& samples, unsigned int& stride)
{
  /* get the data from the source */
  CBuffer& buffer = m_source.GetData(samples, stride);

  if (m_postProcess)
    buffer = PostProcess(buffer, samples, stride);

  return buffer;
}

显然，可以通过执行以下操作来解决此问题：

CBuffer& CPlug::ProcessData(unsigned int& samples, unsigned int& stride)
{
  /* get the data from the source */
  CBuffer* buffer = &m_source.GetData(samples, stride);

  if (m_postProcess)
    buffer = &PostProcess(*buffer, samples, stride);

  return *buffer;
}

但我想知道是否有某种方法可以阻止这种情况，可能是通过使用我不知道的const？

此时我认为我应该转换为使用指针，但知道是否可以完成它会很好。

Answer 1

因为一个样本超过一千字，可能是： see it live

#include <vector>
#include <memory>

typedef std::vector<int> CBuffer;

static CBuffer& PostProcess(CBuffer& data)  { 
    for(auto& el : data)
        el /= 2;
    return data;
}

struct CSource
{
    CSource() : _data(std::make_shared<CBuffer>(10)) {}

    std::shared_ptr<CBuffer>       GetData()       { return _data; }
    std::shared_ptr<const CBuffer> GetData() const { return _data; }

  private:
    std::shared_ptr<CBuffer> _data;
};

struct CPlug
{
    CPlug(bool postProcess = true) : m_postProcess(postProcess) { }

    std::shared_ptr<const CBuffer> ProcessData() const
    {
        /* get the data from the source, implicitely const */
        auto buffer = m_source.GetData();

        if (!m_postProcess)
            return buffer;

        // clone!
        auto clone = *buffer;
        return std::make_shared<CBuffer>(PostProcess(clone));
    }

  private:
    bool    m_postProcess;
    CSource m_source;
};

int main()
{
    CPlug intance;
}

保护私人会员通过参考意外重新分配返回

1 个答案: