Warum kann ich Strukturen und Klassen innerhalb einer Funktion in C ++ definieren?

Ich habe so etwas fälschlicherweise in C ++ gemacht, und es funktioniert. Warum kann ich das tun?

int main(int argc, char** argv) {
    struct MyStruct
    {
      int somevalue;
    };

    MyStruct s;
    s.somevalue = 5;
}

Nachdem ich das getan hatte, erinnerte ich mich daran, dass ich vor langer Zeit irgendwo über diesen Trick gelesen hatte, als eine Art funktionales Programmierwerkzeug für C ++, aber ich kann mich nicht erinnern, warum dies gültig ist oder wo ich es gelesen habe.

Antworten auf beide Fragen sind willkommen!

Hinweis: Obwohl ich beim Schreiben der Frage keine Verweise auf diese Frage erhalten habe, weist die aktuelle Seitenleiste darauf hin, sodass ich sie hier als Referenz einfügen werde. In beiden Fällen ist die Frage anders, könnte aber nützlich sein.

[EDIT 18/4/2013]: Glücklicherweise wurde die unten erwähnte Einschränkung in C ++ 11 aufgehoben, sodass lokal definierte Klassen schließlich nützlich sind! Vielen Dank an Kommentator Bambus.

Die Möglichkeit, Klassen lokal zu definieren, würde das Erstellen benutzerdefinierter Funktoren (Klassen mit operator()()z. B. Vergleichsfunktionen zum Übergeben an std::sort()oder "Schleifenkörper", mit denen verwendet werden soll std::for_each()) wesentlich komfortabler machen.

Leider verbietet C ++ die Verwendung lokal definierter Klassen mit Vorlagen , da diese keine Verknüpfung haben. Da die meisten Anwendungen von Funktoren Vorlagentypen umfassen, die als Vorlage für den Funktortyp dienen, können lokal definierte Klassen hierfür nicht verwendet werden. Sie müssen sie außerhalb der Funktion definieren. :(

[EDIT 1/11/2009]

Das relevante Zitat aus dem Standard lautet:

14.3.1 / 2: Ein lokaler Typ, ein Typ ohne Verknüpfung, ein unbenannter Typ oder ein Typ, der aus einem dieser Typen zusammengesetzt ist, darf nicht als Vorlagenargument für einen Vorlagentypparameter verwendet werden.

Eine Anwendung lokal definierter C ++ - Klassen befindet sich im Factory-Entwurfsmuster :

// In some header
class Base
{
public:
    virtual ~Base() {}
    virtual void DoStuff() = 0;
};

Base* CreateBase( const Param& );

// in some .cpp file
Base* CreateBase( const Params& p )
{
    struct Impl: Base
    {
        virtual void DoStuff() { ... }
    };

    ...
    return new Impl;
}

Sie können dies jedoch auch mit einem anonymen Namespace tun.

Es ist tatsächlich sehr nützlich, um einige stapelbasierte Ausnahmesicherheitsarbeiten durchzuführen. Oder allgemeine Bereinigung von einer Funktion mit mehreren Rückgabepunkten. Dies wird häufig als RAII-Idiom (Resource Acquisition is Initialzation) bezeichnet.

void function()
{

    struct Cleaner
    {
        Cleaner()
        {
            // do some initialization code in here
            // maybe start some transaction, or acquire a mutex or something
        }

        ~Cleaner()
        {
             // do the associated cleanup
             // (commit your transaction, release your mutex, etc.)
        }
    };

    Cleaner cleaner;

    // Now do something really dangerous
    // But you know that even in the case of an uncaught exception, 
    // ~Cleaner will be called.

    // Or alternatively, write some ill-advised code with multiple return points here.
    // No matter where you return from the function ~Cleaner will be called.
}

Warum eigentlich nicht? A structin C (bis in die Anfänge der Zeit) war nur eine Möglichkeit, eine Datensatzstruktur zu deklarieren. Wenn Sie eine möchten, können Sie sie dort deklarieren, wo Sie eine einfache Variable deklarieren würden.

Wenn Sie dies getan haben, denken Sie daran, dass ein Ziel von C ++ darin bestand, wenn möglich mit C kompatibel zu sein. So blieb es.

Es wird zum Beispiel in Abschnitt "7.8: Lokale Klassen: Klassen innerhalb von Funktionen" von http://www.icce.rug.nl/documents/cplusplus/cplusplus07.html erwähnt, der es eine "lokale Klasse" nennt und es sagt " kann in fortgeschrittenen Anwendungen mit Vererbung oder Vorlagen sehr nützlich sein ".

Es dient zum Erstellen von Arrays von Objekten, die ordnungsgemäß initialisiert wurden.

Ich habe eine Klasse C, die keinen Standardkonstruktor hat. Ich möchte ein Array von Objekten der Klasse C. Ich finde heraus, wie diese Objekte initialisiert werden sollen, und leite dann eine Klasse D von C mit einer statischen Methode ab, die das Argument für das C im Standardkonstruktor von D bereitstellt:

#include <iostream>
using namespace std;

class C {
public:
  C(int x) : mData(x)  {}
  int method() { return mData; }
  // ...
private:
  int mData;
};

void f() {

  // Here I am in f.  I need an array of 50 C objects starting with C(22)

  class D : public C {
  public:
    D() : C(D::clicker()) {}
  private:
    // I want my C objects to be initialized with consecutive
    // integers, starting at 22.
    static int clicker() { 
      static int current = 22;
      return current++;
    } 
  };

  D array[50] ;

  // Now I will display the object in position 11 to verify it got initialized
  // with the right value.  

  cout << "This should be 33: --> " << array[11].method() << endl;

  cout << "sizodf(C): " << sizeof(C) << endl;
  cout << "sizeof(D): " << sizeof(D) << endl;

  return;

}

int main(int, char **) {
  f();
  return 0;
}

In diesem Beispiel wird der Einfachheit halber ein trivialer Nicht-Standard-Konstruktor und ein Fall verwendet, in dem die Werte zur Kompilierungszeit bekannt sind. Es ist einfach, diese Technik auf Fälle zu erweitern, in denen ein Array von Objekten mit Werten initialisiert werden soll, die nur zur Laufzeit bekannt sind.