blocks|key|1581888|text|我经常在C#和C%2B%2B之间切换，C#中缺少头文件是我最大的烦恼之一。我可以查看一个头文件，了解所有我需要知道的关于一个类的信息--它的成员函数被调用了什么，它们的调用语法等等--而不需要费力地阅读实现这个类的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1581889|是的，我知道部分类和#regions，但它们是不同的。分部类实际上使问题变得更糟，因为一个类定义分散在多个文件中。就#regions而言，它们似乎永远不会像我现在所做的那样进行扩展，所以我必须花时间扩展这些小加号，直到我得到正确的视图。|1581890|也许如果Visual+Studio的智能感知在C%2B%2B上工作得更好，我就不会有令人信服的理由不得不如此频繁地引用.h文件，但即使在VS2008中，C%2B%2B的智能感知也无法与C#相提并论|1581891|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|$]]

I routinely flip between C# and C++, and the lack of header files in C# is one of my biggest pet peeves. I can look at a header file and learn all I need to know about a class - what it's member functions are called, their calling syntax, etc - without having to wade through pages of the code that implements the class.

And yes, I know about partial classes and #regions, but it's not the same. Partial classes actually make the problem worse, because a class definition is spread across several files. As far as #regions go, they never seem to be expanded in the manner I'd like for what I'm doing at the moment, so I have to spend time expanding those little plus's until I get the view right.

Perhaps if Visual Studio's intellisense worked better for C++, I wouldn't have a compelling reason to have to refer to .h files so often, but even in VS2008, C++'s intellisense can't touch C#'s

blocks|key|1581809|text|头文件允许独立编译。编译文件不需要访问实现文件，甚至不需要拥有实现文件。这可以使分布式构建变得更容易。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1581810|这也使得SDK可以更容易地完成。您可以只提供头文件和一些库。当然，其他语言也有解决这个问题的方法。|1581811|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|$]]

Header files allow for independent compilation. You don't need to access or even have the implementation files to compile a file. This can make for easier distributed builds. 

This also allows SDKs to be done a little easier. You can provide just the headers and some libraries. There are, of course, ways around this which other languages use.

blocks|key|1366983|text|就连Bjarne+Stroustrup也称头文件是一堆废话。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1366984|但是，如果没有包含必要元数据的标准二进制格式(如Java文件或.Net+PE文件)，我看不到任何实现该特性的方法。剥离的ELF或a.out二进制文件没有您需要提取的太多信息。而且我不认为这些信息会存储在Windows+XCOFF文件中。|1366985|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Bjarne_Stroustrup^0|2|H|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Even <a href="http://en.wikipedia.org/wiki/Bjarne_Stroustrup" rel="noreferrer">Bjarne Stroustrup</a> has called header files a kludge.

But without a standard binary format which includes the necessary metadata (like Java class files, or .Net PE files) I don't see any way to implement the feature. A stripped ELF or a.out binary doesn't have much of the information you would need to extract. And I don't think that the information is ever stored in Windows XCOFF files.

blocks|key|1367300|text|在The+Design+and+Evolution+of+C%2B%2B中，Stroustrup给出了另一个原因...|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1367301|同一个头文件可以有两个或多个实现文件，这些实现文件可以由多个程序员同时处理，而不需要源代码控制系统。|1367302|现在这看起来可能很奇怪，但我猜这是C%2B%2B发明时的一个重要问题。|1367303|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/The_Design_and_Evolution_of_C%252B%252B^0|1|V|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

In <a href="http://en.wikipedia.org/wiki/The_Design_and_Evolution_of_C%2B%2B" rel="noreferrer">The Design and Evolution of C++</a>, Stroustrup gives out one more reason...

The same header file can have two or more implementation files which can be simultaneously worked-upon by more than one programmer without the need of a source-control system.

This might seem odd these days, but I guess it was an important issue when C++ was invented.

