blocks|key|1777594|text|有些人必须有能帮助你避免常见C%2B%2B陷阱的C%2B%2B书籍：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1777595|Effective+C%2B%2B|offset|length|1777596|More+Effective+C%2B%2B|1777597|Effective+STL|1777598|Effective+STL一书解释了bools问题的向量:)|1777599|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/0321334876|1|https://rads.stackoverflow.com/amzn/click/com/020163371X|2|https://rads.stackoverflow.com/amzn/click/com/0201749629^0|0|0|D|0|0|0|I|1|0|0|D|2|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@$D|Z|E|10|1|11]]|A|$]]|$1|F|3|G|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@$D|17|E|18|1|19]]|A|$]]|$1|J|3|K|5|6|7|1A|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]|T|$5|O|P|Q|A|$R|U]]|V|$5|O|P|Q|A|$R|W]]]]

Some must have C++ books that will help you avoid common C++ pitfalls:

<a href="https://rads.stackoverflow.com/amzn/click/com/0321334876" rel="noreferrer" rel="nofollow noreferrer">Effective C++</a> 
<a href="https://rads.stackoverflow.com/amzn/click/com/020163371X" rel="noreferrer" rel="nofollow noreferrer">More Effective C++</a> 
<a href="https://rads.stackoverflow.com/amzn/click/com/0201749629" rel="noreferrer" rel="nofollow noreferrer">Effective STL</a>

The Effective STL book explains the vector of bools issue :)

blocks|key|1562739|text|Brian有一个很棒的列表:我会添加“始终将单参数构造函数标记为显式(除非在极少数情况下需要自动类型转换)”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1562740|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Brian has a great list: I'd add "Always mark single argument constructors explicit (except in those rare cases you want automatic casting)."

blocks|key|1777992|text|这不是一个具体的技巧，而是一个通用的指导原则:检查你的来源。C%2B%2B是一门古老的语言，多年来它已经发生了很大的变化。最佳实践已经随之改变，但不幸的是，仍然有许多旧的信息。这里有一些非常好的书籍推荐-我可以第二次购买每一本Scott+Meyer的C%2B%2B书籍。熟悉Boost和Boost中使用的编码风格-参与该项目的人员处于C%2B%2B设计的前沿。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1777993|不要重复发明轮子。熟悉STL和Boost，并尽可能使用它们的工具。特别是，使用STL字符串和集合，除非您有非常、非常好的理由不这样做。很好地了解auto_ptr和Boost智能指针库，了解每种类型的智能指针是在什么情况下使用的，然后在您可能使用原始指针的任何地方使用智能指针。您的代码将同样高效，并且不太容易发生内存泄漏。|1777994|使用static_cast、dynamic_cast、const_cast和reinterpret_cast，而不是C风格的强制转换。与C风格的转换不同，它们会让你知道你是否真的想要一个不同类型的转换，而不是你想要的类型。它们在视觉上脱颖而出，提醒读者演员阵容正在发生。|1777995|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Not really a specific tip, but a general guideline: check your sources. C++ is an old language, and it has changed a lot over the years. Best practices have changed with it, but unfortunately there's still a lot of old information out there. There have been some very good book recommendations on here - I can second buying every one of Scott Meyers C++ books. Become familiar with Boost and with the coding styles used in Boost - the people involved with that project are on the cutting edge of C++ design.

Do not reinvent the wheel. Become familiar with the STL and Boost, and use their facilities whenever possible rolling your own. In particular, use STL strings and collections unless you have a very, very good reason not to. Get to know auto_ptr and the Boost smart pointers library very well, understand under which circumstances each type of smart pointer is intended to be used, and then use smart pointers everywhere you might otherwise have used raw pointers. Your code will be just as efficient and a lot less prone to memory leaks.

Use static_cast, dynamic_cast, const_cast, and reinterpret_cast instead of C-style casts. Unlike C-style casts they will let you know if you are really asking for a different type of cast than you think you are asking for. And they stand out viisually, alerting the reader that a cast is taking place.

blocks|key|1562567|text|我已经提到过几次了，但是Scott+Meyer的书Effective+C%2B%2B和Effective+STL对C%2B%2B的帮助是非常有价值的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1562568|想想看，Steven+Dewhurst的C%2B%2B+Gotchas也是一个很好的“来自战沟”的资源。他关于滚动你自己的异常以及如何构建它们的项目在一个项目中确实对我有帮助。|1562569|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/0321334876|1|https://rads.stackoverflow.com/amzn/click/com/0201749629|2|https://rads.stackoverflow.com/amzn/click/com/0321125185^0|P|D|0|13|D|1|0|K|B|2|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]|$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|F|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]|P|$5|I|J|K|C|$L|Q]]]]

I've already mentioned it a few times, but Scott Meyers' books <a href="https://rads.stackoverflow.com/amzn/click/com/0321334876" rel="nofollow noreferrer" rel="nofollow noreferrer">Effective C++</a> and <a href="https://rads.stackoverflow.com/amzn/click/com/0201749629" rel="nofollow noreferrer" rel="nofollow noreferrer">Effective STL</a> are really worth their weight in gold for helping with C++.

