blocks|key|895848|text|通常，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|895849|operator+string+()+const;|code-block|syntax|javascript|895850|或|895851|friend+ostream&+operator+<<+(ostream&,+const+MyClass&);|895852|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Often,

<pre><code>operator string () const;
</code></pre>

or

<pre><code>friend ostream& operator &lt;&lt; (ostream&, const MyClass&);
</code></pre>

blocks|key|55668|text|在类定义后添加分号。每当我忘记这样做的时候，这就一直让我头疼，因为gcc的错误消息是模糊的，它通常会说“无法在函数的返回类型中定义类型”，这并不意味着什么……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|55669|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|$]]

Adding a semicolon after the class definition. This continuously bites me in the ass every time I forget to do it since gcc's error messages are vague and it generally says something like "can't define a type in the return type of a function" which doesn't mean a whole lot...

blocks|key|3276877|text|我发现打开-Wall、-Werror和(这是一个有趣的)+-Weffc%2B%2B的gcc标志可以帮助捕捉到很多潜在的问题。从gcc手册页：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3276878|3276879|+-Weffc%2B%2B+(仅限C%2B%2B+)警告违反Scott+Meyer的Effective+C%2B%2B一书中的以下样式准则：·第11项:为具有动态分配内存的类定义复制构造函数和赋值运算符。·第12项:在构造函数中首选初始化而不是赋值。·第14项:在基类中将析构函数设为虚的。·第15项:让"operator=“返回一个对*this的引用。·第23项:当必须返回对象时，不要尝试返回引用。关于违反Scott+Meyer的More+Effective+C%2B%2B一书中的以下风格准则：·项目6:区分递增和递减运算符的前缀和后缀形式。·第七项:永远不要重载"&&“、"││”或"，“。如果您使用此选项，您应该意识到标准库头文件并不遵守所有这些准则；您可以使用grep+-v来过滤掉这些警告。|blockquote|3276880|3276881|entityMap^0|5|5|B|7|T|8|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|U|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|V|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|L|$]]

I find turning on the gcc flags <code>-Wall</code>, <code>-Werror</code>, and (this is the fun one) <code>-Weffc++</code> help catch a lot of potential problems. From the gcc man page:

<blockquote>
<pre><code> -Weffc++ (C++ only)
 Warn about violations of the following style guidelines from Scott
 Meyers’ Effective C++ book:

 · Item 11: Define a copy constructor and an assignment operator
 for classes with dynamically allocated memory.

 · Item 12: Prefer initialization to assignment in constructors.

 · Item 14: Make destructors virtual in base classes.

 · Item 15: Have "operator=" return a reference to *this.

 · Item 23: Don’t try to return a reference when you must return
 an object.

 and about violations of the following style guidelines from Scott
 Meyers’ More Effective C++ book:

 · Item 6: Distinguish between prefix and postfix forms of incre-
 ment and decrement operators.

 · Item 7: Never overload "&amp;&amp;", "││", or ",".

 If you use this option, you should be aware that the standard
 library headers do not obey all of these guidelines; you can use
 grep -v to filter out those warnings.
</code></pre>
</blockquote>

blocks|key|4122146|text|在头文件中，执行|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4122147|#ifndef+__SOMEDEFINE__
#define+__SOMEDEFINE__

#endif|code-block|syntax|javascript|4122148|在VS中，我添加了|4122149|#pragma+warning(disable:+4786)|4122150|哦，我还用了|4122151|#include+<inttypes.h>|4122152|因为i+<3种C99类型。|4122153|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

In header files, do

<pre><code>#ifndef __SOMEDEFINE__
#define __SOMEDEFINE__

#endif
</code></pre>

In VS, I add

<pre><code>#pragma warning(disable: 4786)
</code></pre>

Oh, I also use 

<pre><code>#include &lt;inttypes.h&gt;
</code></pre>

cuz I &lt;3 C99 types.

blocks|key|55777|text|I通常包括一个返回代码的枚举，这样类就可以告诉它的调用者在它的成员函数中发生了什么。大多数情况下，这将是类的所有成员返回的唯一类型。所有结果都是通过引用传回的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|55778|entityMap^0|1|2|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|$]]

I usually include an enum of return codes, so the class can tell its callers what happened in its member functions. Most often, this will be the only type returned by all the members of the class. All results are passed back by reference.

blocks|key|4122263|text|当我把一个类放在一起时，我做的第一件事就是在它上面放一些doxygen注释，说明它为什么存在以及它做了什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4122264|我曾经在一个小组项目中工作，他们说他们想在项目结束时记录这些东西。而且稍后将注释放入代码中也是一团糟。我不想让这种事情再次发生。|4122265|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The first i do when putting a class together is putting some doxygen comment above it about why it exists and what it does. 

I once worked on a group project where they said they want to document the stuff at the end of the project. And it was all of a mess to put the comments into the code later on. I don't want to have this happen again.