blocks|key|1582038|text|如果你想要没有头文件的C%2B%2B，我有个好消息要告诉你。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1582039|它已经存在，名为D+(http://www.digitalmars.com/d/index.html)|offset|length|1582040|从技术上讲，D似乎比C%2B%2B好得多，但目前它还不够主流，无法在许多应用程序中使用。|1582041|entityMap|0|LINK|mutability|MUTABLE|url|http://www.digitalmars.com/d/index.html^0|0|B|13|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

If you want C++ without header files then I have good news for you.

It already exists and is called D (<a href="http://www.digitalmars.com/d/index.html" rel="noreferrer">http://www.digitalmars.com/d/index.html</a>)

Technically D seems to be a lot nicer than C++ but it is just not mainstream enough for use in many applications at the moment.

blocks|key|1366891|text|C+%2B%2B的目标之一是成为C语言的超集，如果它不支持头文件，就很难做到这一点。而且，如果你想删除头文件，你也可以考虑完全去掉CPP+(预处理器，而不是加号)；C#和Java都没有在他们的标准中指定宏预处理器(但应该注意，在某些情况下，它们可以甚至甚至与这些语言一起使用)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1366892|因为C%2B%2B现在已经设计好了，所以您需要原型--就像在C中一样--来静态地检查任何引用外部函数和类的编译代码。如果没有头文件，则必须在使用这些类定义和函数声明之前键入它们。要使C%2B%2B不使用头文件，必须在该语言中添加一个支持诸如import关键字之类的特性。这将是一个主要的补充和改变；回答你的问题，如果它是实用的:我不这么认为--一点也不。|offset|length|style|CODE|1366893|entityMap^0|0|34|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

One of C++'s goals is to be a superset of C, and it's difficult for it to do so if it cannot support header files. And, by extension, if you wish to excise header files you may as well consider excising CPP (the pre-processor, not plus-plus) altogether; both C# and Java do not specify macro pre-processors with their standards (but it should be noted in some cases they can be and even are used even with these languages).

As C++ is designed right now, you need prototypes -- just as in C -- to statically check any compiled code that references external functions and classes. Without header files, you would have to type out these class definitions and function declarations prior to using them. For C++ not to use header files, you'd have to add a feature in the language that would support something like Java's <code>import</code> keyword. That'd be a major addition, and change; to answer your question of if it'd be practical: I don't think so--not at all.

blocks|key|1367493|text|许多人意识到头文件的缺点，并有想法在C%2B%2B中引入更强大的模块系统。你可能想看看Daveed+Vandevoorde的Modules+in+C%2B%2B+(Revision+5)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1367494|entityMap|0|LINK|mutability|MUTABLE|url|http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2316.pdf^0|1M|R|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]]]]

Many people are aware of shortcomings of header files and there are ideas to introduce more powerful module system to C++.
You might want to take a look at <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2316.pdf" rel="noreferrer">Modules in C++ (Revision 5)</a> by Daveed Vandevoorde.

blocks|key|1367111|text|C%2B%2B本身不应该消除头文件，因为它具有向后兼容性。然而，总的来说，我确实认为这是一个愚蠢的想法。如果您想要分发一个闭源库，可以自动提取此信息。如果你想了解如何使用一个没有查看实现的类，这就是文档生成器的用途，它们做得好得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1367112|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|$]]

Well, C++ per se shouldn't eliminate header files because of backwards compatibility. However, I do think they're a silly idea in general. If you want to distribute a closed-source lib, this information can be extracted automatically. If you want to understand how to use a class w/o looking at the implementation, that's what documentation generators are for, and they do a heck of a lot better a job.

blocks|key|1582498|text|在实现文件的单独组件中定义类接口是有价值的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1582499|这可以用接口来完成，但是如果你沿着这条路走下去，那么你就隐含地说类在分离实现和契约方面是有缺陷的。|1582500|模块2有正确的想法、定义模块和实现模块。http://www.modula2.org/reference/modules.php|offset|length|1582501|Java/C#的答案是相同的隐式实现(尽管是面向对象的)。|1582502|头文件是一个杂乱无章的东西，因为头文件表达了实现细节(比如私有变量)。|1582503|在转向Java和C#的过程中，我发现如果一种语言需要集成开发环境的支持(比如公共类接口可以在类浏览器中导航)，那么这可能是一种声明，表明该代码本身并不具有特别的可读性。|1582504|我发现接口和实现细节的混合相当可怕。|1582505|至关重要的是，在一个简洁的、注释良好的独立于实现的文件中记录公共类签名的能力的缺乏向我表明，语言设计是为了方便作者而编写的，而不是为了维护方便。好了，我现在正在漫谈Java和C#。|1582506|entityMap|0|LINK|mutability|MUTABLE|url|http://www.modula2.org/reference/modules.php^0|0|0|K|18|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@$F|12|G|13|1|14]]|A|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|17|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|19|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]]]