Come to think of it, Steven Dewhurst's <a href="https://rads.stackoverflow.com/amzn/click/com/0321125185" rel="nofollow noreferrer" rel="nofollow noreferrer">C++ Gotchas</a> is also an excellent "from the trenches" resource. His item on rolling your own exceptions and how they should be constructed really helped me in one project.

blocks|key|1778104|text|使用像C这样的C%2B%2B，在代码中有一个创建和发布循环。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1778105|在C%2B%2B中，这不是异常安全的，因此版本可能无法执行。在C%2B%2B中，我们使用RAII来解决这个问题。|offset|length|1778106|所有具有手动创建和释放的资源都应该包装在一个对象中，以便这些操作在构造函数/析构函数中完成。|1778107|//+C+Code
void+myFunc()
{
++++Plop*+++plop+=+createMyPlopResource();

++++//+Use+the+plop

++++releaseMyPlopResource(plop);
}|code-block|syntax|javascript|1778108|在C%2B%2B中，这应该包装在一个对象中：|1778109|//+C%2B%2B
class+PlopResource
{
++++public:
++++++++PlopResource()
++++++++{
++++++++++++mPlop=createMyPlopResource();
++++++++++++//+handle+exceptions+and+errors.
++++++++}
++++++++~PlopResource()
++++++++{
+++++++++++++releaseMyPlopResource(mPlop);
++++++++}
++++private:
++++++++Plop*++mPlop;
+};

void+myFunc()
{
++++PlopResource++plop;

++++//+Use+the+plop
++++//+Exception+safe+release+on+exit.
}|1778110|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization^0|0|10|4|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@$D|10|E|11|1|12]]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

Using C++ like C. Having a create-and-release cycle in the code.

In C++, this is not exception safe and thus the release may not be executed. In C++, we use <a href="https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization" rel="nofollow noreferrer">RAII</a> to solve this problem.

All resources that have a manual create and release should be wrapped in an object so these actions are done in the constructor/destructor.

<pre><code>// C Code
void myFunc()
{
 Plop* plop = createMyPlopResource();

 // Use the plop

 releaseMyPlopResource(plop);
}
</code></pre>

In C++, this should be wrapped in an object:

<pre><code>// C++
class PlopResource
{
 public:
 PlopResource()
 {
 mPlop=createMyPlopResource();
 // handle exceptions and errors.
 }
 ~PlopResource()
 {
 releaseMyPlopResource(mPlop);
 }
 private:
 Plop* mPlop;
 };

void myFunc()
{
 PlopResource plop;

 // Use the plop
 // Exception safe release on exit.
}
</code></pre>

blocks|key|1562417|text|对于初级开发人员来说，最重要的陷阱是避免混淆C和C%2B%2B。C%2B%2B永远不应该仅仅被看作是一个更好的C或带有类的C，因为这会削弱它的能力，甚至会使它变得危险(特别是在使用内存时，就像在C中一样)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1562418|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The most important pitfalls for beginning developers is to avoid confusion between C and C++. C++ should never be treated as a mere better C or C with classes because this prunes its power and can make it even dangerous (especially when using memory as in C).

blocks|key|1562484|text|查看boost.org。它提供了许多额外的功能，特别是它们的智能指针实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1562485|entityMap|0|LINK|mutability|MUTABLE|url|http://boost.org/^0|2|9|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Check out <a href="http://boost.org" rel="nofollow noreferrer">boost.org</a>. It provides a lot of additional functionality, especially their smart pointer implementations.

blocks|key|1777810|text|PRQA有基于Scott+Meyer，Bjarne+Stroustrop和Herb+Sutter的书的an+excellent+and+free+C%2B%2B+coding+standard。它将所有这些信息集中在一个文档中。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1777811|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codingstandard.com/^0|1F|15|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

PRQA have <a href="http://www.codingstandard.com/" rel="nofollow noreferrer">an excellent and free C++ coding standard</a> based on books from Scott Meyers, Bjarne Stroustrop and Herb Sutter. It brings all this information together in one document.

blocks|key|1562682|text|使用智能指针和容器类时要小心。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1562683|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Be careful when using smart pointers and container classes.

blocks|key|1562888|text|避免使用pseudo+classes+and+quasi+classes...基本上是过度设计。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1562889|entityMap|0|LINK|mutability|MUTABLE|url|http://www.idinews.com/quasiClass.pdf^0|4|W|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Avoid <a href="http://www.idinews.com/quasiClass.pdf" rel="nofollow noreferrer">pseudo classes and quasi classes</a>... Overdesign basically.

blocks|key|1778307|text|忘记定义基类析构函数virtual。这意味着在Base*上调用delete不会最终析构派生的部分。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1778308|entityMap^0|V|6|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Forgetting to define a base class destructor virtual. This means that calling <code>delete</code> on a Base* won't end up destructing the derived part.

