Question

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

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

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。（Rant：这些家伙正在使用动态数组类创建一个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)

有什么想法吗？

Answer 1

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

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

对于所有权，使用唯一的ptr而不是原始ptr。如果它是vapid，则运算符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必须是POD断言，或者处理非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选项。

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

在调试中，很可能你最终会做一个移动构造。但是不应该有任何伤害。

Answer 2

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

但是，您仍然可以通过更改项目设置，命令行和#pragma中的选项来操作每个源文件的编译器优化标记。

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

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

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

Answer 3

如果您使用的是Visual C ++ 2010或更高版本，则可以使用移动语义来获得相同的结果。请参阅How to: Write a Move Constructor。

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

3 个答案: