c++ - 如何在msvc中强制返回值优化

Question

我在一个类中有一个函数，我希望编译器在...一直...甚至在 Debug模式下使用 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 函数接口(interface)时，它很方便，而且您不确定最大大小。

无论如何，我正在尝试编写一个可以返回 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() 更快。在 Release模式下，效果很好。在 Debug模式下，它显然失败了，因为我的类中没有复制构造函数。我不需要复制构造函数，因为 CBuffer 将被喜欢复制所有内容 50 次的开发人员使用。 (咆哮:这些家伙使用动态数组类创建一个 20 个字符的缓冲区以传递给 WideCharToMultiByte()，因为他们似乎忘记了你可以在堆栈上分配一个字符数组。我不知道是否他们甚至知道堆栈是什么......)

我真的不想为了代码在 Debug模式下工作而编写复制构造函数!它变得庞大而复杂:

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)

有什么想法吗？

Answer 1

让您的代码既符合标准又能正常工作并不难。

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

对于所有权，使用唯一的 ptr 而不是原始的。如果它是乏味的，运算符 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 asserts，或者 handle 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 几乎肯定会发生，当它确实发生时，它会做一些逻辑上等同于执行移动构造函数选项的事情。

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

在调试中，您很可能最终会执行移动构造。但这应该没有任何伤害。