blocks|key|1763876|text|您不需要像这样使用this：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1763877|class+A+{
++++int+i;
++++char+c;
public:
++++A(int+i+=+0,+char+c+=+'+')+:+i(i),+c(c)+{}+//+syntax+makes+this+good
};|code-block|syntax|javascript|1763878|这完全没问题，并且完全按照你想要的方式工作。|1763879|语法规则意味着参数不能作为被初始化的变量出现，只能作为它的参数出现。因此，编译器必须将括号i()之外的变量解析为类成员，而将括号(i)内的变量从参数中解析出来，因为由于作用域规则的原因，它们隐藏了成员变量。|1763880|A(int+i+=+0):+i(i)+{}
++++++++++++++%5E+++++++-+syntax+says+that+i+must+be+a+member+

A(int+i+=+0):+i(i)+{}
++++++++++++++++%5E+++++-+syntax+says+normal+scoping+rules+apply|1763881|在括号之外，它必须是一个类成员，但在括号内，作用域规则类似于构造函数体-参数隐藏了成员变量。|1763882|因此，使用该模式将参数命名为与数据成员相同的名称是非常安全的。|1763883|entityMap^0|9|4|0|0|0|19|3|1S|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|17|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|18|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|V|$]]

You don't need to use <code>this</code> like that:

<pre><code>class A {
 int i;
 char c;
public:
 A(int i = 0, char c = ' ') : i(i), c(c) {} // syntax makes this good
};
</code></pre>

That is totally fine and works exactly how you want it to work.

The syntax rules mean that parameters can not appear as the variable being initialized, only its parameter. So the compiler must resolve the variables outside the parens <code>i()</code> as the class member and the one inside the parens <code>(i)</code> from the parameters because they hide the member variables due to scoping rules.

<pre><code>A(int i = 0): i(i) {}
 ^ - syntax says that i must be a member 

A(int i = 0): i(i) {}
 ^ - syntax says normal scoping rules apply
</code></pre>

Outside the parens it must be a class member but inside the parens the scoping rules are like in the constructor body - the parameters hide the member variables.

So it is a perfectly safe pattern to use to name your parameters the same as your data members.

blocks|key|4081155|text|如果查看overview+of+the+C%2B%2B+grammar，特别是mem-initializer-list部分，您会看到初始化器列表应该由identifier(expression)或classname(expression)条目组成。identifier被定义为数字和非数字(a-z，A-Z，_)组成的字符串。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4081156|您的this->identifier(expression)与此不匹配，因此不允许使用。无论如何，这是没有必要的，因为这里没有歧义。identifier始终是类的成员变量，因此很清楚引用哪个i。|4081157|class+A+{
++++int+i;
++++char+c;
public:
++++A(int+i+=+0,+char+c+=+'+')+:+i(i),+c(c)+{}
};|code-block|syntax|javascript|4081158|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/en-us/library/aa903594(v=vs.71).aspx)^0|Z|K|1Z|M|2M|L|3C|A|4|R|0|0|2|S|1U|A|2N|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1D|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

If you look at an <a href="https://msdn.microsoft.com/en-us/library/aa903594(v=vs.71).aspx" rel="nofollow">overview of the C++ grammar</a>, specifically the <code>mem-initializer-list</code> section, you see that the initializer list should consist of <code>identifier(expression)</code> or <code>classname(expression)</code> entries. An <code>identifier</code> is defined <a href="https://msdn.microsoft.com/en-us/library/aa903592(v=vs.71).aspx" rel="nofollow">here</a> as string of digits and nondigits (a-z, A-Z, _).

Your <code>this-&gt;identifier(expression)</code> doesn't match that, so it's not allowed. It's not necessary anyway, because there is no ambiguity here. The <code>identifier</code> is always a member variable of the class, so it's clear which <code>i</code> is referred to.

<pre><code>class A {
 int i;
 char c;
public:
 A(int i = 0, char c = ' ') : i(i), c(c) {}
};
</code></pre>

blocks|key|4081171|text|您不需要在初始化器列表中使用this关键字，因为初始化器列表中的任何内容都必须在类中声明。当你这样做的时候|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4081172|class+MyClass
{
++++int+member;
public:
++++MyClass(int+member)+:+member(member)+{+}
++++++++++++++++++++++++++%5E%5E%5E%5E%5E+Can+only+be+resolved+to+a+member+of+MyClass
}|code-block|syntax|javascript|4081173|不允许初始值设定项列表中的member引用类中除int+member以外的任何内容。因此，如果编译器必须在初始化器列表中同时支持member(member)和this->member(member)，则this关键字是不必要的，并且会增加额外的解析难度。同时给人一种可以同时初始化初始化器列表内的非成员变量的印象。|4081174|entityMap^0|E|4|0|0|D|6|O|A|1S|E|27|K|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$]]

You don't need the <code>this</code> keyword in the initializer list as anything in the initializer list must be declared within the class. When you do

