Namenskonvention - Unterstrich in C ++ - und C # -Variablen

Es ist üblich, einen _varVariablennamen in einem Klassenfeld zu sehen. Was bedeutet der Unterstrich? Gibt es eine Referenz für all diese speziellen Namenskonventionen?

Der Unterstrich ist einfach eine Konvention; nichts mehr. Als solches ist seine Verwendung für jede Person immer etwas anders. So verstehe ich sie für die beiden fraglichen Sprachen:

In C ++ gibt ein Unterstrich normalerweise eine private Mitgliedsvariable an.

In C # wird es normalerweise nur verwendet, wenn die zugrunde liegende private Mitgliedsvariable für eine öffentliche Eigenschaft definiert wird. Andere private Mitgliedsvariablen hätten keinen Unterstrich. Diese Verwendung ist jedoch mit dem Aufkommen automatischer Eigenschaften weitgehend auf der Strecke geblieben.

Vor:

private string _name;
public string Name
{
    get { return this._name; }
    set { this._name = value; }
}

Nach dem:

public string Name { get; set; }

Es wird empfohlen, UNDERSCORES NICHT vor einem Variablennamen oder Parameternamen in C ++ zu verwenden

Namen, die mit einem Unterstrich oder einem doppelten Unterstrich beginnen, werden für die C ++ - Implementierer VORBEHALTEN. Namen mit einem Unterstrich sind für die Bibliothek reserviert.

Wenn Sie den C ++ Coding Standard gelesen haben, sehen Sie, dass auf der ersten Seite Folgendes steht:

"Benennen Sie die Benennung nicht zu stark, sondern verwenden Sie eine einheitliche Namenskonvention: Es gibt nur zwei Must-Dos: a) Verwenden Sie niemals" hinterhältige Namen ", die mit einem Unterstrich beginnen oder einen doppelten Unterstrich enthalten." (p2, C ++ Coding Standards, Herb Sutter und Andrei Alexandrescu)

Im ISO-Arbeitsentwurf sind insbesondere die tatsächlichen Regeln aufgeführt:

Darüber hinaus sind einige Bezeichner für die Verwendung durch C ++ - Implementierungen reserviert und dürfen nicht anderweitig verwendet werden. Es ist keine Diagnose erforderlich. (a) Jeder Bezeichner, der einen doppelten Unterstrich __ enthält oder mit einem Unterstrich gefolgt von einem Großbuchstaben beginnt, ist der Implementierung für jede Verwendung vorbehalten. (b) Jeder Bezeichner, der mit einem Unterstrich beginnt, ist der Implementierung zur Verwendung als Name im globalen Namespace vorbehalten.

Es wird empfohlen, ein Symbol nicht mit einem Unterstrich zu beginnen, falls Sie versehentlich in eine der oben genannten Einschränkungen geraten.

Sie können sich selbst davon überzeugen, warum die Verwendung von Unterstrichen bei der Entwicklung einer Software katastrophal sein kann:

Versuchen Sie, ein einfaches helloWorld.cpp-Programm wie folgt zu kompilieren:

g++ -E helloWorld.cpp

Sie sehen alles, was im Hintergrund passiert. Hier ist ein Ausschnitt:

   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       __streambuf_type* __sb = this->rdbuf();
       if (__sb)
  {
    if (__sb->pubsync() == -1)
      __err |= ios_base::badbit;
    else
      __ret = 0;
  }

Sie können sehen, wie viele Namen mit einem doppelten Unterstrich beginnen!

Wenn Sie sich die Funktionen virtueller Elemente ansehen, werden Sie feststellen, dass * _vptr der Zeiger ist, der für die virtuelle Tabelle generiert wird und automatisch erstellt wird, wenn Sie eine oder mehrere Funktionen virtueller Elemente in Ihrer Klasse verwenden! Aber das ist eine andere Geschichte ...

Wenn Sie Unterstriche verwenden, können Konflikte auftreten und Sie haben keine Ahnung, was sie verursacht, bis es zu spät ist.

Eigentlich kommt die _varKonvention von VB, nicht von C # oder C ++ (m _, ... ist eine andere Sache).

Dies überwand die Groß- und Kleinschreibung von VB bei der Deklaration von Eigenschaften.

