OK Non sono un programmatore C++ molto esperto, ma mi chiedevo qual è il significato dei caratteri di sottolineatura negli argomenti del seguente costruttore?Qual è il significato dei principali caratteri di sottolineatura in un costruttore C++?
class floatCoords
{
public:
floatCoords(float _x, float _y, float _width, float _height)
: x(_x), y(_y), width(_width), height(_height)
{
}
float x, y, width, height;
...
È solo una comoda convenzione di denominazione, non significa nulla per la lingua. Assicurati di non seguirlo con una lettera maiuscola: What does double underscore (__const) mean in C?
Sono solo nomi per i parametri passati. Si verificano corrispondenze tra variabili membro e vengono utilizzati per gli inizializzatori.
Non c'è alcun significato speciale: è solo una convenzione che alcune persone possono utilizzare.
Niente di speciale. L'ha appena chiamato così per distinguere tra le variabili membro e i nomi dei parametri.
Underscore è un carattere valido negli identificatori C++.
Inoltre, normalmente le variabili membro hanno undersco res per convenzione e gli argomenti del costruttore no. Tuttavia, tutto dipende dalla convenzione di programmazione locale. Alcuni negozi richiedono "m_" davanti ai membri. Stai lontano dai doppi trattini bassi (riservato per l'uso del compilatore). vedere: http://stackoverflow.com/questions/1228161/why-use-prefixes-on-member-variables-in-c-classes – bluehavana
Ho visto abbastanza codice per dire che nulla nei nomi dei membri privati, molto meno underscore, sono convenzionali. – coppro
Si noti inoltre che questa distinzione non è strettamente necessaria in un iniziatore del Ctor: la ricerca del nome per i membri trova solo i membri e la ricerca del nome all'interno dell'inizializzatore troverà prima il nome del parametro. – coppro
Non hanno un significato sintattico. Tuttavia, se si dispone di una serie di campi (ad esempio x, , width e height), è una convenzione comune denominare i parametri del costruttore che li inizializzano con il nome del campo più un trattino basso iniziale.
Lo scopo di questi trattini bassi è distinguere la variabile parametro float _x e la variabile membro float x. Sintatticamente, non è stato aggiunto alcun significato speciale a causa dei caratteri di sottolineatura. Personalmente preferisco prefixare tutti i parametri con a_ e prefisso tutte le variabili membro con m_ quando devo codificare C++.
Così, quando mi trovo in una situazione in cui devo mischiare e abbinare le variabili locali, membri e parametri, so con quali rapporti.
int y = a_x * 2;
m_x = y + 3;
Molto probabilmente, l'autore del codice stava tentando di evitare il potenziale conflitto tra i nomi dei membri dati ei nomi dei parametri del costruttore nell'elenco di inizializzazione. Molto probabilmente, l'autore non era a conoscenza del fatto che le regole di ricerca C++ assicurano che il conflitto non si verificherà comunque. Cioè il seguente codice produrrà anche i risultati attesi
class floatCoords {
public:
floatCoords(float x, float y, float width, float height)
: x(x), y(y), width(width), height(height)
{
}
float x, y, width, height;
...
anche se potrebbe rivelarsi fonte di confusione per un lettore non preparato.
Ovviamente, all'interno del corpo del costruttore, i nomi dei parametri nascondono i nomi dei membri, rendendo quindi necessario utilizzare this->... o nomi qualificati per accedere ai membri dei dati. È probabile che l'autore del codice stia cercando di evitare anche quello.
Interessante, non conoscevo questo bocconcino. Tuttavia, nella mia mente sarebbe ancora meglio usare i nomi dei parametri che non corrispondono ai nomi delle variabili dei membri. In questo caso, puoi usare xey come parametri nel ctor, ma se dovessi scrivere setX e setY, dovresti usare nomi di parametri diversi. Preferisco mantenere i miei nomi dei parametri coerenti in tutta la classe. – ThisSuitIsBlackNot
@ThisSuitIsBlackNot: non necessariamente. La sintassi 'this-> member' consente di implementare i metodi' setX' e 'setY' anche se i nomi dei parametri nascondono i nomi dei membri. Alcuni standard di codifica richiedono effettivamente che i membri della classe siano sempre accessibili attraverso la sintassi 'this-> member' (c'è un certo valore in esso, devo ammetterlo). – AnT
@AndreyT: sei un buon punto. Se usato in modo coerente, la sintassi di questo-> membro è molto chiara (ho visto questo formato in molte classi Java). Tuttavia, cosa succede quando dimentichi la parte "questo->"? Non sono sicuro di quale sia il comportamento, ma immagino che ciò avvenga frequentemente su progetti di grandi dimensioni. Anche se non accade nulla di spaventoso, l'incoerenza del codice mi infastidirebbe (sto prendendo in giro qui). – ThisSuitIsBlackNot
perché se si denominasse den float x, float y ecc. Non è possibile accedere ai campi effettivi della classe perché hanno lo stesso nome.
non ha nulla a che fare con il linguaggio, è solo una convenzione dal programmatore reale (per rendere il codice più evidente, credo)
Questi sono solo convenzione di denominazione variabile che diverse persone/istituzioni assumono. Questo può sembrare non necessario a prima vista, ma in realtà è molto utile quando si legge e si scrive codice, specialmente quando si hanno parametri e variabili membro che hanno lo stesso nome. Per esempio.si possono comunemente avere questi tre casi:
class A {
void foo(int age_) { //parameter
int age = 18; //local scope
if (age_ > age) cout << legal << endl;
}
int _age; //member
};
Nell'esempio di cui sopra:
e _Variable tresspasses sul namespace implementor. –
Vedi anche: http://stackoverflow.com/questions/228783/what-are-the-rules-about-using-an-underscore-in-ac-identifier/228797#228797 –
@Martin: Grazie, mi piace il tuo link ancora meglio. –
Evito completamente i trattini bassi solo in modo che non debba spiegare/ricordare il bit "non seguire con una lettera maiuscola". –