SubProcedures in C++/G++?



  • Hallo,

    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



  • 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);
    }
    

    Achso: Die sehen den umgebenen Scope allerdings nicht.



  • Hallo,

    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.



  • Tachyon schrieb:

    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.



  • Braunstein schrieb:

    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.
    };
    


  • Braunstein schrieb:

    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
    }
    


  • Ich weiße mal obligatorisch auf Lambdas in C++0x hin.

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


  • Danke für die Antworten!

    Gruß
    NewBee



  • Ok, Ihr habt ja alle recht.
    Ich ziehe hiermit das deklariert zurück und ersetze es durch definiert.



  • volkard schrieb:

    Static ist wichtiger.

    Wieso?



  • btw, was C++0x mit lambda's anbietet, lässt sich auch mit Funktoren nachstellen...
    sieht nur nicht so stylisch aus :p

    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);
    }
    


  • Tachyon schrieb:

    Wieso?

    Member ohne Instanz ausführen.



  • int test()
    {
      int a = 0;
    
      auto test2 = [&]()
      {
        ++a;
      }
    
      test2();
      cout << a;
    }
    

    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 ...


Log in to reply