1

我在一个类中有一个函数，我希望编译器在......一直使用 NRVO......即使在调试模式下也是如此。对此有语用吗？

这是我的课程在“发布”模式下效果很好：

template <int _cbStack> class CBuffer {
public:
    CBuffer(int cb) : m_p(0) { 
        m_p = (cb > _cbStack) ? (char*)malloc(cb) : m_pBuf;
    }
    template <typename T> operator T () const { 
        return static_cast<T>(m_p); 
    }
    ~CBuffer() { 
        if (m_p && m_p != m_pBuf) 
            free(m_p); 
    }
private: 
    char *m_p, m_pBuf[_cbStack];
};

除非需要超过 _cbStack 字节，否则该类用于在堆栈上创建缓冲区。然后当它销毁时，如果它分配了任何内存，它就会释放内存。当与需要字符串缓冲区的 c 函数交互时，它很方便，并且您不确定最大大小。

无论如何，我试图编写一个可以返回 CBuffer 的函数，就像在这个测试中一样：

#include "stdafx.h"
#include <malloc.h>
#include <string.h>

template <int _cbStack> CBuffer<_cbStack> foo() 
{ 
    // return a Buf populated with something...
    unsigned long cch = 500;
    CBuffer<_cbStack> Buf(cch + 1);
    memset(Buf, 'a', cch);  
    ((char*)Buf)[cch] = 0;
    return Buf;
}

int _tmain(int argc, _TCHAR* argv[])
{
    auto Buf = foo<256>();
    return 0;
}

我指望 NRVO 让 foo() 快速。在发布模式下，它工作得很好。在调试模式下，它显然会失败，因为我的类中没有复制构造函数。我不想要复制构造函数，因为喜欢复制所有内容 50 次的开发人员将使用 CBuffer。（咆哮：这些家伙正在使用动态数组类创建一个包含 20 个字符的缓冲区以传递给 WideCharToMultiByte()，因为他们似乎忘记了您可以只在堆栈上分配一个字符数组。我不知道是否他们甚至知道堆栈是什么......）

我真的不想编写复制构造函数，以便代码在调试模式下工作！它变得庞大而复杂：

template <int _cbStack> 
class CBuffer {
public:
    CBuffer(int cb) : m_p(0) { Allocate(cb); }
    CBuffer(CBuffer<_cbStack> &r) { 
        int cb = (r.m_p == r.m_pBuf) ? _cbStack : ((int*)r.m_p)[-1];
        Allocate(cb);
        memcpy(m_p, r.m_p, cb);
    }
    CBuffer(CBuffer<_cbStack> &&r) { 
        if (r.m_p == r.m_pBuf) {
            m_p = m_pBuf;
            memcpy(m_p, r.m_p, _cbStack);
        } else {
            m_p = r.m_p;
            r.m_p = NULL;
        }
    }
    template <typename T> operator T () const {
        return static_cast<T>(m_p); 
    }
    ~CBuffer() {
        if (m_p && m_p != m_pBuf) 
            free((int*)m_p - 1); 
    }
protected: 
    void Allocate(int cb) {
        if (cb > _cbStack) {
            m_p = (char*)malloc(cb + sizeof(int));
            *(int*)m_p = cb;
            m_p += sizeof(int);
        } else {
            m_p = m_pBuf; 
        }
    }
    char *m_p, m_pBuf[_cbStack];
};

此编译指示不起作用：

 #pragma optimize("gf", on)

有任何想法吗？

4

3 回答 3

2

使您的代码既符合标准又可以工作并不难。

首先，用可选的额外填充包裹 T 的数组。现在你知道布局了。

对于所有权，使用唯一的 ptr 而不是原始的。如果它是 vapid，则 operator T* 返回它，否则为缓冲区。现在，您的默认移动 ctor 可以正常工作，如果移动失败，NRVO 也可以正常工作。

如果你想支持非 POD 类型，一些工作将让你同时支持 ctors 和 dtors 并移动数组元素和逐位填充。

