kennt C++ echte Subfunctions / procedures, die auch im Kontext der Funktion laufen, in der die deklariert wurden?
Wenn ja, wie ist die richtige Deklaration?

void test()
{
  int a;

  void test2() {
   a++;
  }

  test();
}

Danke und Gruß
NewBee

int main()
{
    struct
    {
        void operator()(int a)
        {
            std::cout << a << '\n';
        }
    } sub;

    sub(10);
}

Achso: Die sehen den umgebenen Scope allerdings nicht.

Funktionen dürfen nicht innerhalb andere Funktionen deklariert werden.
Du kannst aber Klasse bzw. Strukturen innerhalb von Funktionen deklarieren. Die können dann natürlich Memberfunktionen haben

kennt C++ echte Subfunctions / procedures, die auch im Kontext der Funktion laufen, in der die deklariert wurden?
Wenn ja, wie ist die richtige Deklaration?

Nein. C++ kennst keine Funktionen, die lokal in einer Funktion definiert / aufgerufen werden können. Man kann das Verhalten aber durch eine Funktion in einer lokal (in der Funktion) definierten Klasse erreichen.

Nein, kennt es nicht. Aber Du kannst Funktoren dafür benutzen:

int main()
{
    struct
    {
        void operator()(int a)
        {
            std::cout << a << '\n';
        }
    } sub;
    
    sub(10);
}

Static ist wichtiger.

void test() {
  int a;

  struct foo {
    static void test2() {
       a++;//klappt aber nicht. 
    }
  }

  foo::test2();
}

Das war nicht gefragt. Gefragt war, daß die sub ohne Übergabe von a magischerweise a schon kennt.

Hallo,

Funktionen dürfen nicht innerhalb andere Funktionen deklariert werden.

Deklariert schon, definiert nicht. Zur Deklaration bedenke das hin und wieder auftauchende Problem der Funktions-Deklaration, die eigentlich ein Default-Ctor-Aufruf sein sollte:

class Foo
{
public: 
  Foo();
};

/* ... */
int main()
{
  Foo f(); //Deklariert eie Funktion f, die ein Foo liefert.
  Foo f2; //Deklariert&Definiert eine Foo-Variable f2, die default-initialisiert wird.
};

Hallo,
Funktionen dürfen nicht innerhalb andere Funktionen deklariert werden.

Doch, irgendwie schon.

#include <string>
int main(){
   std::string h("hallo");
   std::string w("welt");
   std::string p();//patsch
}

void test()
{
  int a;

  auto test2 = [&]() {
   a++;
  };

  test2();
}

Gruß
NewBee

Static ist wichtiger.

Wieso?

void foo(void)
{
    int a = 0;

    struct functor
    {
        int& a;

        functor(int & A) : a(A) {}

        void operator () (void)
        {
            ++a;
        }
    } bar(a);

    bar();
}

-> ungetestet

wenn die subroutine keine Kenntnis vom äußeren scope braucht,
kann man auch direkt den Konstruktor misbrauchen

void foo(void)
{
    int a = 0;

    struct functor
    {
        functor(int & a)
        {
            ++a;
        }
    };

    // hier würde ein temporäres functor-Objekt erstellt, was verworfen wird,
    // da es keiner Variablen zugewiesen wird
    // übrig bleibt eine einfach Funktion...
    // bleibt nur offen, in wiefern hier der compiler optimiert
    // aber da der functor keine Attribute hat, dürfte es eig keine Speicher-Overhead geben.
    functor(a);
}

Wieso?

Member ohne Instanz ausführen.

C++0x rockt mal wieder die Bude. Zumindestens wenn dein Compiler schon ein bischen kann

Edit: Upps, ich sollte keine Seiten mehrere Minuten offen lassen und dann erst schreiben ...