Zum Beispiel ist ein solcher Code in VB nicht möglich , weil sie der Auffassung ist userund Userals die gleiche Kennung

Private user As String

Public Property User As String
  Get
    Return user
  End Get
  Set(ByVal Value As String)
    user = value
  End Set
End Property

Um dies zu überwinden, verwendeten einige eine Konvention, um dem privaten Feld '_' hinzuzufügen, um so zu kommen

Private _user As String

Public Property User As String
  Get
    Return _user
  End Get
  Set(ByVal Value As String)
    _user = value
  End Set
End Property

Da viele Konventionen für .Net gelten und eine gewisse Einheitlichkeit zwischen der C # - und der VB.NET-Konvention gewährleisten sollen, verwenden sie dieselbe.

Ich fand die Referenz für das, was ich sagte: http://10rem.net/articles/net-naming-conventions-and-programming-standards---best-practices

Kamelkoffer mit führendem Unterstrich. Geben Sie in VB.NET immer "Geschützt" oder "Privat" an, verwenden Sie nicht "Dim". Von der Verwendung von "m_" wird abgeraten, ebenso wie von der Verwendung eines Variablennamens, der sich nur in Einzelfällen von der Eigenschaft unterscheidet, insbesondere bei geschützten Variablen, da dies die Compliance verletzt und Ihr Leben zu einem Schmerz macht, wenn Sie wie Sie in VB.NET programmieren Sie müssten Ihren Mitgliedern einen anderen Namen als die Accessor / Mutator-Eigenschaften geben. Von allen hier aufgeführten Punkten ist der führende Unterstrich wirklich der einzige umstrittene. Ich persönlich bevorzuge es für meine privaten Variablen gegenüber einem Kamel ohne Unterstrich, damit ich Variablennamen nicht mit "this" qualifizieren muss. um von Parametern in Konstruktoren oder anderswo zu unterscheiden, wo ich wahrscheinlich eine Namenskollision haben werde. Bei der Groß- und Kleinschreibung von VB.NET ist dies umso wichtiger, als Ihre Accessor-Eigenschaften mit Ausnahme des Unterstrichs normalerweise denselben Namen wie Ihre privaten Mitgliedsvariablen haben. Für m_ geht es wirklich nur um Ästhetik. Ich (und viele andere) finde m_ hässlich, da es so aussieht, als ob der Variablenname ein Loch enthält. Es ist fast beleidigend. Ich habe es die ganze Zeit in VB6 verwendet, aber das lag nur daran, dass Variablen keinen führenden Unterstrich haben konnten. Ich könnte nicht glücklicher sein zu sehen, wie es verschwindet. Microsoft empfiehlt gegen das m_ (und das gerade _), obwohl beide in ihrem Code getan haben. Auch das Präfixieren mit einem geraden "m" ist richtig. Da sie hauptsächlich in C # codieren, können sie natürlich private Mitglieder haben, die sich nur im Fall von den Eigenschaften unterscheiden. VB-Leute müssen etwas anderes tun. Anstatt zu versuchen, sprachweise Sonderfälle zu entwickeln, empfehle ich den führenden Unterstrich für alle Sprachen, die dies unterstützen. Wenn meine Klasse vollständig CLS-kompatibel sein soll, kann ich das Präfix für alle C # -geschützten Mitgliedsvariablen weglassen. In der Praxis mache ich mir darüber jedoch keine Sorgen, da ich alle potenziell geschützten Mitgliedsvariablen privat halte und stattdessen geschützte Accessoren und Mutatoren bereitstelle. Warum: Kurz gesagt, diese Konvention ist einfach (ein Zeichen), leicht zu lesen (Ihr Auge wird nicht von anderen führenden Zeichen abgelenkt) und vermeidet erfolgreich das Benennen von Kollisionen mit Variablen auf Prozedurebene und Eigenschaften auf Klassenebene. Eigenschaften auf Klassenebene . Ich empfehle den führenden Unterstrich für alle Sprachen, die ihn unterstützen. Wenn meine Klasse vollständig CLS-kompatibel sein soll, kann ich das Präfix für alle C # -geschützten Mitgliedsvariablen weglassen. In der Praxis mache ich mir darüber jedoch keine Sorgen, da ich alle potenziell geschützten Mitgliedsvariablen privat halte und stattdessen geschützte Accessoren und Mutatoren bereitstelle. Warum: Kurz gesagt, diese Konvention ist einfach (ein Zeichen), leicht zu lesen (Ihr Auge wird nicht von anderen führenden Zeichen abgelenkt) und vermeidet erfolgreich das Benennen von Kollisionen mit Variablen auf Prozedurebene und Eigenschaften auf Klassenebene. Eigenschaften auf Klassenebene . Ich empfehle den führenden Unterstrich für alle Sprachen, die ihn unterstützen. Wenn meine Klasse vollständig CLS-kompatibel sein soll, kann ich das Präfix für alle C # -geschützten Mitgliedsvariablen weglassen. In der Praxis mache ich mir darüber jedoch keine Sorgen, da ich alle potenziell geschützten Mitgliedsvariablen privat halte und stattdessen geschützte Accessoren und Mutatoren bereitstelle. Warum: Kurz gesagt, diese Konvention ist einfach (ein Zeichen), leicht zu lesen (Ihr Auge wird nicht von anderen führenden Zeichen abgelenkt) und vermeidet erfolgreich das Benennen von Kollisionen mit Variablen auf Prozedurebene und Eigenschaften auf Klassenebene. Eigenschaften auf Klassenebene . Ich mache mir darüber keine Sorgen, da ich alle potenziell geschützten Mitgliedsvariablen privat halte und stattdessen geschützte Accessoren und Mutatoren bereitstelle. Warum: Kurz gesagt, diese Konvention ist einfach (ein Zeichen), leicht zu lesen (Ihr Auge wird nicht von anderen führenden Zeichen abgelenkt) und vermeidet erfolgreich das Benennen von Kollisionen mit Variablen auf Prozedurebene und Eigenschaften auf Klassenebene. Eigenschaften auf Klassenebene . Ich mache mir darüber keine Sorgen, da ich alle potenziell geschützten Mitgliedsvariablen privat halte und stattdessen geschützte Accessoren und Mutatoren bereitstelle. Warum: Kurz gesagt, diese Konvention ist einfach (ein Zeichen), leicht zu lesen (Ihr Auge wird nicht von anderen führenden Zeichen abgelenkt) und vermeidet erfolgreich das Benennen von Kollisionen mit Variablen auf Prozedurebene und Eigenschaften auf Klassenebene. Eigenschaften auf Klassenebene .

