blocks|key|1693975|text|您可以使用不同的技术来说明您的意图，而不会让工具感到不快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1693976|#define+CONST_RETURN

CONST_RETURN+int+foo();|code-block|syntax|javascript|1693977|使用const+char+*没有问题，因为它声明的是指向常量字符的指针，而不是常量指针。|offset|length|style|CODE|1693978|entityMap^0|0|0|2|C|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can use a different technique to illustrate your intent without making the tools unhappy.

<pre><code>#define CONST_RETURN

CONST_RETURN int foo();
</code></pre>

You don't have a problem with <code>const char *</code> because that's declaring a pointer to constant chars, not a constant pointer.

blocks|key|1694020|text|对于你的代码来说，尽可能准确地描述正在发生的事情通常是更好的。您会收到此警告，因为const+int+foo();中的const基本上没有任何意义。只有当您不知道const关键字的含义时，该应用程序接口才显得更加清晰。不要重载这样的含义；static已经足够糟糕了，没有理由增加更多混淆的可能性。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1694021|const+char+*的含义与const+int有所不同，这就是您的工具不会抱怨它的原因。前者是一个指向常量字符串的指针，这意味着任何调用返回该类型的函数的代码都不应该试图修改字符串的内容(例如，它可能在ROM中)。在后一种情况下，系统无法强制您不对返回的int进行更改，因此限定符是没有意义的。与返回类型更相似的是：|1694022|const+int+foo();
char+*+const+foo2();|code-block|syntax|javascript|1694023|这都会导致您的静态分析给出警告-将常量限定符添加到返回值是一个无意义的操作。只有当你有一个引用参数(或返回类型)时，它才有意义，就像你的const+char+*例子。|1694024|其实我刚刚做了一个小测试程序，对于这个问题，GCC甚至明确提出了警告：|1694025|test.c:6:+warning:+type+qualifiers+ignored+on+function+return+type|1694026|所以不仅仅是你的静态分析程序在抱怨。|1694027|entityMap^0|15|G|1N|5|29|5|3B|6|0|0|C|G|9|3L|3|0|0|1W|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1G|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1H|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|1I|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|V|$]]

It's usually better for your code to describe as accurately as possible what's going on. You're getting this warning because the <code>const</code> in <code>const int foo();</code> is basically meaningless. The API only seems clearer if you don't know what the <code>const</code> keyword means. Don't overload meaning like that; <code>static</code> is bad enough as it is, and there's no reason to add the potential for more confusion.

<code>const char *</code> means something different than <code>const int</code> does, which is why your tool doesn't complain about it. The former is a pointer to a constant string, meaning any code calling the function returning that type shouldn't try to modify the contents of the string (it might be in ROM for example). In the latter case, the system has no way to enforce that you not make changes to the returned <code>int</code>, so the qualifier is meaningless. A closer parallel to the return types would be:

<pre><code>const int foo();
char * const foo2();
</code></pre>

which will both cause your static analysis to give the warning - adding a const qualifier to a return value is a meaningless operation. It only makes sense when you have a a reference parameter (or return type), like your <code>const char *</code> example.

In fact, I just made a little test program, and GCC even explicitly warns about this problem:

<pre><code>test.c:6: warning: type qualifiers ignored on function return type
</code></pre>

So it's not just your static analysis program that's complaining.

blocks|key|1694042|text|const+int+foo()与const+char*+foo()非常不同。const+char*+foo()返回一个数组(通常是一个字符串)，该数组的内容不允许更改。想一想它们之间的区别：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1694043|+const+char*+a+=+"Hello+World";|code-block|syntax|javascript|1694044|和|1694045|const+int+b+=+1;|1694046|a仍然是一个变量，可以赋值给其他不能改变的字符串，而b不是一个变量。所以|1694047|const+char*+foo();
const+char*+a+=+"Hello+World\n";
a+=+foo();|1694048|是允许的，但是|1694049|const+int+bar();
const+int+b+=+0;
b+=+bar();|1694050|是不允许的，即使使用bar()的const声明也是如此。|1694051|entityMap^0|0|F|G|H|12|H|0|0|0|0|0|1|Q|1|0|0|0|0|A|5|G|5|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1G|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|Z|$]]

<code>const int foo()</code> is very different from <code>const char* foo()</code>. <code>const char* foo()</code> returns an array (usually a string) whose content is not allowed to change. Think about the difference between:

<pre><code> const char* a = "Hello World";
</code></pre>

and

<pre><code>const int b = 1;
</code></pre>

<code>a</code> is still a variable and can be assigned to other strings that can't change whereas <code>b</code> is not a variable. So