There is value in defining the class interface in a separate component to the implementation file. 

It can be done with interfaces, but if you go down that road, then you are implicitly saying that classes are deficient in terms of separating implementation from contract.

Modula 2 had the right idea, definition modules and implementation modules. <a href="http://www.modula2.org/reference/modules.php" rel="nofollow noreferrer">http://www.modula2.org/reference/modules.php</a>

Java/C#'s answer is an implicit implementation of the same (albeit object-oriented.)

Header files are a kludge, because header files express implementation detail (such as private variables.)

In moving over to Java and C#, I find that if a language requires IDE support for development (such that public class interfaces are navigable in class browsers), then this is maybe a statement that the code doesn't stand on its own merits as being particularly readable.

I find the mix of interface with implementation detail quite horrendous. 

Crucially, the lack of ability to document the public class signature in a concise well-commented file independent of implementation indicates to me that the language design is written for convenience of authorship, rather convenience of maintenance. Well I'm rambling about Java and C# now.

blocks|key|1582164|text|如果你想知道这种情况永远不会发生的原因:它会破坏几乎所有现有的C%2B%2B软件。如果你看看C%2B%2B委员会的一些设计文档，他们会考虑各种替代方案，看看它会破坏多少代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1582165|将switch语句更改为某种不太智能的语句要容易得多。这只会破坏一小部分代码。这仍然不会发生。|1582166|为新想法编辑：|1582167|使C%2B%2B头文件成为必要的C%2B%2B和Java之间的区别在于，C%2B%2B对象不一定是指针。在Java中，所有类实例都是由指针引用的，尽管看起来并非如此。C%2B%2B在堆和堆栈上分配了对象。这意味着C%2B%2B需要一种方法来知道对象将有多大，以及数据成员在内存中的什么位置。|1582168|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|$]]

If you want the reason why this will never happen: it would break pretty much all existing C++ software. If you look at some of the C++ committee design documentation, they looked at various alternatives to see how much code it would break.

It would be far easier to change the switch statement into something halfway intelligent. That would break only a little code. It's still not going to happen.

EDITED FOR NEW IDEA:

The difference between C++ and Java that makes C++ header files necessary is that C++ objects are not necessarily pointers. In Java, all class instances are referred to by pointer, although it doesn't look that way. C++ has objects allocated on the heap and the stack. This means C++ needs a way of knowing how big an object will be, and where the data members are in memory.