Der erste Kommentator (R Samuel Klatchko) verwies auf: Welche Regeln gelten für die Verwendung eines Unterstrichs in einem C ++ - Bezeichner? Dies beantwortet die Frage nach dem Unterstrich in C ++. Im Allgemeinen sollten Sie keinen führenden Unterstrich verwenden, da dieser dem Implementierer Ihres Compilers vorbehalten ist. Der Code, den Sie sehen, _varist wahrscheinlich entweder Legacy-Code oder Code, der von jemandem geschrieben wurde, der mit dem alten Benennungssystem aufgewachsen ist, das die führenden Unterstriche nicht missbilligt hat.

Wie in anderen Antworten angegeben, wurde es in C ++ verwendet, um Klassenmitgliedsvariablen zu identifizieren. Es hat jedoch keine besondere Bedeutung für Dekorateure oder Syntax. Wenn Sie es also verwenden möchten, wird es kompiliert.

Ich werde die C # -Diskussion anderen überlassen.

_var hat keine Bedeutung und dient nur dazu, die Unterscheidung zu erleichtern, dass die Variable eine private Mitgliedsvariable ist.

In C ++ ist die Verwendung der _var-Konvention eine schlechte Form, da es Regeln für die Verwendung des Unterstrichs vor einem Bezeichner gibt. _var ist als globale Kennung reserviert, während _Var (Unterstrich + Großbuchstabe) jederzeit reserviert ist. Aus diesem Grund werden in C ++ Benutzer angezeigt, die stattdessen die var_-Konvention verwenden.

Sie können Ihre eigenen Codierungsrichtlinien erstellen. Schreiben Sie einfach eine klare Dokumentation für den Rest des Teams.

Die Verwendung von _field hilft Intelilsense, alle Klassenvariablen zu filtern, die nur _ eingeben.

