const int *p 与 int const *p - 类型后面的 const 是否可以接受？

Question

我的同事对他启发的问题的得分是 0 比 2 (1< /a>，2），所以我想我应该给他一个机会跟上来。

我们最新的分歧是关于在声明中放置“const”的样式问题。

他认为它应该位于类型前面或指针后面。 原因是，这通常是其他人所做的，而其他风格很容易令人困惑。 因此，指向常量 int 的指针和指向 int 的常量指针将分别是：

const int *i;
      int * const i;

但是，我还是很困惑。 我需要一致且易于理解的规则，而我理解“const”的唯一方法是它位于它正在修改的内容之后。 有一个例外允许它位于最终类型之前，但那是一个例外，所以如果我不使用它，对我来说会更容易。

因此，指向常量 int 的指针和指向 int 的常量指针分别是：

int const * i;
int * const i;

作为一个额外的好处，以这种方式执行操作可以使更深层次的间接更容易理解。 例如，指向 int 的常量指针的指针显然是：

int * const * i;

我的论点是，如果有人按照自己的方式学习它，他们将很容易弄清楚上面的结果。

这里的最终问题是，他认为将 const 放在 int 后面是难以形容的丑陋，并且对可读性非常有害，因此应该在样式指南中禁止它。 当然，我认为指南应该建议按照我的方式进行，但无论哪种方式，我们都不应该禁止一种方法。

编辑： 我得到了很多好的答案，但没有一个真正直接解决我的最后一段（“最终问题”）。 很多人都主张一致性，但在这种情况下，这是否如此理想，以至于最好禁止其他实现方式，而不是仅仅阻止它？

Answer 1

最重要的是一致性。 如果没有任何编码指南，那么选择一个并坚持使用。 但是，如果您的团队已经有了事实上的标准，请不要更改它！

也就是说，我认为到目前为止更常见的是

const int * i;
int * const j;

因为大多数人都写

const int n;

而不是

int const n;

旁注 - 读取指针常量的一种简单方法是从右侧开始读取声明。

const int * i; // pointer to an int that is const
int * const j; // constant pointer to a (non-const) int
int const * aLessPopularWay; // pointer to a const int

Answer 2

有一类示例将 const 放在类型右侧也有助于避免混淆。

如果 typedef 中有指针类型，则无法将类型的常量更改为：

typedef int * PINT;
const PINT pi;

pi仍然具有类型int * const< /code>，无论你在哪里编写const，这都是一样的。

Answer 3

我希望 B. Stroustrup 关于 Style & 的常见问题解答对此做出解释。 技术会给你明确的答案。

Bjarne Stroustrup 的 C++ 风格和技术常见问题解答

---

我个人更喜欢：

int const* pi;
int* const pi;

因为 const 标识左侧标记，该标记应为常量。

当你使用这样的东西时，你肯定会保持相同的一致性：

int const* const pi;

而不是不一致地写：

const int* const pi;

如果你有一个指向指针的指针等等，会发生什么：

int const* const* const pi;

而不是：

const int* const* const pi;

Answer 4

我参加了一次会议，Bjarne Stroustrup 正在做演讲，他使用了类似 const int* i 的东西。 有人问他为什么用这种风格，他回答（释义）：

“当某些东西是常量时，人们喜欢首先看到 const。”

Answer 5

人们通常使用 const int* blah ，因为它读起来很好英语。 我不会低估它的用处。

我发现 int* const blah 变体非常罕见，因此向后进行更常见的定义通常没有用处。 一般来说，我不喜欢任何在一般情况下稍微模糊代码的东西，尽管它可能在特殊情况下提供一些名义上的好处。

另请参见“if (1 == a)”。 有些人真的很喜欢编写读起来不像英语的代码。 我不是那些人中的一个。

但实际上，const 背后的规则很简单。 向左看，然后向右看。 如此简单，我认为在风格指南中不值得太多关注。

Answer 6

如果只是变量和指向它们的指针可以是 const 或不是 const，那么可能就没有那么重要了。 但请考虑一下：

class MyClass
{
    public:
        int foo() const;
};

除了尾随它所引用的函数之外，const 不可能写在其他任何地方。

风格指南越短，开发人员就越有可能遵循它。 可能的最短规则，以及为您提供一致性的唯一规则是：

const 关键字始终尾随 无论它指的是什么。

所以，我会为你的同事说 0:3。

关于你的“最终问题”：为了风格指南的缘故，指南是否“劝阻”或“禁止”它公开反对的事物并不重要。 这是一个社会问题，一个政策。 风格指南本身应该尽可能简洁。 冗长的风格指南只会被每个人忽视（除了管理人员寻找应受指责的人），因此只需写“做”或“不做”，并在其他地方（例如在公司政策中）说明您对违反指南的行为同行评审的进行方式）。

Answer 7

虽然 const int 和 int const 之间没有任何有意义的区别（并且我已经看到这两种样式都在使用），但 const int *< 之间存在差异/code> 和 int * const。

在第一个中，您有一个指向 const int 的指针。 您可以更改指针，但无法更改它指向的值。 在第二个中，你有一个指向 int 的 const 指针。 您无法更改指针（希望它已根据您的喜好进行初始化），但您可以更改所指向的 int 的值。

正确的比较是与 const int * 和 int const * 进行比较，它们都是指向 const int 的指针。

请记住，* 不一定按您希望的方式工作。 声明 int x, y; 将按照您的预期工作，但 int* x, y; 声明一个指向 int 的指针和一个 int。

Answer 8

一旦您训练自己从右向左阅读 C++ 类型声明，将“const”放在类型声明之后就变得更有意义。

我要把你的牛人定为 0 换 3 :)

