Как система знает, что использовать, когда используется это ключевое слово?

Question

Как система знает, что использовать, когда используется это ключевое слово?

В последнее время мне задали этот вопрос в интервью. Никогда не задумываясь об этом, я ответил, сказав, что система будет знать текущий контекст, в котором поток управления и решить, что объект будет использоваться вместо этого. Интервьюер не выглядел довольным, и он перешел к следующему вопросу.

Может ли кто-нибудь сказать мне, что интервьюер, возможно, хотел спросить и что было бы ответом? (я думаю, что это может интерпретироваться по-разному и, следовательно, сохранить это как wiki, если кто-то не укажет на то, что не ..)

Answer 1

this ключевое слово является указателем на текущий объект. Все нестатические функции-члены класса имеют доступ к этому указателю.

Указатель на текущий объект обычно предоставляется компилятором в нестатической функции-члене, используя регистр, обычно ECX. Поэтому, когда вы пишете this в нестатической функции-члене, компилятор переведет этот вызов на загрузку адреса из ECX.

Проверить этот простой пример:

 
A t; 
t.Test(); 
004114DE lea   ecx,[t] 
004114E1 call  std::operator > (41125Dh) 

Перед вызова функции-члена нестатического Test() компилятор загружает регистр ECX с [T] (адресом переменного т - будет this внутри метода испытаний).

 
004114DE lea   ecx,[t] 

И внутри функции он может использовать ecx для получения адреса для экземпляра текущего объекта.

Answer 2

this является скрытым параметром во всех методах объекта и содержит копию указателя экземпляра.

Answer 3

Во время выполнения «это» будет разрешено указатель на текущий объект, поэтому «система» сможет вызвать соответствующий метод для этого объекта.

Answer 4

c c Этот указатель является аргументом невидимого указателя для вашего класса.

Таким образом, по существу первым аргументом метода класса является указатель на сам класс. Вы ссылаетесь на него, используя это.

Answer 5

Я бы ответил «Это ссылка на экземпляр текущего класса».

Dan

Answer 6

Рассмотрим этот класс

class A { 
private: 
    int data; 
public: 
    void SetData(int arg) { 
     this->data = arg; 
    } 
} 

и это код, который вызывает SetData():

A objA; 
objA.SetData(1); 

Когда приведенный выше код компилируется, компилятор выдает что-то эквивалентное этому для функции члена:

void SetData(A* this, int arg) { 
    this->data = arg; 
} 

И код вызова преобразуется в примерно так:

A objA; 
SetData(&objA, 1); 

Что это означает, что при компиляции:

1. Функции-члены преобразуются в простые, глобальные функции.

2. Экземпляр класса, к которому принадлежат функции-члены, просто передается им в качестве первого аргумента (или, скорее, его адрес передается).

В заключение, то, что вы называете этим указателем в коде, просто заканчивается тем, что является первым аргументом функции. Это то, как «система знает», которые хотят получить доступ через «этот» указатель.

Приведенный выше пример C++. Если вы на мгновение забыли о CLR и JITting, и все, что происходит на C#, концептуально то же самое.

Answer 7

Shematicaly компилятор преобразует такой код:

pObject->someMethod(A,B,C) 

В таком коде, если 'SomeMethod' не является виртуальным:

someMethod(pObject,A,B,C) 

Или в такой код, если 'SomeMethod' виртуальна:

(*pObject->vtable[someMethodIndex]) (pObject, A,B,C) 

И везде, где вы помещаете ключевое слово 'this', вместо него используется первый параметр;

Конечно, компилятор может оптимизировать/упростить, удалив первый аргумент и используя некоторый регистр ЦП (обычно esx), чтобы сохранить адрес объекта.

Answer 8

Компилятор правильно решает эту ссылку во время компиляции. Если вы хотите узнать более подробную информацию о некоторых из методов, которые они используют, чтобы сделать это, эта книга расскажет вам все, что вам нужно знать:
http://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools

Answer 9

Мой ответ был бы: «Кто заботится Он знает Если мне когда-нибудь понадобится узнать более подробно, я сделаю это Google ».

Вы, очевидно, знаете, какой эффект от использования «этого» будет, что, безусловно, является важной вещью. Для 99% задач программирования я бы подумал, что детали того, как это разрешено внутренне, являются пустяками.

Answer 10

Оператор «Этот» указывает на текущий объект.Пример, в котором наличие «этого» оператора будет делать различие заключается в следующем:

public class MyClass 
{ 
    int value; 
    public void Test(int value) 
    { 
     MessageBox.Show(value); // Will show the parameter to the function 
     MessageBox.Show(this.value); // Will show the field in the object 
    } 
} 

Обратите внимание, что «этот» оператор не изменит то, что виртуальная функция будет вызываться, если он переопределен в дочернем классе

public class MyClass 
{ 
    public virtual void Test() {} 
    public void CallTest() 
    { 
     this.Test(); 
    } 
} 
public class MyClass2 : MyClass 
{ 
    public override void Test() {} 
} 

Если выполнить следующий код

MyClass c = new MyClass2(); 
c.CallTest(); 

еще будет вызывать MyClass2.Test() и не MyClass.Test()

Итак, оператор «this» просто сообщает вам, что вы обращаетесь к чему-то, объявленному на уровне класса.

Answer 11

Хотя ответы, указывающие на то, что «эта» ссылка, по существу, передана в качестве магического «скрытого параметра» для вызова, по существу правильны, полная история на самом деле довольно сложна в C#, чем можно было бы подумать Первый взгляд.

Ссылочные типы просты; ссылочный объект проверяется на нуль, а затем концептуально передается как неназванный, непеременный параметр под названием «this». История сложна по типам значений.

Помните, что типы значений по определению передаются по значению, т.е. передаются путем создания копии данных. Отсюда их имя. Но явно изменяемые типы значений, которые являются чистым злом, и их следует избегать, не могут быть переданы по значению как «это», потому что, если вы вызвали мутатор, «это» в методе мутатора будет мутировать копию, а не оригинал!

Поэтому в вызове метода типа значения, в «этом» не значения приемника, это псевдоним переменного, представляющее место хранения приемника. Мы реализуем это, передавая «это» как управляемый адрес приемника, а не значение получателя.

Теперь мы можем поднять еще одну трудность. Что делать, если переменная, сохраняющая измененное значение, является переменной только для чтения? Теперь, что мы делаем? Если вам интересно, читайте мою статью на эту тему и посмотреть, если вы можете правильно ответить на загадку представлены:

http://blogs.msdn.com/ericlippert/archive/2008/05/14/mutating-readonly-structs.aspx