Normalerweise befolge ich die Brad Adams-Richtlinien , es wird jedoch empfohlen, keinen Unterstrich zu verwenden.

Der Microsoft-Namensstandard für C # besagt, dass Variablen und Parameter die Kleinbuchstaben- IE verwenden sollten : paramName . Die Norm fordert auch Felder die gleiche Form zu folgen , aber dies unklar Code führen kann , so viele Teams für einen Unterstrich Präfix Anrufklarheit zu verbessern IE: _fieldName .

In C # wird in den Microsoft Framework-Entwurfsrichtlinien empfohlen , den Unterstrich für öffentliche Mitglieder nicht zu verwenden. Für private Mitglieder können Unterstriche verwendet werden. Tatsächlich verwendet Jeffrey Richter (oft in den Richtlinien zitiert) beispielsweise ein m_ und ein "s_" für private statische Mitglieder.

Persönlich benutze ich nur _, um meine privaten Mitglieder zu markieren. "m_" und "s_" grenzen an die ungarische Notation, die nicht nur in .NET verpönt ist, sondern auch sehr ausführlich sein kann, und ich finde Klassen mit vielen Mitgliedern schwierig, einen schnellen Augenscan alphabetisch durchzuführen (stellen Sie sich 10 Variablen vor, die alle mit m_ beginnen). .

Ich verwende die _var-Benennung für Mitgliedsvariablen meiner Klassen. Ich habe zwei Hauptgründe:

1) Es hilft mir, Klassenvariablen und lokale Funktionsvariablen im Auge zu behalten, wenn ich meinen Code später lese.

2) Es hilft in Intellisense (oder einem anderen Code-Vervollständigungssystem), wenn ich nach einer Klassenvariablen suche. Nur das erste Zeichen zu kennen, ist hilfreich beim Filtern durch die Liste der verfügbaren Variablen und Methoden.

Für die Sprachen C und C ++ hat ein Unterstrich im Namen (Anfang, Mitte oder Ende) keine besondere Bedeutung. Es ist nur ein gültiges Variablennamenzeichen. Die "Konventionen" stammen aus Codierungspraktiken innerhalb einer Codierungsgemeinschaft.

Wie bereits in verschiedenen Beispielen oben angegeben, kann _ am Anfang private oder geschützte Mitglieder einer Klasse in C ++ bedeuten.

Lassen Sie mich nur eine Geschichte erzählen, die Spaß machen kann. Wenn Sie unter UNIX über eine Kernfunktion der C-Bibliothek und ein Kernel-Back-End verfügen, in dem Sie die Kernelfunktion auch dem Benutzerbereich zugänglich machen möchten, bleibt das _ vor dem Funktionsstub hängen, der die Kernelfunktion direkt aufruft, ohne etwas anderes zu tun. Das bekannteste und bekannteste Beispiel hierfür ist exit () vs _exit () unter Kerneln vom Typ BSD und SysV: Dort erledigt exit () User-Space-Aufgaben, bevor der Exit-Service des Kernels aufgerufen wird, während _exit nur dem Exit-Service des Kernels zugeordnet wird.

Also wurde _ für "lokales" Zeug verwendet, in diesem Fall ist local maschinenlokal. Normalerweise waren _functions () nicht portierbar. Insofern sollten Sie nicht dasselbe Verhalten auf verschiedenen Plattformen erwarten.

Nun zu _ in Variablennamen, wie z

int _foo;

Nun, psychologisch gesehen ist ein _ eine seltsame Sache, die man am Anfang eingeben muss. Wenn Sie also einen Variablennamen erstellen möchten, bei dem die Wahrscheinlichkeit eines Konflikts mit etwas anderem geringer ist, sollten Sie INSBESONDERE bei der Verwendung von Vorprozessorsubstitutionen die Verwendung von _ in Betracht ziehen.

Mein grundlegender Rat wäre, immer die Konvention Ihrer Coding-Community zu befolgen, damit Sie effektiver zusammenarbeiten können.

Es bedeutet einfach, dass es sich um ein Mitgliedsfeld in der Klasse handelt.

Es gibt keine bestimmte Namenskonvention, aber ich habe das für private Mitglieder gesehen.

Viele Leute möchten, dass privaten Feldern ein Unterstrich vorangestellt wird. Es ist nur eine Namenskonvention.

