blocks|key|1214021|text|不要打破常规。最后，你会得到一个不能很好工作的蠕虫球。另外，编译器会讨厌你的。C/C%2B%2B这样设置是有原因的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1214022|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|$]]

Don't break with convention. In the end, you will make a ball of worms that doesn't work very well. Plus, compilers will hate you. C/C++ are setup that way for a reason.

blocks|key|4999294|text|还有另一种选择，但治疗比疾病更糟糕--在头文件中定义所有的函数体，甚至在类中定义内联，比如C#。缺点是这将显著增加编译时间，并且会惹恼经验丰富的C%2B%2B程序员。它还会让你陷入一些令人讨厌的循环依赖的情况，虽然是可以解决的，但处理起来却很麻烦。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4999295|就我个人而言，我只是将IDE设置为垂直拆分，并将头文件放在右侧，源文件放在左侧。|4999296|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|$]]

There is an alternative, but the cure is worse than the illness &mdash; define all the function bodies in the header, or even inline in the class, like C#. The downsides are that this will bloat compile times significantly, and it'll annoy veteran C++ programmers. It can also get you into some annoying situations of circular dependency that, while solvable, are a nuisance to deal with.

Personally, I just set my IDE to have a vertical split, and put the header file on the right side and the source file on the left.

blocks|key|3530918|text|我假设您正在谈论头文件中的成员函数声明和源文件中的定义？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3530919|如果您习惯了Java/Python/等模型，那么它看起来很可能是多余的。实际上，如果您愿意的话，可以在类定义中(在头文件中)内联定义所有函数。但是，每次在实现中更改任何次要内容时，您肯定会打破常规，并付出额外耦合和编译时间的代价。|3530920|C%2B%2B、Ada和其他最初为大规模系统设计的语言隐藏定义是有原因的--没有理由让类的用户关心它的实现，也没有任何理由让他们反复花钱编译它。如今，速度更快的系统不是什么问题，但对于真正的大型系统仍然是相关的。此外，隔离和更快的编译为TDD、存根和其他测试策略提供了便利。|3530921|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 assume you're talking about member function declarations in a header file and definitions in source files?

If you're used to the Java/Python/etc. model, it may well seem redundant. In fact, if you were so inclined, you could define all functions inline in the class definition (in the header file). But, you'd definitely be breaking with convention and paying the price of additional coupling and compilation time every time you changed anything minor in the implementation.

C++, Ada, and other languages originally designed for large scale systems kept definitions hidden for a reason--there's no good reason that the users of a class should have to be concerned with its implementation, nor any reason they should have to repeatedly pay to compile it. Less of an issue nowadays with faster systems, but still relevant for really large systems. Additionally, TDD, stubbing and other testing strategies are facilitated by the isolation and quicker compilation.

blocks|key|3530942|text|你“可以”绕过这个问题。您定义了一个抽象接口类，它只包含外部应用程序将调用的纯虚拟函数。然后在CPP文件中提供从接口派生并包含所有类变量的实际类。您现在可以像往常一样实现。唯一需要的是一种从接口类实例化派生实现类的方法。您可以通过提供一个静态的"Create“函数来实现，该函数的实现在CPP文件中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3530943|即|3530944|InterfaceClass*+InterfaceClass::Create()
{
+++++return+new+ImplementationClass;
}|code-block|syntax|javascript|3530945|通过这种方式，您可以对任何外部用户有效地隐藏实现。但是，您不能仅在堆上创建堆栈上的类……但它确实解决了您的问题，并提供了更好的抽象层。最后，如果你没有准备好这样做，你需要坚持你正在做的事情。|3530946|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You "can" get around the problem. You define an abstract interface class that only contains the pure virtual functions that an outside application will call. Then in the CPP file you provide the actual class that derives from the interface and contains all the class variables. You implement as normal now. The only thing this requires is a way to instantiate the derived implementation class from the interface class. You could do that by providing a static "Create" function that has its implementation in the CPP file.

ie

<pre><code>InterfaceClass* InterfaceClass::Create()
{
 return new ImplementationClass;
}
</code></pre>

This way you effectively hide the implementation from any outside user. You can't, however, create the class on the stack only on the heap ... but it does solve your problem AND provides a better layer of abstraction. In the end though if you aren't prepared to do this you need to stick with what you are doing.

blocks|key|4999393|text|C%2B%2B语言支持函数重载，这意味着整个函数签名基本上是标识特定函数的一种方式。因此，只要单独声明和定义函数，就不需要再次列出参数。更准确地说，必须列出参数类型并不是多余的。另一方面，参数名在这个过程中不起作用，你可以在声明中(即在头文件中)自由地省略它们，尽管我认为这限制了可读性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4999394|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|$]]

C++ language supports function overloading, which means that the entire function signature is basically a way to identify a specific function. For this reason, as long as you declare and define function separately, there's really no redundancy in having to list the parameters again. More precisely, having to list the parameter types is not redundant. Parameters names, on the other hand, play no role in this process and you are free to omit them in the declaration (i.e in the header file), although I belive this limits readability.

Most C++ class method signatures are duplicated between the declaration normally in a header files and the definition in the source files in the code I have read. I find this repetition undesirable and code written this way suffers from poor locality of reference. For instance, the methods in source files often reference instance variables declared in the header file; you end up having to constantly switch between header files and source files when reading code.

Would anyone recommend a way to avoid doing so? Or, am I mainly going to confuse experienced C++ programmers by not doing things in the usual way?

See also <a href="https://stackoverflow.com/questions/583255/c-code-in-header-files">Question 538255 C++ code in header files</a> where someone is told that everything should go in the header.

Is there a good way to avoid duplication of method prototypes in C++?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在我读过的代码中，大多数C++类方法签名都是在头文件中的声明和源文件中的定义之间重复的。我发现这种重复是不可取的，以这种方式编写的代码存在引用局部性差的问题。例如，源文件中的方法通常引用头文件中声明的实例变量；在读取代码时，您最终必须不断地在头文件和源文件之间切换。有没有人能推荐一种避免这样做的方法？或者，我不按通常的...

问在C++中有没有避免方法原型重复的好方法？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中有没有避免方法原型重复的好方法？EN