<pre><code>class MyClass
{
 int member;
public:
 MyClass(int member) : member(member) { }
 ^^^^^ Can only be resolved to a member of MyClass
}
</code></pre>

<code>member</code> in the initializer list is not permitted to refer to anything other than <code>int member</code> within the class. Therefore the this keyword is unnecessary and would add additional parsing difficulties if compilers had to support both <code>member(member)</code> and <code>this-&gt;member(member)</code> within initializer list. While giving the impression that it is possible to initialize non-member variables within the initializer list at the same time.

blocks|key|1479150|text|这是因为this指针需要位于以下其中一项中：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1479151|cppreference|1479152|1479153|它可以出现在以下上下文中：|blockquote|1479154|1479155|1)在任何非静态成员函数体中，包括成员初始值设定项列表|1479156|2)在非静态成员函数的声明中，在(可选)cv限定符序列之后的任何位置，包括动态异常规范(已弃用)、noexcept规范(+C%2B%2B11)和尾随返回类型(自C%2B%2B11以来)|1479157|3)在非静态数据成员的括号或相等初始值设定项内(从C%2B%2B11开始)|1479158|class+Foo+{
++++int+a[sizeof(*this)];+//+error,+not+inside+a+member+function
};|code-block|syntax|javascript|1479159|类似地：|1479160|class+A+{
++++int+i+=+sizeof(*this);+//+valid+-+brace-or-equal+initializer
++++char+c;
public:
++++//+Error,+not+inside+member+function.
++++A(int+i+=+0,+char+c+=+'+')+:+this->i(i),+this->c(c)+//+invalid
++++{}
};|1479161|当把它放在构造函数的主体中时，它会起作用：|1479162|A(int+i+=+0,+char+c+=+'+')
{
++++this->c+=+c;+//+'this->'+required+for+disambiguation
++++this->i+=+i;
}

A(int+i+=+0,+char+c+=+'+')+:+i(sizeof(*this))+//+also+valid
{}|1479163|通常不需要显式地使用this->。|1479164|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/language/this^0|4|4|0|0|C|0|0|0|0|0|0|0|0|0|0|0|0|0|A|6|0^^$0|@$1|2|3|4|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1I|8|@]|D|@$9|1J|A|1K|1|1L]]|E|$]]|$1|H|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|1N|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1P|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1R|8|@]|D|@]|E|$]]|$1|S|3|T|5|U|7|1S|8|@]|D|@]|E|$V|W]]|$1|X|3|Y|5|6|7|1T|8|@]|D|@]|E|$]]|$1|Z|3|10|5|U|7|1U|8|@]|D|@]|E|$V|W]]|$1|11|3|12|5|6|7|1V|8|@]|D|@]|E|$]]|$1|13|3|14|5|U|7|1W|8|@]|D|@]|E|$V|W]]|$1|15|3|16|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|17|3|-4|5|6|7|20|8|@]|D|@]|E|$]]]|18|$19|$5|1A|1B|1C|E|$1D|1E]]]]

It is because the <code>this</code> pointer needs to be inside one of the following:

<a href="http://en.cppreference.com/w/cpp/language/this" rel="nofollow">cppreference</a>:

<blockquote>
 It can appear in the following contexts: 
 1) Within the body of any non-static member function, including member
 initializer list 
 2) within the declaration of a non-static member
 function anywhere after the (optional) cv-qualifier sequence,
 including dynamic exception specification(deprecated), noexcept
 specification(C++11), and the trailing return type(since C++11) 
 3)
 within brace-or-equal initializer of a non-static data member (since
 C++11) 
</blockquote>

<pre><code>class Foo {
 int a[sizeof(*this)]; // error, not inside a member function
};
</code></pre>

Similarly:

<pre><code>class A {
 int i = sizeof(*this); // valid - brace-or-equal initializer
 char c;
public:
 // Error, not inside member function.
 A(int i = 0, char c = ' ') : this-&gt;i(i), this-&gt;c(c) // invalid
 {}
};
</code></pre>

When put inside of the body of the constructor, it will work:

<pre><code>A(int i = 0, char c = ' ')
{
 this-&gt;c = c; // 'this-&gt;' required for disambiguation
 this-&gt;i = i;
}

A(int i = 0, char c = ' ') : i(sizeof(*this)) // also valid
{}
</code></pre>

It is often not necessary to use <code>this-&gt;</code> explicitly.

I mean, we can't do:

<pre><code>class A {
 int i;
 char c;
public:
 A(int i = 0, char c = ' ') : this-&gt;i(i), this-&gt;c(c) {}
};
</code></pre>

Is it because the instance hasn't been created yet or something like that?

Why can't the 'this' pointer be used in the constructor initializer list?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我是说，我们不能这样做：class A {    int i;    char c;public:    A(int i = 0, char c = ' ') : this->i(i), this->c(c) {}};是因为实例还没有创建，还是类似的原因？

问为什么不能在构造函数初始化器列表中使用'this‘指针？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么不能在构造函数初始化器列表中使用'this‘指针？EN