blocks|key|891119|text|奇怪的是，这里的大多数建议都是我特别不会做的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|891120|891121|我不会让dtors变成虚拟的，除非我专门把它设计成继承的。它增加了很多开销，并阻止了自动内联，这很糟糕，因为大多数ctor无论如何都是空的(而且很少有类从继承中受益)|unordered-list-item|891122|我不会进行复制ctor/赋值操作，除非缺省值不起作用--如果不起作用，我可能会重新考虑设计。记住，在string和vector之间，几乎再也没有理由调用new了。创建你自己的复制ctor，和默认的一样，效率几乎肯定会更低。|891123|，|891124|，我不会添加字符串转换。它导致了太多的问题，在你不想要的地方，强制转换被静默地调用。最好添加一个ToString()方法。|891125|我不添加朋友oper<<，因为朋友是邪恶和混乱的。最好添加一个Display(ostream)方法。然后oper<<可以调用它，而不需要成为朋友。实际上，您可以使oper<<成为调用Display()的模板函数，而再也不用担心它了。|891126|891127|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|R|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|T|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|V|8|@]|9|@]|A|$]]|$1|L|3|M|5|E|7|W|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

Oddly, most of the suggestions here are things I specifically don't do.

<ul>
<li>I don't make dtors virtual unless I am designing it specifically to be inherited. It adds a lot of overhead and prevents automatic inlining, which is bad since most dtors are empty anyways (and few classes benefit from inheritance)</li>
<li>I don't make copy ctor/assignment op unless the defaults won't work -- and if it won't, I may want to reconsider the design. Remember, between string &amp; vector, there's hardly ever a reason to call new anymore. And creating your own copy ctor identical to the default one will almost certainly be less efficient.</li>
<li>I don't add string cast. It causes too many problems where the cast is called silently where you didn't intend it to be. Better to add a ToString() method.</li>
<li>I don't add a friend oper&lt;&lt;, because friends are evil and messy. Better to add a Display(ostream) method. Then the oper&lt;&lt; can call that, and doesn't need to be a friend. In fact, you could make the oper&lt;&lt; a template function calling Display() and never have to worry about it again.</li>
</ul>

blocks|key|55997|text|我首先调用开发环境宏来设置包含保护(#ifdefs和/或#杂注一次)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|55998|接下来，我删除类名和它所在的任何名称空间，而根本不添加任何功能。|55999|然后，我为该类创建单元测试文件，并添加第一个测试(通常是参数构造函数测试)。|56000|我只是从那里开始工作，在思考我真正需要它的时候，编写和重构类。我倾向于专门测试的东西:常量正确性、隐式和显式转换、抛出的异常类型等。|56001|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I start by calling the development environment macro that sets up the include guards (#ifdefs and/or #pragma once).

Next I stub out the class name and any namespace it will be in, without adding any functionality at all.

Then I create the unit test file for that class, and add the first test (usually a parameter constructor test).

I just work from there, writing and refactoring the class as I think about what I really need from it. Things I tend to test specifically: const-correctness, implicit and explicit conversions, types of exceptions thrown, etc.

blocks|key|891164|text|停下来思考|type|unstyled|depth|inlineStyleRanges|entityRanges|data|891165|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|$]]

blocks|key|3277309|text|对于一个全新的类文件，我做的第一件事就是写几段注释，说明这个类做什么，为什么它存在，它使用什么类，以及如何使用它。在模块中随机打开文件的人从该注释中知道足够的信息就可以找到他们实际正在寻找的文件，这就足够了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3277310|我同意James的观点--我非常小心地避免向不需要的类添加功能，大多数类都不需要虚拟析构函数(或者根本不需要析构函数)。如果他们这样做了，我质疑他们为什么不直接使用智能指针和其他自动内存管理。显然，有许多类(即智能范围锁)确实需要析构函数，但这不是理所当然的事情。|3277311|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The first thing I do with a totally new class file is to write several paragraphs of comments on what the class does, why it exists, what classes it uses and how to use it. It should be enough that someone who randomly opens up a file in a module knows enough from that comment to find the file they are actually looking for.

I agree with James - I am very careful not to add functionality to a class that does not need it, most classes do not need a virtual destructor (or a destructor at all). If they do, I question why they don't just use smart pointers and other automatic memory management. Obviously there are many classes (i.e smart scoped locks) that DO need a destructor but it is not just a matter of course to make on.

There are a few things that I almost always do when I put a class together in C++.

1) Virtual Destructor
2) Copy constructor and assignment operator (I either implement them in terms of a private function called Copy(), or declare them private and thus explicitly disallow the compiler to auto generate them).

What things do you find are almost always useful?

In C++, what do you do nearly all the time?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

当我在C++中组合一个类时，我几乎总是会做一些事情。1)虚拟析构函数2)复制构造函数和赋值运算符(我要么通过一个称为Copy()的私有函数来实现它们，要么将它们声明为私有，从而显式地禁止编译器自动生成它们)。你发现什么东西几乎总是有用的？

问在C++中，你几乎一直在做什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中，你几乎一直在做什么？EN