结果将是一个行为不会令人惊讶的类，并且在某人第一次尝试复制或移动它时不会产生错误 - 不是第一次，这很容易。编写的代码会在不同的时间以不同的方式爆炸！

遵守三法则。

这是一个明确的示例（现在我已经关闭了手机）：

template <size_t T, size_t bufSize=sizeof(T)>
struct CBuffer {
  typedef T value_type;
  CBuffer();

  explicit CBuffer(size_t count=1, size_t extra=0) {
    reset(count, extra);
  }
  void resize(size_t count, size_t extra=0) {
    size_t amount = sizeof(value_type)*count + extra;
    if (amount > bufSize) {
      m_heapBuffer.reset( new char[amount] );
    } else {
      m_heapBuffer.reset();
    }
  }
  explicit operator value_type const* () const { 
    return get();
  }
  explicit operator value_type* () { 
    return get();
  }
  T* get() {
    return reinterpret_cast<value_type*>(getPtr())
  }
  T const* get() const {
    return reinterpret_cast<value_type const*>(getPtr())
  }
private: 
  std::unique_ptr< char[] > m_heapBuffer;
  char m_Buffer[bufSize];
  char const* getPtr() const {
    if (m_heapBuffer)
      return m_heapBuffer.get();
    return &m_Buffer[0];
  }
  char* getPtr() {
    if (m_heapBuffer)
      return m_heapBuffer.get();
    return &m_Buffer[0];
  }
};

以上CBuffer支持移动构造和移动分配，但不支持复制构造或复制分配。这意味着您可以从函数返回这些的本地实例。RVO 可能会发生，但如果没有，上面的代码仍然是安全和合法的（假设T是 POD）。

在自己投入生产之前，我会T在上面添加一些 must be POD 断言，或者处理 non-POD T。

作为使用示例：

#include <iostream>
size_t fill_buff(size_t len, char* buff) {
  char const* src = "This is a string";
  size_t needed = strlen(src)+1;
  if (len < needed)
    return needed;
  strcpy( buff, src );
  return needed;
}
void test1() {
  size_t amt = fill_buff(0,0);
  CBuffer<char, 100> strBuf(amt);
  fill_buff( amt, strBuf.get() );
  std::cout << strBuf.get() << "\n";
}

而且，对于（希望如此）NRVO 的案例：

template<size_t n>
CBuffer<char, n> test2() {
  CBuffer<char, n> strBuf;
  size_t amt = fill_buff(0,0);
  strBuf.resize(amt);
  fill_buff( amt, strBuf.get() );
  return strBuf;
}

如果 NRVO 发生（应该如此），则不需要移动 - 如果 NRVO 没有发生，则发生的隐式移动在逻辑上等同于不移动。

关键是不依赖于 NRVO 具有明确定义的行为。但是，几乎可以肯定 NRVO 会发生，并且当它发生时，它会在逻辑上等同于执行 move-constructor 选项。

我不必编写这样的移动构造函数，因为unique_ptr它是可移动构造的，s 中的数组也是如此struct。另请注意，复制构造被阻止，因为unique_ptr无法复制构造：这符合您的需求。

在调试中，很可能你最终会做一个移动构造。但这应该没有什么坏处。

于 2013-01-11T00:38:21.500 回答
1

我认为没有公开可用的细粒度编译器选项只触发 NRVO。

但是，您仍然可以通过更改项目设置、命令行和#pragma.

http://msdn.microsoft.com/en-us/library/chh3fb0k(v=vs.110).aspx

尝试将 /O1 或 /O2 提供给您想要的文件。

而且，Visual C++ 中的调试模式只不过是一种没有优化和生成调试信息（PDB，程序数据库文件）的配置。

于 2013-01-10T23:59:05.927 回答
1

如果您使用的是 Visual C++ 2010 或更高版本，则可以使用移动语义来获得等效的结果。请参阅如何：编写移动构造函数。

于 2013-01-11T00:09:45.820 回答