Questa macro può essere definita in qualche intestazione globale, o meglio come parametro della riga di comando del compilatore:
#define me (*this)
E alcuni esempi di utilizzo:
some_header.h:
inline void Update()
{
/* ... */
}
main.cpp:
#include "some_header.h"
class A {
public:
void SetX(int x)
{
me.x = x;
me.Update();
}
void SomeOtherFunction()
{
::Update();
}
/*
100 or more lines
...
*/
void Update()
{
// ...
}
int x;
};
Quindi, in un metodo di classe quando accedo a un membro della classe, utilizzo sempre me , e quando accedo a un identificatore globale uso sempre :: . Questo dà al lettore che non ha familiarità con il codice (probabilmente io dopo pochi mesi) le informazioni localizzate su ciò a cui si accede senza la necessità di cercare altrove. Voglio definire me perché trovo che usare this-> ovunque sia troppo rumoroso e brutto. Ma può #define me (*this) essere considerato una buona pratica C ++? Ci sono alcuni punti problematici pratici con la macro me ? E se tu come programmatore C ++ sarai il lettore di un codice usando la macro me , ti piacerebbe o no?
Modifica: perché molte persone discutono in modo non specifico contro usando me , ma in generale contro esplicito questo. Penso che potrebbe non essere chiaro quali sono i vantaggi di "esplicitare questo ovunque".
Quali sono i vantaggi di "esplicito questo ovunque"?
- Come lettore del codice hai la certezza di ciò a cui si accede e puoi concentrarti su cose diverse rispetto a verificare - in qualche codice remoto - che è realmente accessibile quello a cui pensi di aver accesso.
- Puoi utilizzare la funzione di ricerca in modo più specifico. La ricerca "
this->x" può darti risultati più ricercati rispetto alla sola ricerca "x" - Quando si elimina o si rinomina un membro, il compilatore ti avvisa in modo affidabile nei luoghi in cui viene utilizzato questo membro. (Alcune funzioni globali possono avere lo stesso nome ed esistono possibilità che tu possa introdurre un errore se non stai usando questo esplicito).
- Quando si esegue il refactoring del codice e si esegue una funzione non membro dal membro (per rendere l'incapsulamento migliore) esplicita questo mostra quale posto è necessario modificare ed è possibile sostituirlo facilmente con il puntatore all'istanza della classe fornita come parametro della funzione non membro
- Generalmente quando modifichi il codice, ci sono più possibilità di errori quando non lo usi esplicitamente rispetto a quando lo usi esplicitamente ovunque.
- Esplicito questo è meno rumoroso dell'esplicativo "m_" quando si accede al membro dall'esterno (
object.membervsobject.m_member) (grazie a @Kaz per individuare questo punto) - Esplicito risolve questo problema universalmente per tutti i membri - attributi e metodi, mentre "m_" o altro prefisso è praticabile solo per gli attributi.
Vorrei lucidare ed estendere questo elenco, dimmi se conosci altri vantaggi e casi d'uso per esplicito questo ovunque .