Danke im Voraus :3

void schrittweise()
{
  static int step=0;
  ++step;
  switch (step)
    {
    case 1:
      // Schritt 1
      return;
    case 2:
      // Schritt 2
      return;

      // Und so weiter
    }
}

Hai.
Könnte mir jemand sagen, wie ich das programm eine funktion schrittweise ausführen kann? Also, mein ziel ist, eine classe zu machen, die mehrere funktionen gleichzeitig ausführen kann (bitte nicht sagen, Dazu giebt's doch threads).

Ohne die Funktionen zu verändern, wie SeppJ gezeigt hat, wird es kaum möglich sein. Eine andere Möglichkeit wäre vielleicht das hier.

int foobar (string abc)
{
    int a;
    a = 10 * 20 / 30 + 40 - 50;
    int b;
    // usw...

    return 0;
}

int main ()
{
    exec_func_step(foobar);
    return 0;
}

Diese Angabe "Schritt für Schritt ausführen" ist ziemlich ungenau. Um Code Schritt für Schritt auszuführen, nimmt man normalerweise einen Debugger.

Also, ich habe doch gesagt das ich das genau OHNE Threads oder Debugger machen MUSS.

Und genau das wurde dir bereits gesagt: Ohne etwas an deinem Code zu verändern geht es nicht!
Entweder Threads, dann wird parallel abgearbeitet, oder du führst eine zusätzliche Variable ein die dir anzeigt, welche Operation du nun ausführen sollst (siehe direkt die erste Antwort von SeppJ).

Du könntest mal genauer erklären was die Aufgabenstellung ist, dann gibt es auch konkretere Tipps.

OHNE ... Debugger machen MUSS

Das hast du aber jetzt reineditiert...

Aber könntest du trotzdem mal sagen, wie genau du dir das vorstellst?
Warum funktioniert das was SeppJ vorgeschlagen hat nicht?

class Tmulti
{
public:
    void addF (FUNC f); // FUNC ist soll ein funktionspointer sein
    void exec_all ()
    {
        bool end = false;
        while (!end)
        {
            for(int i=0; i<f_max; i++) // f_max: anzahl an functionen
            {
                dostep(fs[i], 10); // 10 schritte auf einmal
            }
        }
    }
};

Gegenfrage: Das was du vor hast ist sehr ungewöhnlich. Kannst du mal deine Motivation erläutern? Vermutlich gibt es bessere, deutlich einfachere Lösungen.

Geht so nicht. Lass es einfach.

Nee, danke. Ich bleib dran :3

Und eine wichtige Sache vergisst du komplett: Multiprozessorsysteme. Viel Spaß, wenn du selber versuchst, die einzelnen Funktionshappen auf mehrere Kerne zu verteilen, damit du wirklich parallele Abarbeitung erhältst

Und jetzt mal wieder ernst: Warum nicht threads verwenden? Das ist genau das was du haben willst und mit etwas Grundwissen (von dem du deutlich mehr brauchst, wenn du das echt selber hinbiegen willst - gib dir 2 Jahre...) kommst du da bald mit zurecht.

Und eine wichtige Sache vergisst du komplett: Multiprozessorsysteme. Viel Spaß, wenn du selber versuchst, die einzelnen Funktionshappen auf mehrere Kerne zu verteilen, damit du wirklich parallele Abarbeitung erhältst

Warum um Gottes Willen sollte er das tun? damit er ganze Cache-Inhalte zwischen den Kernen hin- und herschaufeln lässt?

Für das was er vorhat empfehle ich dem OP ein wenig ordentliche Lektüre über Compilerbau und Parallel-Abläufe. Das sollte ihn ein paar Monate beschäftigen...

Willst du dich nicht nur auf Windows festlegen, kann ein Blick in Richtung boost.threads oder C++0x nicht schaden (der neue Standard soll ja Klassen für Threads enthalten).

l'abra d'or schrieb:

Und eine wichtige Sache vergisst du komplett: Multiprozessorsysteme. Viel Spaß, wenn du selber versuchst, die einzelnen Funktionshappen auf mehrere Kerne zu verteilen, damit du wirklich parallele Abarbeitung erhältst

Warum um Gottes Willen sollte er das tun? damit er ganze Cache-Inhalte zwischen den Kernen hin- und herschaufeln lässt?

Weil es durchaus Betriebssysteme geben soll, die einzelne Threads auf verschiedene Kerne verteilen können. Ich wollte eigentlich nur darauf hinaus, dass es ziemlich aufwändig ist, die Effizienz von nativen Threads selber nachzubauen.

pumuckl schrieb:

l'abra d'or schrieb:

Und eine wichtige Sache vergisst du komplett: Multiprozessorsysteme. Viel Spaß, wenn du selber versuchst, die einzelnen Funktionshappen auf mehrere Kerne zu verteilen, damit du wirklich parallele Abarbeitung erhältst

Warum um Gottes Willen sollte er das tun? damit er ganze Cache-Inhalte zwischen den Kernen hin- und herschaufeln lässt?

Weil es durchaus Betriebssysteme geben soll, die einzelne Threads auf verschiedene Kerne verteilen können. Ich wollte eigentlich nur darauf hinaus, dass es ziemlich aufwändig ist, die Effizienz von nativen Threads selber nachzubauen.

Einzelne Threads, die jeweils ihren eigenen Stack haben, ja. Aber nicht einzelne Funktionshappen, wo dann ständig zumindest der Stackframe der Funktion und einiges mehr an referenzierten Daten zwischen den verschiedenen Kernen und ihren Caches hin- und her- hoppeln müsste.

l'abra d'or schrieb:

pumuckl schrieb:

l'abra d'or schrieb:

Und eine wichtige Sache vergisst du komplett: Multiprozessorsysteme. Viel Spaß, wenn du selber versuchst, die einzelnen Funktionshappen auf mehrere Kerne zu verteilen, damit du wirklich parallele Abarbeitung erhältst

Warum um Gottes Willen sollte er das tun? damit er ganze Cache-Inhalte zwischen den Kernen hin- und herschaufeln lässt?

Weil es durchaus Betriebssysteme geben soll, die einzelne Threads auf verschiedene Kerne verteilen können. Ich wollte eigentlich nur darauf hinaus, dass es ziemlich aufwändig ist, die Effizienz von nativen Threads selber nachzubauen.

Einzelne Threads, die jeweils ihren eigenen Stack haben, ja. Aber nicht einzelne Funktionshappen, wo dann ständig zumindest der Stackframe der Funktion und einiges mehr an referenzierten Daten zwischen den verschiedenen Kernen und ihren Caches hin- und her- hoppeln müsste.

Das passiert bei fast jedem OS eigentlich "dauernd".
Aber natürlich nicht parallel, klar dass immer nur ein "Core" an einem logischen Thread nuckeln kann.