C'è qualche ragione per usare questo->

Question

Ho programmato in C++ per molti anni e ho ancora dei dubbi su una cosa. In molti luoghi in altro codice persone che vedo qualcosa di simile:

void Classx::memberfunction() 
{ 
    this->doSomething(); 
} 

Se ho bisogno di importare/utilizzare quel codice, ho semplicemente rimuovere la parte this->, e non ho mai visto niente di rotto o avere qualche effetti collaterali.

void Classx::memberfunction() 
{ 
    doSomething(); 
} 

Quindi, si conosce qualche motivo per utilizzare tale costrutto?

EDIT: Si noti che sto parlando delle funzioni membro qui, non delle variabili. Capisco che possa essere usato quando vuoi fare una distinzione tra una variabile membro e un parametro di funzione.

EDIT: apparente duplicato: Are there any reasons not to use "this" ("Self", "Me", ...)?

Answer 1

Per garantire l'attivazione degli errori del compilatore se è presente una macro che potrebbe essere definita con lo stesso nome della funzione membro e non si è certi se è stata definita indefinitamente.

No scherzo, sono abbastanza sicuro che ho dovuto fare esattamente questo per quel motivo!

Answer 2

mi viene in mente la leggibilità come quando si utilizza ulteriore parentesi di fare chiarezza.

Answer 3

Non penso che faccia la differenza per il compilatore, ma scrivo sempre questo-> perché credo che renda il codice autodocumentante.

Answer 4

Penso che sia principalmente un aiuto per il lettore. Rende esplicito che ciò che viene chiamato è un metodo sull'oggetto e non una funzione ordinaria. Durante la lettura del codice, può essere utile sapere che la funzione chiamata può modificare i campi nell'oggetto corrente, ad esempio.

Answer 5

Se esiste un'altra variabile con lo stesso nome con lo stesso nome, questo-> rimuoverà l'ambiguità.

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

Inoltre, è chiaro che si sta facendo riferimento a una variabile/funzione membro.

Answer 6

Disambiguazione: nel caso in cui si disponga di un'altra funzione/variabile di denominazione simile nello stesso spazio dei nomi? Non ho mai visto l'utilizzo per nessun altro motivo.

Answer 7

È la tua scelta. Trovo più chiaro quando lo usi. Ma se non ti piace, puoi ometterlo.

Answer 8

come "ragione codice", per distinguere un parametro o valore locale (che ha la precedenza) da un membro:

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

Tuttavia, questo è male practive per cominciare, e di solito possono essere risolti.

Il secondo motivo è più "ambiente": a volte aiuta Intellisense a filtrare quello che sto cercando. Comunque, anche io quando lo uso per trovare il membro che sto cercando, dovrei anche rimuoverlo.

Quindi sì, ci sono buone ragioni, ma sono tutte temporanee (e cattive a lungo termine).

Answer 9

Questa è davvero una questione di stile e si applica a molti altri linguaggi come Java e C#. Alcune persone preferiscono vedere l'esplicito this (o o Me o altro) e altri no. Vai con quello che è nelle tue linee guida di stile, e se è il tuo progetto, devi decidere le linee guida.

Answer 10

Lo preferisco senza l'esplicito questo puntatore. Per le chiamate al metodo non aggiunge molto valore, ma aiuta a distinguere le variabili locali dalle variabili membro.

Answer 11

Questo è stato chiesto un paio di volte, ma è difficile cercarlo perché "questo" sembra essere una parola d'ordine per la ricerca.

Ecco la mia domanda: Are there any reasons not to use "this" ("Self", "Me", ...)?

Answer 12

Questo viene fatto per essere espliciti circa il fatto che la variabile utilizzata è una variabile membro al contrario di una variabile locale o globale. Nella maggior parte dei casi non è necessario, ma essere espliciti riguardo all'ambito può essere utile se hai superato la variabile con una dichiarazione con lo stesso nome in un ambito più stretto.

Alle aziende in cui ho lavorato, abbiamo anteposto "m_" alle variabili membro. A volte può essere utile, e preferisco di gran lunga usare "questo->".

Modifica: Aggiunta di un collegamento a the GCC docs, che spiega un caso in cui l'utilizzo di questo -> è necessario per ottenere una ricerca non dipendente per funzionare correttamente.

Answer 13

L'unico posto dove veramente fa la differenza è nei modelli nelle classi derivate:

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

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

causa details in the name lookup in C++ compilers, deve essere fatto esplicitamente chiarito che x è una (ereditata) membro della classe, fatto più facilmente con this->x. Ma questo è un caso piuttosto esoterico, se non si dispone di gerarchie di classi basate su modelli, non è necessario utilizzare esplicitamente this per accedere ai membri di una classe.

Answer 14

Non riesco a ricordare le circostanze esatte, ma ho visto casi (molto rari) in cui ho dovuto scrivere "questo-> nomeutente" per compilare correttamente il codice con GCC. Tutto ciò che ricordo è che non era in relazione all'ambiguità e quindi mi ci è voluto un po 'per capire la soluzione. Lo stesso codice compilato bene senza usare questo-> in Visual Studio.

Answer 15

Lo userò per chiamare implicitamente gli operatori (i tipi di restituzione e di parametri sottostanti sono solo dei maniaci per la creazione del codice).

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

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

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

Mi piace la sintassi *this di più. Ha una semantica leggermente diversa, in quanto l'uso di *this non nasconderà le funzioni dell'operatore non membro con lo stesso nome di un membro, però.

Answer 16

Ci sono molte buone risposte, ma nessuno di loro menziona che l'uso di questo-> nel codice sorgente rende più facile leggere, specialmente quando si legge un codice di qualche funzione lunga, ma anche una funzione breve, immagina un codice :

bool Class::Foo() 
{ 
    return SomeValue; 
} 

dall'osservazione di questo codice, non è possibile sapere chiaramente cos'è SomeValue.Potrebbe essere anche un po '# define o variabile statica, ma se si scrive

bool Class::Foo() 
{ 
    return this->SomeValue; 
} 

si sa chiaramente che SomeValue è una variabile membro non statica della stessa classe.

Quindi non ti aiuta solo a garantire che il nome delle tue funzioni o variabili non sia in conflitto con altri nomi, ma rende anche più facile per gli altri leggere e capire il codice sorgente, scrivendo un auto-documentare il codice sorgente è talvolta molto importante.

Answer 17

Un altro caso, che è arrivato sulle scene dopo C++ 11 è in lambda in cui viene catturato this.

Potrebbe essere qualcosa di simile:

class Example 
{ 
    int x; 
public: 
    std::function<void()> getIncrementor() 
    { 
    return [this]() -> void 
    { 
     ++(this->x); 
    } 
    } 
}; 

Anche se il lambda viene generato all'interno di una classe, si avrà accesso solo alle variabili locali da loro cattura (se il compilatore C++ fa 14) o catturare this . Nel secondo caso, all'interno del corpo di lambda, semplicemente non c'è x, ma solo this->x.