在 C/C++ 中使用堆栈进行内存管理时的编码风格

Question

来自 Java 背景，我试图学习如何以最简单的方式处理 C/C++ 中的内存分配（取消）分配。

一位同事建议我只为成员变量分配内存，让堆栈处理局部变量。我不完全确定这个概念叫什么，但这意味着函数将像这样实现：

void inc(int x, int &y){
  y=x+1;
}

另一种方式是这样的：

int inc(int x, int &y){
  y=x+1;
  return y;
}

第一个禁止我在表达式中使用它，即：

int y;
inc(2,y); 
inc(y,y);

第二个可以，但它不是' t Pretty：

int y;
y=inc(inc(2,y),y);

在我搞乱我的代码之前，经验丰富的 C/C++ 程序员对这种编码风格有何看法？

Answer 1

对于使用此函数的程序员来说，我强烈劝阻他们

int inc(int x, int &y) {
   y=x+1;
   return y;
}

，不清楚为什么该函数会修改输入并返回值，并且它们都是同一个对象。

---

实际上，在我看来，选择是：

// #1
void inc(int x, int& y) {
   y=x+1;
}

int y = 0;
inc(2, y);

和

// #2
int inc(int x) {
   return x+1;
}

int y = inc(2);

在一般情况下，我仍然更喜欢 #2 因为我发现“输出参数”过时且使用起来很笨拙。正如您所指出的，您最终会与表达式作斗争，并且调用函数¹时实际发生的情况并不是很清楚。

再说一遍，如果您有一个比 int 更复杂的对象（例如，一个数组或一个大类，或者您只想“返回”多个对象），它可能会使对象所有权变得更容易如果您不在函数内创建任何新对象，则需要处理，使 #1 成为更方便的选择。

我认为我在这里试图得出的结论是，它取决于场景。试图对这些事情进行概括是愚蠢的行为。

---

¹ - 使用指针而不是引用在一定程度上解决了这个问题，尽管它确实引入了膨胀，现在不得不费心检查无效指针：

// #3
void inc(int x, int* y) {
   assert(y); // at least, we can check that it's not NULL
   *y = x+1;
}

int y = 0;
inc(2, &y); // clear here that I'm passing a pointer

Answer 2

还有第三种更简单的方法：

int inc( int x ) {
   return x+1;
}

int y = inc(inc(2));

Answer 3

这不太可能是您同事所指的编程风格。像整数或简单结构这样的 POD 类型不是您通常关心的数据。 资源获取即初始化，即 RAII，是 C++ 中的一种常见策略，它利用了堆栈分配的属性变量，从而保证在大多数情况下调用其析构函数。

假 RAII 代码：

// take a reference to some resource 'r'
void frob(resource& r, int val)
{
    other_resource or(val);

    or << r; // use of r requires no pointer manipulation, etc
} // 'or' is destructed at the end of 'frob'
  // even in exceptional situations.

int main (int argc, char argv[][])
{
    resource r(1, "a", 3.0);

    frob(r, 9);

    return 0; // after this 'r' will be destructed
}

Answer 4

对于基元类型，这是可以的：

int inc(int x) {
   return x+1;
}

对于更复杂的类型，这样做可以避免函数返回时进行额外的复制

void reverse_vector(const std::vector<int>& v, std::vector<int>* result) {
   if (!result) return;
   *result = v;
   std::reverse(result->begin(), result->end();
}
// ... 
std::vector<int> v;
std::vector<int> reversed;
reverse_vector(v, &reversed);

对于堆分配的对象，我建议使用 boost::shared_ptr (tr1::shared_ptr) 库。然后您就可以像在 java 中一样编写代码。

#include <string>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>

class A {
public:
    A(int x, const std::string& str) 
      : x(x), str(str) {
    }

    void foo() {
    }
private:
    int x;
    const std::string& str;
};

// ...

boost::shared_ptr<A> a = boost::make_shared<A>(1, "hello");
a->foo();

您可以将 boost::shared_ptr 对象视为 java 引用。没有垃圾收集（只是引用计数），因此您必须自己关心周期。

请记住，shared_ptr 比标准指针慢一点。

另外，请务必记住，应避免复制大对象。 否则最好编写

void foo(const std::string& str);

而不是

void foo(std::string str);

除非您需要 foo 中的 str 副本，

编写。另一件事是编译器很聪明，会为你做一些优化。例如，reverse_vector 可以写为

std::vector<int> reverse_vector(std::vector<int> v) { // note copying!
   std::reverse(v.begin(), v.end());
   return v; // no additional copying of temporary due to RVO
}

此 RVO（返回值优化）非常有用，但有时编译器无法自动执行此操作。这就是为什么我建议在不依赖 RVO 的情况下编写此类函数，除非您在失败时学习。

Answer 5

您的问题与内存分配无关，只是关于按值或按引用传递参数。

该函数将 y 参数作为引用传递，x 参数被复制。

void inc(int x, int &y){
  y=x+1;
}

我个人认为这种形式可能是令人严重头痛的根源，因为语法并没有偏离值传递。你应该避免它，除非你正在处理物体。我建议这种形式：

int inc(int x){
  return x+1;
}

y=inc(2)

Answer 6

我认为在您的第二个示例中，您不希望引用 y ，因此

int inc(int x, int &y)

您应该引用 y

int inc(int x, int y)

，因为当您在函数内编辑 y 时，它会再次编辑原始内容y 而不仅仅是本地副本，这不是您想要的。