<pre><code>const char* foo();
const char* a = "Hello World\n";
a = foo();
</code></pre>

is allowed but

<pre><code>const int bar();
const int b = 0;
b = bar();
</code></pre>

is not allowed, even with the <code>const</code> declaration of <code>bar()</code>.

blocks|key|287768|text|现在忽略const，foo()返回值。你可以做到|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|287769|int+x+=+foo();|code-block|syntax|javascript|287770|并将foo()返回的值赋给变量x，方法与您可以执行的操作大致相同|287771|int+x+=+42;|287772|将值42赋值给变量x。|287773|但您不能更改42+...或foo()返回的值。通过将const关键字应用于foo()类型来声明从foo()返回的值不能更改，这样做什么也做不到。|287774|值不能为const+(或restrict__或volatile)。只有对象才能有类型限定符。|BOLD|287775|287776|与之对比|287777|const+char+*foo();|287778|在这种情况下，foo()返回一个指向对象的指针。返回值指向的对象可以是限定的const。|287779|entityMap^0|4|5|A|5|0|0|2|5|F|1|0|0|2|2|0|6|2|D|5|Q|5|11|5|1C|5|0|0|1|4|5|C|8|N|8|0|0|0|0|7|5|12|5|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1J|8|@$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1U|8|@$9|1V|A|1W|B|U]|$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]|$9|21|A|22|B|C]]|D|@]|E|$]]|$1|V|3|-4|5|6|7|23|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|24|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|25|8|@]|D|@]|E|$I|J]]|$1|10|3|11|5|6|7|26|8|@$9|27|A|28|B|C]|$9|29|A|2A|B|C]]|D|@]|E|$]]|$1|12|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]]|13|$]]

Ignoring the <code>const</code> for now, <code>foo()</code> returns a value. You can do

<pre><code>int x = foo();
</code></pre>

and assign the value returned by <code>foo()</code> to the variable <code>x</code>, in much the same way you can do

<pre><code>int x = 42;
</code></pre>

to assign the value <code>42</code> to variable x. 
But you cannot change the <code>42</code> ... or the value returned by <code>foo()</code>. Saying that the value returned from <code>foo()</code> cannot be changed, by applying the <code>const</code> keyword to the type of <code>foo()</code> accomplishes nothing.

Values cannot be <code>const</code> (or <code>restrict</code>, or <code>volatile</code>). Only objects can have type qualifiers.

<hr>

Contrast with

<pre><code>const char *foo();
</code></pre>

In this case, <code>foo()</code> returns a pointer to an object. The object pointed to by the value returned can be qualified <code>const</code>.

blocks|key|1708941|text|int由copy返回。它可能是const的副本，但当它被分配给其他东西时，凭借它是可分配的事实，根据定义，它不能是const。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1708942|关键字const在语言中具有特定的语义，而在这里，您将其误用为注释。与其说它增加了清晰度，不如说它暗示了对语言语义的误解。|1708943|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 int is returned by copy. It may be a copy of a const, but when it is assigned to something else, that something by virtue of the fact that it was assignable, cannot by definition be a const. 

The keyword const has specific semantics within the language, whereas here you are misusing it as essentially a comment. Rather than adding clarity, it rather suggests a misunderstanding of the language semantics.

Our static analysis tool complains about a "useless type qualifier on return type" when we have prototypes in header files such as:

<pre><code>const int foo();
</code></pre>

We defined it this way because the function is returning a constant that will never change, thinking that the API seemed clearer with <code>const</code> in place.

I feel like this is similar to explicitly initializing global variables to zero for clarity, even though the C standard already states that all globals will be initialized to zero if not explicitly initialized. At the end of the day, it really doesn't matter. (But the static analysis tool doesn't complain about that.)

My question is, is there any reason that this could cause a problem? Should we ignore the errors generated by the tool, or should we placate the tool at the possible cost of a less clear and consistent API? (It returns other <code>const char*</code> constants that the tool doesn't have a problem with.)

Should useless type qualifiers on return types be used, for clarity?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

当我们在头文件中有原型时，我们的静态分析工具会抱怨“返回类型上的无用类型限定符”，例如：const int foo();我们这样定义它是因为函数返回一个永远不会改变的常量，认为有了const，应用编程接口似乎更清晰。为了清晰起见，我觉得这类似于显式地将全局变量初始化为零，即使C标准已经声明，如果不显式初始化，所有全局变...

问为了清楚起见，应该在返回类型上使用无用的类型限定符吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为了清楚起见，应该在返回类型上使用无用的类型限定符吗？EN