Есть ли любая причина использовать это->

Я не могу вполне помнить точные обстоятельства, но я видел (очень редкие) экземпляры, где я должен был записать "это-> membername" для успешной компиляции кода с GCC. Все, что я помню, - то, что это не было относительно неоднозначности и поэтому взяло меня некоторое время для выяснения решения. Тот же код скомпилированный штраф, не используя это-> в Visual Studio.

Я предпочитаю его без явного этот указатель также. Для вызовов метода это не добавляет много значения, но это помогает отличить локальные переменные от членских переменных.

Это - Ваш собственный выбор. Я нахожу это более ясным, когда Вы используете это. Но если Вам не нравится он, Вы можете ommit это.

Разрешение неоднозначности: в случае, если у Вас есть другая подобная функция/переменная именования в том же пространстве имен? Я никогда не видел использование ни по какой другой причине.

Я не думаю, что это имеет значение к компилятору, но я всегда пишу это->, потому что я полагаю, что это делает самодокументирование кода.

Это - действительно вопрос стиля и относится ко многим другим языкам, таким как Java и C#. Некоторые люди предпочитают видеть явное this (или self, или Me, или безотносительно), и другие не делают. Просто пойдите с тем, что находится в Ваших инструкциях по стилю, и если это - Ваш проект, Вы добираетесь для решения инструкций.

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

В компаниях я работал в, мы просто предварительно ожидали "m _" к членским переменным. Это может иногда быть полезно, и я очень предпочитаю его использованию "этого->".

Редактирование: Добавление ссылки к документы GCC , которые объясняют случай, где использование этого-> необходимо, чтобы заставить независимый поиск работать правильно.

Это спросили пару раз, но трудно искать его, потому что "это", кажется, стоп-слово для поиска.

Вот мой собственный вопрос: там любые причины не использовать " this" (" Self" " Me"...)?

Я думаю, что это главным образом как помощь читателю. Это делает это явным, что то, что называют, является методом на объекте и не обычной функцией. При чтении кода может быть полезно знать, что вызванная функция может изменить поля в текущем объекте, например.

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

Как "причина кода", для различения локального параметра или значения (который имеет приоритет) от участника:

class Foo
{
    int member;
    void SetMember(int member)
    {
       this->member = member;
    }
}

Однако это - плохой practive для начала и обычно может решаться локально.

второй причиной является больше "среды": это иногда помогает Intellisense отфильтровать то, что я действительно ищу. Однако я также вещь, когда я использую это для нахождения участника, которого я ищу, я должен также удалить это.

Так да, существуют серьезные основания, но они - весь временный файл (и плохо на длительном периоде).

Если будет другая переменная в том же объеме с тем же именем, то это-> удалит неоднозначность.

void Bar::setFoo(int foo)
{
    this->foo = foo;
}

Также это проясняет, что Вы обращаетесь к членской переменной / функция.

Единственное место, где это действительно имеет значение, находится в шаблонах в производных классах:

template<typename T>
class A {
protected:
  T x;
};

template<typename T>
class B : A<T> {
public:
  T get() {
    return this->x;
  }
};

из-за детали в поиске имени в компиляторах C++ , должно быть сделано явно ясным, что x (наследованный) член класса, наиболее легко сделанного с this->x. Но это - довольно тайный случай, если у Вас нет шаблонных иерархий классов, Вы не должны действительно явно использовать this для доступа к членам класса.

Я буду использовать его для неявного вызова операторов (возвращаемые типы и параметры ниже - это всего лишь пустышки для составления кода).

struct F {
  void operator[](int); 
  void operator()();

  void f() {
    (*this)[n];
    (*this)();
  }

  void g() {
    operator[](n);
    operator()();
  }
};

Мне больше нравится синтаксис * this . Он имеет немного другую семантику, поскольку использование * this не скроет, однако, не являющиеся членами операторные функции с тем же именем, что и член.