Die offiziellen Namenskonventionen von C # schreiben einfache Kleinbuchstaben (kein Unterstrich) für private Felder vor.

Standardkonventionen für C ++ sind mir nicht bekannt, obwohl Unterstriche sehr häufig verwendet werden.

Es ist nur eine Konvention, die einige Programmierer verwenden, um deutlich zu machen, wenn Sie ein Mitglied der Klasse oder eine andere Art von Variable (Parameter, lokal für die Funktion usw.) manipulieren. Eine andere Konvention, die auch für Mitgliedsvariablen weit verbreitet ist, ist das Präfixieren des Namens mit 'm_'.

Auf jeden Fall sind dies nur Konventionen, und Sie werden nicht für alle eine einzige Quelle finden. Sie sind eine Frage des Stils und jedes Programmierteam, Projekt oder Unternehmen hat seine eigenen (oder sogar keine).

Es gibt einen völlig legitimen Grund, es in C # zu verwenden: Wenn der Code auch über VB.NET erweiterbar sein muss. (Sonst würde ich nicht.)

Da bei VB.NET die Groß- und Kleinschreibung nicht berücksichtigt wird, gibt es fieldin diesem Code keine einfache Möglichkeit, auf das geschützte Mitglied zuzugreifen :

public class CSharpClass
{
    protected int field;
    public int Field { get { return field; } }
}

Dies greift beispielsweise auf den Property Getter zu, nicht auf das Feld:

Public Class VBClass
    Inherits CSharpClass

    Function Test() As Integer
        Return Field
    End Function

End Class

Heck, ich kann nicht einmal fieldin Kleinbuchstaben schreiben - VS 2010 korrigiert es einfach weiter.

Um es abgeleiteten Klassen in VB.NET leicht zugänglich zu machen, muss eine andere Namenskonvention entwickelt werden. Das Präfixieren eines Unterstrichs ist wahrscheinlich der am wenigsten aufdringliche und "historisch akzeptierte" von ihnen.

Jetzt ist die Notation mit "this" wie in this.foobarbaz für Mitgliedsvariablen der C # -Klasse akzeptabel. Es ersetzt die alte Notation "m_" oder nur "__". Es macht den Code besser lesbar, da es keinen Zweifel gibt, worauf Bezug genommen wird.

Aus meiner Erfahrung (sicherlich begrenzt) zeigt ein Unterstrich an, dass es sich um eine private Mitgliedsvariable handelt. Wie Gollum sagte, wird dies jedoch vom Team abhängen.

Alte Frage, neue Antwort (C #).

Eine andere Verwendung von Unterstrichen für C # ist die DI (Dependency Injection) von ASP NET Core. Private readonlyVariablen einer Klasse, die während der Erstellung der injizierten Schnittstelle zugewiesen wurden, sollten mit einem Unterstrich beginnen. Ich denke, es ist eine Debatte, ob für jedes private Mitglied einer Klasse ein Unterstrich verwendet werden soll (obwohl Microsoft selbst dem folgt), aber dieser ist sicher.

private readonly ILogger<MyDependency> _logger;

public MyDependency(ILogger<MyDependency> logger)
{
    _logger = logger;
}

Eine solche Namenskonvention ist nützlich, wenn Sie Code lesen, insbesondere Code, der nicht Ihr eigener ist. Eine starke Namenskonvention gibt an, wo ein bestimmtes Mitglied definiert ist, um welche Art von Mitglied es sich handelt usw. Die meisten Entwicklungsteams verwenden eine einfache Namenskonvention und stellen den Mitgliedsfeldern einfach einen Unterstrich ( _fieldName) voran . In der Vergangenheit habe ich die folgende Namenskonvention für C # verwendet (die auf Microsoft-Konventionen für den .NET Framework-Code basiert, die mit Reflector angezeigt werden):

Instanzfeld : m_fieldName
Statisches Feld: s_fieldName
Öffentliches / geschütztes / internes Mitglied: PascalCasedName ()
Privates Mitglied: camelCasedName ()

Dies hilft den Menschen, die Struktur, Verwendung, Zugänglichkeit und Position von Mitgliedern zu verstehen, wenn sie unbekannten Code sehr schnell lesen.