Answer 9

就我个人而言（这是个人偏好），我发现从右到左阅读类型声明是最简单的。 尤其是当你开始将参考文献混入其中时。

std::string const&  name = plop; // reference to const string.

const std::string&  flame =plop; // reference to string const;
                                 // That works better if you are German I suppose :-)

Answer 10

这里的最终问题是，他认为将 const 放在 int 后面是难以形容的丑陋，并且对可读性非常有害，因此应该在样式指南中禁止它

真的吗？

向我展示一个在看到以下内容时陷入困境的程序员：

int foo() {
}

vs

int foo()
{
}

...，我将向你展示一个对细节不够关注的程序员。

任何称职的专业程序员都不会因为风格上的表面差异而烦恼。

编辑：确实 const int* 和 int* const 并不意味着完全相同的事情，但这不是重点。 OP 同事提出的观点是，风格的差异使得代码难以理解和理解。 维持。 我不同意这种说法。

Answer 11

让我把我的 2 美分投入到讨论中。

在现代 C++ 中，我建议坚持使用 int const 而不是 const int 以突出 const 和 constexpr 之间的区别代码>. 这将帮助程序员记住 const int 不能总是被认为是编译时常量，因为：

• 编译器可能（会？）为它分配内存，
• 该内存甚至可能不是写保护的（堆栈段），
• 这样的常量无法履行constexpr 可以履行的所有职责。

Answer 12

规则是很好遵守的。 规则越简单越好。
Const 位于 const 的右侧。

采取这个声明：

int
主要的
( int 常量 argc
, char const * const * const argv
）
...

Answer 13

我同意你们俩的观点。 您应该将 cons 放在类型后面。 我还发现看着它是一种必须被摧毁的可憎行为。 但我最近对 ​​常量值参数 的奇迹的尝试让我明白了为什么要把const 第二个有意义。

int *
int const *
int * const
int const * const

光是看着就让我脖子上的汗毛都竖起来了。 我确信这会让我的同事感到困惑。

编辑：我只是想知道如何在类中使用它：

class Foo {
    Bar* const bar;
    Foo(const Foo&) = delete; // would cause too many headaches
public:
    Foo() : bar(new Bar) {}
    ~Foo() { delete bar; }
};

此示例中的 bar 在功能上等同于 Bar& 但它位于堆上并且可以删除。 在每个 Foo 的生命周期中，都会有一个与其关联的 Bar。

Answer 14

我喜欢使用以下形式声明“清单常量”。 在本例中，值本身是一个常量，因此我将“const”放在前面（与 Bjarne 相同）以强调这一点常量应该在编译时显现出来，并且可用于编译器的特定优化。

const int i = 123;

为了声明不会用于修改值的引用，我使用以下形式，强调标识符是“常量引用”这一事实。 参考值可以是也可以不是常数。 [相关讨论：如果函数参数不是指针或引用，您还会使用“const”吗？ 使用“const”作为函数参数]

void fn( int const & i );

对于指针，我使用相同的我用于引用的形式，本质上是出于相同的原因（尽管术语“常量指针”似乎比“常量引用”更加模糊）。

void fn( int const * i );

此外，正如另一位发帖者指出的那样，当您具有多个间接级别时，这种形式保持一致。

void fn( int const * const * i );

最后一种情况，即声明一个常量指针，在我的 C++ 经验中很少见。 无论如何，你在这里真的没有任何选择。 [此案例表明，最一致的方法是将单词“const”放在类型之后 - 因为事实上，这是此特定声明的必需。 ]

void fn( int * const i );

...除非你使用 typedef。

typedef int * IntPtr;

void fn1( const IntPtr i );
void fn2( IntPtr const i );

最后一点：除非您在低级域中工作，否则大多数 C++ 代码应该永远不要声明指针。 因此，这个讨论的这个方面可能与 C 更相关。

Answer 15

在现代 C++11 中，您还可以使用模板 typedef 来增加复杂声明的清晰度：

template<typename T>
using Const = const T;

template<typename T>
using Ptr = T*;

您在问题中提到的三个声明：

int const * a;
int * const b;
int * const * c;

然后将写为：

Ptr<Const<int>> a;
Const<Ptr<int>> b;
Ptr<Const<Ptr<int>>> c;