blocks|key|1582282|text|没有头文件就不存在任何语言。这是个神话。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1582283|看看任何专有的Java库发行版(我没有C#经验，但我希望它们是一样的)。它们不会给出完整的源文件；它们只会给出一个文件，其中每个方法的实现都是空白的({}或{return+null;}或类似的)，并隐藏了所有可以隐藏的东西。除了头之外，你不能称它为任何东西。|offset|length|style|CODE|1582284|然而，没有技术原因，为什么C或C%2B%2B编译器可以将适当标记的文件中的所有内容都算作extern，除非该文件是直接编译的。然而，编译的成本将是巨大的，因为C和C%2B%2B都不能快速解析，这是一个非常重要的考虑因素。任何更复杂的融合头和源代码的方法都会很快遇到技术问题，比如编译器需要知道对象的布局。|1582285|entityMap^0|0|23|2|26|E|0|14|6|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|K|$]]

No language exists without header files. It's a myth.

Look at any proprietary library distribution for Java (I have no C# experience to speak of, but I'd expect it's the same). They don't give you the complete source file; they just give you a file with every method's implementation blanked (<code>{}</code> or <code>{return null;}</code> or the like) and everything they can get away with hiding hidden. You can't call that anything but a header.

There is no technical reason, however, why a C or C++ compiler could count everything in an appropriately-marked file as <code>extern</code> unless that file is being compiled directly. However, the costs for compilation would be immense because neither C nor C++ is fast to parse, and that's a very important consideration. Any more complex method of melding headers and source would quickly encounter technical issues like the need for the compiler to know an object's layout.

blocks|key|1367370|text|哦，是的!|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1367371|在用Java和C#编写代码之后，每个类都有两个文件真的很烦人。所以我在想如何在不破坏现有代码的情况下合并它们。|1367372|事实上，这真的很简单。只需将定义(实现)放在#ifdef部分中，并在编译器命令行上添加一个定义来编译该文件。就这样。|1367373|下面是一个示例：|1367374|/*+File+ClassA.cpp+*/

#ifndef+_ClassA_
#define+_ClassA_

#include+"ClassB.cpp"
#include+"InterfaceC.cpp"

class+ClassA+:+public+InterfaceC
{
public:
++++ClassA(void);
++++virtual+~ClassA(void);

++++virtual+void+methodC();

private:
++++ClassB+b;
};

#endif

#ifdef+compiling_ClassA

ClassA::ClassA(void)
{
}

ClassA::~ClassA(void)
{
}

void+ClassA::methodC()
{
}

#endif|code-block|syntax|javascript|1367375|在命令行上，使用以下命令编译该文件|1367376|-D+compiling_ClassA|1367377|其他需要包含ClassA的文件也可以|1367378|#include+"ClassA.cpp"|1367379|当然，可以使用宏扩展(Visual+Studio编译器)或自动变量(gnu+make)轻松地在命令行中添加定义，并使用与定义名称相同的命名法。|1367380|entityMap^0|0|0|0|0|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|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

Oh Yes!

After coding in Java and C# it's really annoying to have 2 files for every classes. So I was thinking how can I merge them without breaking existing code.

In fact, it's really easy. Just put the definition (implementation) inside an #ifdef section and add a define on the compiler command line to compile that file. That's it.

Here is an example:

<pre><code>/* File ClassA.cpp */

#ifndef _ClassA_
#define _ClassA_

#include "ClassB.cpp"
#include "InterfaceC.cpp"

class ClassA : public InterfaceC
{
public:
 ClassA(void);
 virtual ~ClassA(void);

 virtual void methodC();

private:
 ClassB b;
};

#endif

#ifdef compiling_ClassA

ClassA::ClassA(void)
{
}

ClassA::~ClassA(void)
{
}

void ClassA::methodC()
{
}

#endif
</code></pre>

On the command line, compile that file with

<pre><code>-D compiling_ClassA
</code></pre>

The other files that need to include ClassA can just do

<pre><code>#include "ClassA.cpp"
</code></pre>

Of course the addition of the define on the command line can easily be added with a macro expansion (Visual Studio compiler) or with an automatic variables (gnu make) and using the same nomenclature for the define name.

blocks|key|1582593|text|不过，我还是不明白一些陈述的要点。分离API和实现是一件非常好的事情，但是头文件不是API。那里有私有字段。如果添加或删除私有字段，则会更改实现而不是API。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1582594|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|$]]

Still I don't get the point of some statements. Separation of API and implementation is a very good thing, but header files are not API. There are private fields there. If you add or remove private field you change implementation and not API.

Many languages, such as Java, C#, do not separate declaration from implementation. C# has a concept of partial class, but implementation and declaration still remain in the same file. 

Why doesn't C++ have the same model? Is it more practical to have header files?

I am referring to current and upcoming versions of C++ standard.

Should C++ eliminate header files?

许多语言，如Java、C#，都没有将声明和实现分开。C#有分部类的概念，但实现和声明仍然保留在同一个文件中。为什么C++没有相同的模型？有头文件是不是更实用？我指的是C++标准的当前和即将发布的版本。

问C++应该去掉头文件吗？
EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++应该去掉头文件吗？EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++应该去掉头文件吗？
EN