blocks|key|1879100|text|TL;DR;所有的原型都是声明，但并不是所有的声明都是原型。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1879101|声明是通用术语中使用的标准，原型更具体。|1879102|引用C11，第6.7章|CODE|1879103|声明指定一组标识符的解释和属性。..。|blockquote|1879104|从第6.7.6节起，|1879105|每个声明器声明一个标识符，并声明当一个与声明器形式相同的操作数出现在表达式中时，它指定一个函数或对象，其作用域、存储时间和声明说明符所指示的类型。|1879106|另一方面，取自第6.2.1章|1879107|……函数原型是声明其参数类型的函数的声明。|1879108|因此，一个线性，原型是更完整的形式(包括参数类型)的声明。|1879109|关于“标识符”：第6.4.2.1章，|1879110|标识符是一系列非数字字符(包括下划线_、小写和大写拉丁字母以及其他字符)和数字，它们指定一个或多个实体，如6.2.1中所述。..。|1879111|在第6.2.1章中，|1879112|标识符可以表示一个对象；一个函数；一个标签或一个结构、联合或枚举的成员；一个类型胡枝子名称；一个标签名称；一个宏名称；或者一个宏参数。……|1879113|entityMap^0|0|6|0|0|2|3|0|0|0|0|0|0|0|0|I|1|0|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1A|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1B|8|@$9|1C|A|1D|B|J]]|D|@]|E|$]]|$1|K|3|L|5|M|7|1E|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1F|8|@]|D|@]|E|$]]|$1|P|3|Q|5|M|7|1G|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1H|8|@]|D|@]|E|$]]|$1|T|3|U|5|M|7|1I|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|1J|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|1K|8|@]|D|@]|E|$]]|$1|Z|3|10|5|M|7|1L|8|@$9|1M|A|1N|B|J]]|D|@]|E|$]]|$1|11|3|12|5|6|7|1O|8|@]|D|@]|E|$]]|$1|13|3|14|5|M|7|1P|8|@]|D|@]|E|$]]|$1|15|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]]|16|$]]

TL;DR; All prototypes are declarations, but not all declarations are prototypes.

Declaration is the generic terminology used in the standards, prototype is more specific.

Quoting <code>C11</code>, chapter §6.7

<blockquote>
 A declaration specifies the interpretation and attributes of a set of identifiers. [...]
</blockquote>

and from §6.7.6, 

<blockquote>
 Each declarator declares one identifier, and asserts that when an operand of the same
 form as the declarator appears in an expression, it designates a function or object with the
 scope, storage duration, and type indicated by the declaration specifiers.
</blockquote>

On the other hand, from chapter §6.2.1

<blockquote>
 [....] A function
 prototype is a declaration of a function that declares the types of its parameters.
</blockquote>

So, one liner, prototype is more complete form (including types of parameter) of declaration.

<hr>

About "identifier": chapter §6.4.2.1,

<blockquote>
 An identifier is a sequence of nondigit characters (including the underscore <code>_</code>, the
 lowercase and uppercase Latin letters, and other characters) and digits, which designates
 one or more entities as described in 6.2.1. [...]
</blockquote>

and in chapter §6.2.1,

<blockquote>
 An identifier can denote an object; a function; a tag or a member of a structure, union, or
 enumeration; a typedef name; a label name; a macro name; or a macro parameter. [....]
</blockquote>

blocks|key|1879137|text|声明引入了一个名称：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1879138|int+a;++++//+"a"+has+type+int|code-block|syntax|javascript|1879139|函数声明(也不是原型)只引入函数的名称及其返回类型：|1879140|int+f();+++//+a+function+call+expression+"f(x,+y,+...)"+has+type+int|1879141|但是，这样的函数声明没有指定哪些参数对函数调用有效；换句话说，它没有指定函数签名。这是由一个函数原型完成的(这是一种声明)：|1879142|int+g1(void);+++++++++//+"g1"+takes+no+arguments,+"g()"+has+type+int
int+g2(float,+char);++//+"g2"+takes+two+arguments
int+g3(int,+...);+++++//+"g3"+takes+at+least+one+argument|1879143|函数原型在函数调用时是否可见，对调用参数有重要影响:如果没有原型可见，所有参数都会经历默认的参数提升。相反，如果原型可用，函数参数将转换为相应形式参数的类型(如果参数数量不匹配或任何转换都不正确，则程序的格式不正确)。|1879144|要进一步探讨这一点，请注意有某些“不可能”的组合:如果我们有一个声明int+g2();和一个定义int+g2(float,+char)+{+return+0;+}，那么就永远不可能只使用声明调用g2，因为形式参数类型不能由默认的参数提升产生。通常情况下，最好总是使用原型声明，而不要使用非原型声明。|offset|length|style|CODE|1879145|最后，如果原型以省略号(...)结尾，则可以使用比参数更多的参数调用原型函数。使用<stdarg.h>获取这些参数需要在调用这样一个变量参数函数时，函数原型是可见的。|1879146|entityMap^0|0|0|0|0|0|0|0|Y|9|1C|X|2P|2|0|C|3|15|A|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|17|8|@$S|18|T|19|U|V]|$S|1A|T|1B|U|V]|$S|1C|T|1D|U|V]]|9|@]|A|$]]|$1|W|3|X|5|6|7|1E|8|@$S|1F|T|1G|U|V]|$S|1H|T|1I|U|V]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|Z|$]]

