Deklarieren Sie Variablen am Anfang der Funktion oder in separaten Bereichen?

Variablen deklariert werden sollte so lokal wie möglich.

Deklarieren von Variablen "an der Spitze der Funktion" immer eine katastrophal schlechte Praxis. Auch in C89/90 Sprache, wo Variablen können nur erklärt werden, an den Anfang des Blocks, ist es besser zu erklären, so lokal wie möglich, also am Anfang von kleinsten lokalen block umfassen, die die gewünschte Lebensdauer der Variablen. Manchmal ist es vielleicht sogar sinnvoll, für die Einführung eines "redundanten" lokalen block, nur mit dem Zweck der "Lokalisierung" der Deklaration von Variablen.

In C++ und C99, wo es möglich ist, zu erklären, variable irgendwo im code, die Antwort ist ziemlich einfach: immer deklarieren Sie jede variable so lokal wie möglich und so nah wie möglich an dem Punkt, wo Sie es das erste mal. Die primäre Begründung dafür ist, dass in den meisten Fällen wird diese ermöglichen es Ihnen zu liefern, die eine sinnvolle Initialisierung der Variablen an der Stelle der Deklaration (statt Deklaration ohne Initialisierung oder mit einem dummy-Initialisierung).

Als Speicher für die Verwendung, die im Allgemeinen eine typische Implementierung wird sofort (sobald Sie mit der Eingabe der Funktion) Zuordnung der maximal erforderliche Speicherplatz für alle Variablen, die zur gleichen Zeit existieren. Aber Ihre Erklärung Gewohnheiten beeinflussen könnte, die genaue Größe des Raumes. Zum Beispiel in diesem code

void foo() {
  int a, b, c;

  if (...) {
  }

  if (...) {
  }
}

alle drei Variablen zur gleichen Zeit existieren und in der Regel den Raum für alle drei allokiert werden. Aber in diesem code

void foo() {
  int a;

  if (...) {
    int b;
  }

  if (...) {
    int c;
  }
}

nur zwei Variablen existieren, die in jedem gegebenen moment, was bedeutet, dass Platz für nur zwei Variablen zugewiesen werden, die von einer typischen Implementierung (b und c teilen sich den gleichen Raum). Dies ist ein weiterer Grund, deklarieren Sie Variablen so lokal wie möglich.

InformationsquelleAutor der Antwort AnT

Ich wie Methode 3:

LRESULT wpMainWindowPaint(HWND hwnd)
{
    HDC hdc;
    PAINTSTRUCT ps;

    RECT rc;
    GetClientRect(hwnd, &rc);           

    hdc = BeginPaint(hwnd, &ps);
    //drawing here
    EndPaint(hwnd, &ps);
    return 0;
}

LRESULT CALLBACK wpMainWindow(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
    switch (msg)
    {
        case WM_PAINT:      return wpMainWindowPaint(hwnd);
        default:            return DefWindowProc(hwnd, msg, wparam, lparam);
    }
}

Wenn es verdient einen eigenen Bereich für die Organisation Zwecke, die es verdient seine eigene Funktion. Wenn Sie besorgt über das function-call overhead, stellen Sie es inline.

InformationsquelleAutor der Antwort Ben Voigt

Definieren Sie die Variablen im engsten Bereich, wo Sie relevant sind. Es gibt keinen Grund, verwenden Sie Methode 2, oben, meiner Meinung nach.

Stack-Speicher ist wahrscheinlich nur verwendet werden, wenn die Variablen in scope. @Paxdiablo Punkte, die einheimische wind in Registern statt auf dem stack, wenn der compiler Sie finden den Raum für Sie.

InformationsquelleAutor der Antwort Steve Townsend

Können Sie nicht wissen, an welchem Punkt die stack-Reservierung erfolgt ist.

Zur besseren Lesbarkeit würde ich mit C99 (oder C++). Das ermöglicht die Deklaration einer variable wirklich dort, wo Sie zuerst verwenden.

 HDC hdc = BeginPaint(hwnd, &ps);

InformationsquelleAutor der Antwort Jens Gustedt

Für die Programmiersprache Java, die gängige Praxis ist, um lokale Variablen deklarieren, die nur bei Bedarf in eine Methode.

void foo(int i) {
  if (i == 1)
    return;
  Map map1 = new HashMap();
  if (i == 2)
    return;
  Map map2 = new HashMap();
}

Für die C++ - Programmiersprache, ich empfehle auch die gleiche Praxis, da das deklarieren von Variablen mit einer nicht-trivialen Konstruktor beinhaltet die Ausführung Kosten. Putting alle diese Erklärungen auf die Methode Anfang verursacht unnötige Kosten, wenn einige dieser Variablen verwendet werden.

void foo(int i) 
{
  if (i == 1)
    return;
  std::map<int, int> map1; //constructor is executed here
  if (i == 2)
    return;
  std::map<int, int> map2; //constructor is executed here
}

C, die Geschichte ist anders. Es hängt von der Architektur und compiler. Für x86-GCC, dass alle Erklärungen auf Funktion Anfang und das deklarieren von Variablen, die nur bei Bedarf die gleiche Leistung. Der Grund ist, dass C-Variablen nicht über einen Konstruktor verfügen. Und der Effekt auf den stack-Speicher-Zuordnung, die durch diese beiden Methoden ist die gleiche. Hier ist ein Beispiel:

void foo(int i)
{
  int m[50];
  int n[50];
  switch (i) {
    case 0:
      break;
    case 1:
      break;
    default:
      break;
  }
}

void bar(int i) 
{
  int m[50];
  switch (i) {
    case 0:
      break;
    case 1:
      break;
    default:
      break;
  }
  int n[50];
}

Für beide Funktionen, die Assembler-code für stack-manipulation ist:

pushl   %ebp
movl    %esp, %ebp
subl    $400, %esp

Dass alle Erklärungen auf Funktion zu Beginn wird Häufig in Linux-kernel-code.

InformationsquelleAutor der Antwort Jingguo Yao