我很好奇其他人如何使用this关键字。 我倾向于在构造函数中使用它,但我也可能在整个类中的其他方法中使用它。 一些例子:

在构造函数中:

public Light(Vector v)
{
    this.dir = new Vector(v);
}

别处

public void SomeMethod()
{
    Vector vec = new Vector();
    double d = (vec * vec) - (this.radius * this.radius);
}

===============>>#1 票数:245

我并不是说这听起来很尖刻,但这并不重要。

严重地。

看看重要的事情:你的项目、你的代码、你的工作、你的个人生活。 他们的成功都不会取决于您是否使用“this”关键字来限定对字段的访问。 this 关键字不会帮助您按时发货。 它不会减少错误,也不会对代码质量或可维护性产生任何明显影响。 它不会让你加薪,也不会让你在办公室花更少的时间。

这真的只是一个风格问题。 如果你喜欢“这个”,那就用它。 如果你不这样做,那就不要。 如果您需要它来获得正确的语义,请使用它。 事实是,每个程序员都有自己独特的编程风格。 这种风格反映了特定程序员对“最美观的代码”应该是什么样子的看法。 根据定义,任何其他阅读您代码的程序员都会有不同的编程风格。 这意味着总会有其他人不喜欢你做的事情,或者会做不同的事情。 在某些时候,有人会阅读您的代码并对某些事情发牢骚。

我不会为此烦恼。 我只会根据您自己的口味确保代码尽可能美观。 如果你问 10 位程序员如何格式化代码,你会得到大约 15 种不同的意见。 更值得关注的是代码是如何分解的。 抽象的东西对吗? 我是否为事物选择了有意义的名称? 是否有很多代码重复? 有什么方法可以简化东西吗? 我认为,把这些事情做好,会对你的项目、代码、工作和生活产生最大的积极影响。 巧合的是,这也可能会让对方最不抱怨。 如果您的代码有效、易于阅读并且经过精心设计,那么其他人就不会仔细检查您如何初始化字段。 他只是会使用你的代码,惊叹它的伟大,然后继续做其他事情。

===============>>#2 票数:217 已采纳

这个关键字在 C# 中有几种用法。

  1. 限定被相似名称隐藏的成员
  2. 让对象将自身作为参数传递给其他方法
  3. 让对象从方法返回自身
  4. 声明索引器
  5. 声明扩展方法
  6. 在构造函数之间传递参数
  7. 在内部重新分配值类型(结构) value
  8. 在当前实例上调用扩展方法
  9. 将自身强制转换为另一种类型
  10. 链接在同一类中定义的构造函数

您可以通过不在作用域中使用同名的成员变量和局部变量来避免第一次使用,例如通过遵循常见的命名约定并使用属性(Pascal case)而不是字段(camel case)来避免与局部变量(也是camel案件)。 在 C# 3.0 中,字段可以通过使用自动实现的属性轻松转换为属性

===============>>#3 票数:96

我只在绝对必要时使用它,即当另一个变量遮蔽另一个变量时。 比如这里:

class Vector3
{
    float x;
    float y;
    float z;

    public Vector3(float x, float y, float z)
    {
        this.x = x;
        this.y = y;
        this.z = z;
    }

}

或者正如 Ryan Fox 指出的那样,当您需要将其作为参数传递时。 (局部变量优先于成员变量)

===============>>#4 票数:54

就个人而言,我尝试在引用成员变量时始终使用this 它有助于澄清代码并使其更具可读性。 即使有通过我的第一次不知道代码没有歧义,有人读书,但如果他们看到这种一贯使用的,他们知道,如果他们正在寻找一个成员变量或没有。

===============>>#5 票数:38

我每次引用实例变量时都会使用它,即使我不需要。 我认为它使代码更清晰。

===============>>#6 票数:36

我无法相信所有说使用它总是“最佳实践”等的人。

当有歧义时使用“this”,如Corey 的示例,或者当您需要将对象作为参数传递时,如Ryan 的示例 没有理由以其他方式使用它,因为能够根据作用域链解析变量应该足够清楚,不需要用它来限定变量。

编辑:关于“this”的 C# 文档表明除了我提到的两个之外,还有一个用途,用于“this”关键字 -用于声明索引器