A declaration introduces a name:

<pre><code>int a; // "a" has type int
</code></pre>

A function declaration (that is not also a prototype) only introduces the name of a function and its return type:

<pre><code>int f(); // a function call expression "f(x, y, ...)" has type int
</code></pre>

However, such a function declaration does not specify which arguments are valid for the function call; in other words, it does not specify the function signature. This is done by a function prototype (which is a kind of declaration):

<pre><code>int g1(void); // "g1" takes no arguments, "g()" has type int
int g2(float, char); // "g2" takes two arguments
int g3(int, ...); // "g3" takes at least one argument
</code></pre>

Whether a function prototype is visible at the time of a function call has important consequences on the call arguments: If no prototype is visible, all arguments undergo default argument promotions. By contrast, if a prototype is available, function arguments are converted to the types of the corresponding formal parameters (and the program is ill-formed if the number of arguments doesn't match or if any of the conversions would be ill-formed).

To explore this further, observe that there are certain "impossible" combinations: If we had a declaration <code>int g2();</code> and a definition <code>int g2(float, char) { return 0; }</code>, it would never be possible to call <code>g2</code> just with the declaration, because the formal parameter types cannot result from default argument promotions. It is generally advisable to always use prototype declarations and never use non-prototype declarations.

Finally, it is possible to call a prototyped function with more arguments than it has parameters, if the prototype ends in the ellipsis (<code>...</code>). The use of <code>&lt;stdarg.h&gt;</code> to get at those arguments requires that a function prototype is visible at the time of call for such a variable-argument function.

blocks|key|2873987|text|根据C标准(6.2.1identiﬁers的Scopes+)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2873988|blockquote|2873989|.(函数原型是声明参数类型的函数的声明)。|ordered-list-item|2873990|也就是说，原型提供了有关函数参数类型的信息。|2873991|例如，考虑|2873992|void+f();|code-block|syntax|javascript|2873993|和|2873994|void+f(+void+);|2873995|第一个声明不是原型，因为对函数参数一无所知。|2873996|第二个声明是一个原型，因为它提供了一个函数参数的类型列表(它是类型列表的一种特殊类型--ﬁ，函数没有参数)。|2873997|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|-4|5|C|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|14|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|15|8|@]|9|@]|A|$]]|$1|R|3|S|5|M|7|16|8|@]|9|@]|A|$N|O]]|$1|T|3|U|5|6|7|17|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|18|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|Y|$]]

According to the C Standard (6.2.1 Scopes of identiﬁers)

<blockquote>
 <ol start="2">
 <li>...(A function prototype is a declaration of a function that declares the 
 types of its parameters.)</li>
 </ol>
</blockquote>

That is a prototype provides the information about the types of the function parameters.

Consider for example

<pre><code>void f();
</code></pre>

and 

<pre><code>void f( void );
</code></pre>

The first declaration is not a prototype because there is nothing known about the function parameters.

The second declaration is a prototype because it provides a type list of the function parameters (it is a special kind of the type list speciﬁes that the function has no parameters).

blocks|key|1879217|text|函数声明是声明函数并以;结尾的任何形式的行。|type|unordered-list-item|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1879218|prototype是一个函数声明，其中指定了所有类型的参数。|1879219|示例，原型函数声明：void+func+(void);|unstyled|1879220|例如，非原型函数声明：void+func+();。|1879221|非原型函数声明是一个过时的特性(6.11.6)，可能会从C语言中删除。因此，您应该始终使用原型格式，而不是其他任何东西。|1879222|entityMap^0|B|1|0|0|A|H|0|B|D|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|K|3|L|5|J|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|M|3|N|5|J|7|10|8|@]|D|@]|E|$]]|$1|O|3|-4|5|J|7|11|8|@]|D|@]|E|$]]]|P|$]]

<ul>
<li>A function declaration is any form of line declaring a function and ending with <code>;</code>. </li>
<li>A prototype is a function declaration where all types of the parameters are specified. </li>
</ul>

Example, prototype function declaration: <code>void func (void);</code> 
Example, non-prototype function declaration: <code>void func ();</code>.

Non-prototype function declarations is an obsolescent feature (6.11.6) that may get removed from the C language. Therefore you should always use prototype format and never anything else.

What is the difference between declaration and prototype in C? In which situations they are called declarations and in which prototypes?

Declaration and prototype difference

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在C语言中声明和原型有什么区别？在什么情况下，它们被称为声明，在哪些原型中？

问声明和原型差异
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问声明和原型差异EN