2

我有以下函数原型：

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我不知道的使用？

在这一点上，我认为我应该只转换为使用指针，但很高兴知道它是否可以完成。

4

1 回答 1

2

因为一个样本说了一千多个单词，可能：现场观看

#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;
}
于 2013-07-25T09:59:24.537 回答