27

您从经验中学到了哪些与 C++ 相关的习语、误解和陷阱？

一个例子：

class A
{
  public: 
  char s[1024];
  char *p;

  A::A()
  {
    p = s;
  }

  void changeS() const
  {
    p[0] = 'a';
  }

};

甚至知道changeS是一个const成员函数，它是改变对象的值。所以一个 const 成员函数只是意味着它将所有变量都视为 const，并不意味着它实际上会保留所有成员 const。（为什么？成员函数上的 const 关键字将 char *p; 视为 char * const p; 而不是 const char *p;

因此，这意味着 p 不能指向其他东西。并不是说你不能改变 p 的数据。

4

16 回答 16

55

您无需了解 C++ 复杂的函数 typedef 声明语法。这是我发现的一个可爱的技巧。

快，描述一下这个 typedef：

typedef C &(__cdecl C::* const CB )(const C &) const;

简单的！CB 是指向 C 类成员函数的指针，它接受对 C 对象的 const 引用并返回对 C 对象的非常量引用。哦，它是一个 const 成员函数。哦，函数指针本身是 const ......（对吗？）

C++ 函数声明规范语法是出了名的晦涩难记。是的，经验丰富的 C++ 资深人士可能会使用一些技巧来破译这种恐怖，但这不是本技巧的内容。这个技巧是关于你如何不需要记住这种可怕的语法并且仍然能够声明这样的函数指针类型定义（例如，如果你正在与一些从未听说过 boost::function 的遗留 API 交互）。让编译器为您完成工作，而不是费尽心思。下次您尝试为成员函数创建 typedef 时，如下所示：

struct C {
        const C& Callback(const C&) const   { }
};

与其努力手动想出上面的复杂语法，不如引发一个故意的编译错误，这将迫使编译器命名野兽。

例如：

char c = &C::Callback;

编译器高兴地发出这个有用的错误消息：

“… cannot convert from 'const C &(__cdecl C::* )(const C &) const' to 'char'”

这就是我们正在寻找的。:)

于 2008-11-16T16:20:59.983 回答
18

自从我在一些代码中发现它以来，我就喜欢它：

assert(condition || !"Something has gone wrong!");

或者如果你手头没有条件，你可以这样做

assert(!"Something has gone wrong!");

以下归因于@Josh（见评论）。它使用逗号运算符代替：

assert(("Something has gone wrong!", condition));
于 2008-11-16T15:51:15.737 回答
18

这是我有一天抓到的另一个：

char int2hex(int x) {
     return "-0123456789abcdef"[(x >= 0 && x < 16) ? (x + 1) : 0];
}

它只是索引 char 数组而不是进行切换。如果超出范围，则返回“-”。

于 2008-11-16T18:53:43.497 回答
14

当我们不知道以后是否需要时，永远不要浪费时间尝试在类上实现复制操作。我们处理的许多对象只是实体，复制它们几乎没有任何意义。使它们不可复制，如果确实需要，稍后再实施复制/复制。

于 2008-11-16T16:38:06.517 回答
11

有时，标头会因不表现宏名称而受到污染，例如

#define max(a, b) (a > b ? a : b)

这将使使用以这种方式调用的最大函数或函数对象的代码无效。一个臭名昭著的例子就是windows.h这样做的。一种解决方法是在调用周围加上括号，这会阻止它使用宏并使其使用真正的 max 函数：

void myfunction() {
    ....
    (max)(c, d);
}

现在，最大值在括号中，不再算作对宏的调用！

于 2009-03-10T11:14:56.820 回答
7

一个很少使用但很方便的 C++ 习惯用法是在构造函数链中使用 ?: 运算符。

class Sample
{  
    const char * ptr;
    const bool  freeable;

    Sample(const char * optional):
        ptr( optional ? optional : new char [32]),
        freeable( optional ? false : true ) {}
    ~Sample( )  { if (freeable) delete[] ptr; }
}

C++ 不允许在构造函数的主体内更改 const 值，因此这避免了 const-casts。

于 2008-11-16T17:32:27.030 回答
6

您通常可以在源文件中隐藏比您想象的更多的东西。如果不需要，不要将所有内容都设为私有 - 通常最好将其保留在源文件中的匿名命名空间中。我发现它实际上使事情更容易处理，因为这样您就不会透露实现细节，而是会受到启发来制作许多微小的功能而不是单一的功能。

于 2008-11-16T22:13:30.427 回答
5

一些通常会绊倒人们的事情：

std::cout << a << a++ << --a;
i = ++i;

上述行均未定义。

void foo(bar* b1, bar* b2);

int main() {
  foo(shared_ptr<bar>(new bar()), shared_ptr<bar>(new bar()));
}

以上可能会泄漏内存。

int* arr = new int[10];
arr + 11;

这会导致未定义的行为。

至于成语，我最喜欢的是RAII。在栈上分配对象，保证在对象超出范围时调用析构函数，防止资源泄漏。

于 2008-11-16T16:10:34.747 回答
5

因为我们都忽略了 OP，而是发布了我们最喜欢的酷技巧......

使用 boost（或 tr1）shared_ptr 在运行时保持类不变（很明显，但我没有看到其他人这样做）：

#include <cassert>
#include <functional>
#include <stdexcept>
#include <boost/shared_ptr.hpp>
using namespace std;
using namespace boost;

class Foo
{
public:
    Foo() : even(0)
    {
        // Check on start up...
        Invariant();
    }

    void BrokenFunc()
    {
        // ...and on exit from public non-const member functions.
        // Any more is wasteful.
        shared_ptr<Foo> checker(this, mem_fun(&Foo::Invariant));

        even += 1;
        throw runtime_error("didn't expect this!");
        even += 1;
    }

private:
    void Invariant() { assert(even % 2 == 0); }
    int even;
};
于 2008-11-16T20:57:13.093 回答
4

自从我了解了 RAII（有史以来最糟糕的首字母缩写词之一）和智能指针以来，内存和资源泄漏几乎完全消失了。

于 2008-11-16T21:30:26.833 回答
3

如果您有一个没有值语义的类，请确保显式声明以下所有构造，以防止出现问题。

  • 默认构造函数
  • 复制构造函数
  • 赋值运算符

在许多情况下，您只需要声明这些结构的一个子集。然而，在某些情况下，哪些需要哪些不需要，这可能会变得非常棘手。将所有 3 项声明为私有并完成此事要安全得多。

在顶部添加注释说明这不是复制安全类也非常有帮助。

这将节省您的时间。

于 2008-11-16T17:54:52.913 回答
0

我不能说我是一位经验丰富的 C++ 程序员，但我最近了解到将数组和数组作为函数参数传递是多么困难。尽量避免这种情况:(

如果您知道编译时的大小，它很简单。即使您在编译时知道其中一个维度。如果你根本不知道......你可能正在看这样的东西

m[i*dim2+j]

作为行的迭代器，dim2 是列数，j 是列的迭代器。

于 2008-11-16T21:15:56.673 回答
0

我在编程时实际上没有遇到任何事情，但一位朋友想要解释为什么代码可以工作。我花了一段时间才弄清楚。也许这对你们来说很明显，但我不是一个经验丰富的程序员。

#include <iostream>
using namespace std;

int& strangeFunction(int& x){return x;}


int main(){
        int a=0;
        strangeFunction(a) = 5;               //<------- I found this very confusing
        cout << a <<endl;
        return 0;
}
于 2009-03-10T11:34:49.813 回答
0

shared_ptr除非需要，否则不喜欢使用。更喜欢使用 C++ 引用而unique_ptr不是。shared_ptr是性能猪，使代码看起来比实际更复杂。通常这不会是一个问题，除了不寻常的吸引力shared_ptr和它的传染性。

于 2013-01-16T11:50:44.643 回答
0

std::noncopyable除非需要，否则不要陷入使用的陷阱。是的，它在很多地方都很有用，应该在那里使用。

陷阱是人们开始编写clone()函数并使其不可复制，这实现了相同的功能。相反，您也可以将explicit( link ) 用于复制构造函数，以防止意外复制（并将赋值设为私有，或删除 C++0x 中的函数）。clone()但是，继承的基类需要。

于 2013-01-16T11:58:50.897 回答
0

使用boost::spirit::hold_any( link ) 而不是boost::any性能代码（同时持有大量小对象）。我看到他们的表现有很大的不同。

于 2013-01-16T12:06:33.730 回答