blocks|key|1563048|text|保持名称空间的整洁(包括结构、类、名称空间和使用)。当程序不能编译时，这是我最大的挫败感。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1563049|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Keep the name spaces straight (including struct, class, namespace, and using). That's my number-one frustration when the program just doesn't compile.

blocks|key|1563074|text|要搞砸，就得多用直接指针。取而代之的是，几乎任何事情都使用RAII，当然要确保您使用了正确的智能指针。如果你在句柄或指针类型的类之外的任何地方写"delete“，你很可能做错了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1563075|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

To mess up, use straight pointers a lot. Instead, use RAII for almost anything, making sure of course that you use the right smart pointers. If you write "delete" anywhere outside a handle or pointer-type class, you're very likely doing it wrong.

blocks|key|1778166|text|在取消引用指针之前，一定要检查它。在C中，你通常可以指望在你取消引用一个错误的指针时发生崩溃；在C%2B%2B中，你可以创建一个无效的引用，它将在远离问题根源的地方崩溃。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1778167|class+SomeClass
{
++++...
++++void+DoSomething()
++++{
++++++++%2B%2Bcounter;++++//+crash+here!
++++}
++++int+counter;
};

void+Foo(SomeClass+&+ref)
{
++++...
++++ref.DoSomething();++++//+if+DoSomething+is+virtual,+you+might+crash+here
++++...
}

void+Bar(SomeClass+*+ptr)
{
++++Foo(*ptr);++++//+if+ptr+is+NULL,+you+have+created+an+invalid+reference
++++++++++++++++++//+which+probably+WILL+NOT+crash+here
}|code-block|syntax|javascript|1778168|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Always check a pointer before you dereference it. In C, you could usually count on a crash at the point where you dereference a bad pointer; in C++, you can create an invalid reference which will crash at a spot far removed from the source of the problem.

<pre><code>class SomeClass
{
 ...
 void DoSomething()
 {
 ++counter; // crash here!
 }
 int counter;
};

void Foo(SomeClass &amp; ref)
{
 ...
 ref.DoSomething(); // if DoSomething is virtual, you might crash here
 ...
}

void Bar(SomeClass * ptr)
{
 Foo(*ptr); // if ptr is NULL, you have created an invalid reference
 // which probably WILL NOT crash here
}
</code></pre>

blocks|key|1778191|text|意图是(x+==+10)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1778192|if+(x+=+10)+{
++++//Do+something
}|code-block|syntax|javascript|1778193|我以为我自己永远不会犯这个错误，但我最近确实犯了这个错误。|1778194|entityMap^0|3|9|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Intention is <code>(x == 10)</code>:

<pre><code>if (x = 10) {
 //Do something
}
</code></pre>

I thought I would never make this mistake myself, but I actually did it recently.

blocks|key|1563158|text|我花了很多年做C%2B%2B开发。我写了一个quick+summary，上面写了几年前我遇到的问题。符合标准的编译器不再是一个真正的问题，但我怀疑列出的其他陷阱仍然有效。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1563159|entityMap|0|LINK|mutability|MUTABLE|url|http://btstout.blogspot.com/2005_09_01_archive.html^0|I|D|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I spent many years doing C++ development. I wrote a <a href="http://btstout.blogspot.com/2005_09_01_archive.html" rel="nofollow noreferrer">quick summary</a> of problems I had with it years ago. Standards-compliant compilers are not really a problem anymore, but I suspect the other pitfalls outlined are still valid.

blocks|key|1563089|text|#include+<boost/shared_ptr.hpp>
class+A+{
public:
++void+nuke()+{
+++++boost::shared_ptr<A>+(this);
++}
};

int+main(int+argc,+char**+argv)+{
++A+a;
++a.nuke();
++return(0);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1563090|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#include &lt;boost/shared_ptr.hpp&gt;
class A {
public:
 void nuke() {
 boost::shared_ptr&lt;A&gt; (this);
 }
};

int main(int argc, char** argv) {
 A a;
 a.nuke();
 return(0);
}
</code></pre>

I remember first learning about vectors in the STL and after some time, I wanted to use a vector of bools for one of my projects. After seeing some strange behavior and doing some research, I learned that <a href="http://www.informit.com/guides/content.aspx?g=cplusplus&amp;seqNum=98" rel="noreferrer">a vector of bools is not really a vector of bools</a>.

Are there any other common pitfalls to avoid in C++?

What C++ pitfalls should I avoid?

编译器

容器

我记得我第一次学习STL中的向量，一段时间后，我想在我的一个项目中使用布尔向量。在看到一些奇怪的行为并做了一些研究后，我了解到。在C++中还有其他常见的陷阱需要避免吗？

问我应该避免哪些C++陷阱？
EN

回答 17

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我应该避免哪些C++陷阱？EN

回答 17

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我应该避免哪些C++陷阱？
EN