编辑:@Juan:嗯,我的陈述中没有任何不一致之处 - 有 3 次我会使用“this”关键字(如 C# 文档中所述),而那些是您实际需要它的时候。 在没有阴影的情况下,将“this”放在构造函数中的变量前面只是浪费击键和阅读它的时间,它没有任何好处。

===============>>#7 票数:27

只要StyleCop告诉我,我就会使用它。 必须遵守StyleCop 哦是的。

===============>>#8 票数:11

任何时候您需要对当前对象的引用。

一个特别方便的场景是当您的对象正在调用一个函数并希望将自身传递给它时。

例子:

void onChange()
{
    screen.draw(this);
}

===============>>#9 票数:7

我也倾向于在任何地方使用它,只是为了确保我们正在处理的是实例成员。

===============>>#10 票数:5

this 关键字的另一个很少使用的用途是当您需要从实现类中调用显式接口实现时。 这是一个人为的例子:

class Example : ICloneable
{
    private void CallClone()
    {
        object clone = ((ICloneable)this).Clone();
    }

    object ICloneable.Clone()
    {
        throw new NotImplementedException();
    }
}

===============>>#11 票数:5

我在任何可能存在歧义的地方使用它(显然)。 不仅仅是编译器的歧义(在那种情况下是必需的),还有查看代码的人的歧义。

===============>>#12 票数:4

这是我使用它的时候:

  • 从类中访问私有方法(以区分)
  • 将当前对象传递给另一个方法(或作为发送者对象,以防万一)
  • 创建扩展方法时:D

我不将它用于私有字段,因为我用下划线 (_) 作为私有字段变量名称的前缀。

===============>>#13 票数:4

[C++]

我同意“必要时使用它”旅。 不必要地装饰代码并不是一个好主意,因为当您忘记这样做时,编译器不会警告您。 这给期望始终存在的人们带来了潜在的混乱,即他们必须考虑它。

那么,你会在什么时候使用它? 我刚刚查看了一些随机代码并找到了这些示例(我不会判断这些是否是好事):

  • 将“你自己”传递给一个函数。
  • 将“你自己”分配给一个指针或类似的东西。
  • 铸造,即向上/向下铸造(安全或其他),抛弃常量等。
  • 编译器强制消歧。

===============>>#14 票数:3

在 Jakub Šturc 的回答中,他关于在构造函数之间传递数据的 #5 可能需要一些解释。 这是在重载构造函数中,并且是强制使用this的一种情况。 在下面的示例中,我们可以使用默认参数从无参数构造函数调用参数化构造函数。

class MyClass {
    private int _x
    public MyClass() : this(5) {}
    public MyClass(int v) { _x = v;}
}

我发现这有时是一个特别有用的功能。

===============>>#15 票数:3

你应该总是使用它,我用它来区分私有字段和参数(因为我们的命名约定声明我们不使用成员和参数名称的前缀(并且它们基于在 Internet 上找到的信息,所以我认为最佳实践))

===============>>#16 票数:3

当我在接受对同一类型对象的引用的函数中使用它时,我想完全清楚我指的是哪个对象,在哪里。

例如

class AABB
{
  // ... members
  bool intersects( AABB other )
  {
    return other.left() < this->right() &&
           this->left() < other.right() &&

           // +y increases going down
           other.top() < this->bottom() &&
           this->top() < other.bottom() ;
  }
} ;

(对比)

class AABB
{
  bool intersects( AABB other )
  {
    return other.left() < right() &&
           left() < other.right() &&

           // +y increases going down
           other.top() < bottom() &&
           top() < other.bottom() ;
  }
} ;

一目了然 AABB right()指的是哪个? this增加了一些澄清剂。

===============>>#17 票数:2

我养成了在 Visual C++ 中大量使用它的习惯,因为这样做会触发 IntelliSense,我按了“>”键,而且我很懒。 (并且容易出现错别字)

但是我继续使用它,因为我发现我调用的是成员函数而不是全局函数很方便。

===============>>#18 票数:1

this在 C++ 编译器上

如果 C++ 编译器没有立即找到它,它将默默地查找符号。 有时,大多数时候,这很好:

  • 如果您没有在子类中重载它,则使用母类的方法。
  • 将一种类型的值提升为另一种类型

但有时,您只是不想让编译器猜测。 您希望编译器选择正确的符号而不是另一个。

对我来说,那些时候是在一个方法中,我想访问一个成员方法或成员变量。 我只是不想因为我写了printf而不是print就接收到一些随机符号。 this->printf不会编译。

关键是,使用 C 遗留库 (§)、多年前编写的遗留代码 (§§) 或任何可能发生在复制/粘贴已过时但仍处于活动状态的语言中,有时会告诉编译器不要播放智慧是个好主意。

这些是我使用this的原因。

(§) 这对我来说仍然是一种谜,但我现在想知道您在源代码中包含 <windows.h> 标头的事实是否是所有遗留 C 库符号都会污染您的全局命名空间的原因

(§§) 意识到“你需要包含一个标题,但包含这个标题会破坏你的代码,因为它使用了一些具有通用名称的愚蠢宏”是编码员生活中的俄罗斯轮盘赌时刻之一

===============>>#19 票数:1

我倾向于用 _ 在字段下划线,所以真的不需要使用它。 无论如何,R# 也倾向于重构它们......

===============>>#20 票数:1

我几乎只在从同一类型内部引用类型属性时使用 正如另一位用户所提到的,我还强调了本地字段,因此它们在不需要this 的情况下也很明显。

===============>>#21 票数:1

我只在需要时使用它,除了由于单参数多态性而必须放入一侧方法的对称操作:

boolean sameValue (SomeNum other) {
   return this.importantValue == other.importantValue;
} 

===============>>#22 票数:1

'这。' 帮助在具有很多成员的“这个”类上找到成员(通常是由于一个深层的继承链)。

按 CTRL+Space 对此没有帮助,因为它还包括类型; where-as 'this.' 仅包括会员。

我通常会在得到我想要的东西后删除它:但这只是我的风格突破。

在风格方面,如果你是一个独行侠——你决定; 如果您为公司工作,请遵守公司政策(查看源代码管理中的内容并查看其他人在做什么)。 用它来限定会员,没有对也没有错。 唯一错误的是不一致——这是风格的黄金法则。 留下挑剔的其他人。 花时间思考真正的编码问题——显然是编码——。

===============>>#23 票数:1

[C++]

在赋值运算符中使用,大多数时候您必须检查和防止奇怪的(无意的、危险的或只是浪费程序时间)的事情,例如:

A a;
a = a;

您的赋值运算符将被写入:

A& A::operator=(const A& a) {
    if (this == &a) return *this;

    // we know both sides of the = operator are different, do something...

    return *this;
}

===============>>#24 票数:1

我每次都用它。 我相信它使代码更具可读性,更易读的代码意味着更少的错误和更高的可维护性。

===============>>#25 票数:1

当您有许多开发人员在同一个代码库上工作时,您需要一些代码指南/规则。 在我工作的地方,我们决定在字段、属性和事件上使用“this”。

对我来说,这样做很有意义,当您区分类变量和方法变量时,它使代码更易于阅读。

===============>>#26 票数:0

我用它来调用Intellisense就像JohnMcG一样,但是当我完成后我会回去擦除“this->”。 我遵循 Microsoft 的约定,即在成员变量前加上“m_”前缀,因此将其保留为文档是多余的。

===============>>#27 票数:0

1 - 常见的 Java setter 习惯用法:

 public void setFoo(int foo) {
     this.foo = foo;
 }

2 - 使用此对象作为参数调用函数时

notifier.addListener(this);

===============>>#28 票数:0

在 C++ 中还没有提到一种用途,那就是不引用自己的对象或从接收的变量中消除成员的歧义。

您可以使用this在从其他模板继承的模板类中将非依赖名称转换为参数依赖名称。

template <typename T>
struct base {
   void f() {}
};

template <typename T>
struct derived : public base<T>
{
   void test() {
      //f(); // [1] error
      base<T>::f(); // quite verbose if there is more than one argument, but valid
      this->f(); // f is now an argument dependent symbol
   }
}

模板是用两遍机制编译的。 在第一遍期间,仅解析和检查非参数依赖名称,而仅检查依赖名称的一致性,而不实际替换模板参数。

在这一步,没有实际替换类型,编译器几乎没有关于base<T>可能是什么的信息(注意基本模板的特化可以把它变成完全不同的类型,甚至是未定义的类型),所以它只是假设它是一种类型。 在这个阶段,对程序员来说似乎很自然的非依赖调用f是一个符号,编译器必须找到它作为derived名称空间或封闭名称空间的成员——这在示例中没有发生——并且它会抱怨。

解决方案是将非依赖名称f转换为依赖名称。 这可以通过几种方式完成,通过显式声明它实现的类型( base<T>::f --adding the base<T>使符号依赖于T并且编译器只会假设它会在参数替换后,存在并推迟第二遍的实际检查。

第二种方式,如果您从具有多个参数或长名称的模板继承,则更简单,只需在符号前添加一个this-> 由于您正在实现的模板类确实依赖于一个参数(它继承自base<T>this->依赖于参数,我们得到相同的结果: this->f在第二轮检查,在模板参数替换之后.

===============>>#29 票数:0

这取决于我正在使用的编码标准。 如果我们使用 _ 来表示一个实例变量,那么“this”就变得多余了。 如果我们不使用 _ 那么我倾向于使用它来表示实例变量。

===============>>#30 票数:-2

除非绝对必须,否则不应使用“this”。

有与不必要的冗长相关的惩罚。 您应该争取与需要的代码完全一样长,并且不再需要。

  ask by community wiki translate from so

未解决问题?本站智能推荐: