Was ist der Unterschied zwischen c beide Texte



  • @sami12 Zwischen einer for und while Schleife gibt es in C eigentlich keinen Unterschied.

    (Seit C99 kannst du bei der for-Schleife den Scope (Sichtbarkeit) der Laufvariablen auf die Schleife begrenzen)

    Daher gibt es die Konvention, dass man die for-Schleife nimmt, wenn man die Anzahl der Durchläufe vor Schleifenbeginn kennt.
    Z.B. die Anzahl Elemente in einem Array.

    Die while-Schleife nimmt man, wenn die Abbruchbedingung erst in der Schleife selber ermittelt wird.
    Z.B. Stringende, Genauigkeit einer Berechnung ist erreicht, Benutzereingabe.

    Dieser Konvention muss man aber nicht folgen.



  • @DirkB sagte in Was ist der Unterschied zwischen c beide Texte:

    Daher gibt es die Konvention, dass man die for-Schleife nimmt, wenn man die Anzahl der Durchläufe vor Schleifenbeginn kennt.

    Worauf bezieht sich dieses "Daher"? Macht überhaupt keinen Sinn. Ob ich eine while- oder eine for- schleife nehme hat null, nix, gaga, niente damit zu tun ob die Abbruchbedingung konstant ist oder nicht.



  • @john-0 sagte in Was ist der Unterschied zwischen c beide Texte:

    C krankt ohnehin an der Problematik, dass man verschachtelte for-Schleifen nur mit goto verlassen kann.

    mal unabhängig davon, dass man bei sauberer programmierung auch wirklich ohne goto auskommt, ist es ja grundsätzlich auch kein problem, in solchen fällen goto zu benutzen.

    aber ich hab hier irgendwann mal ein einfaches programm mit goto als negativbeispiel gepostet (guck zur not halt mal im verlauf oder benutz die suche. schade, dass ich keinen eyetracker habe......) und die anweisung, kein goto zu verwenden, hat eben den zweck, genau solche programmierstile zu vermeiden.



  • @DirkB du hast total Recht Dirk.



  • ich komme nicht weiter, ich lernen gerade c, und kenne diese Sachen noch nicht



  • welche sachen?



  • @Swordfish sagte in Was ist der Unterschied zwischen c beide Texte:

    In der Originalfassung des Posts sind die ersten beiden Beispiele sicher keine "Negativbeispiele" in C++ gewesen und auch jetzt sind sie keine "Negativbeispiele" in C.

    Dein Posting enthält noch immer C++ Code. Wie wäre es einfach mal Rücksicht zu nehmen auf den Empfänger der Nachricht (einen Anfänger in C) zu nehmen, und die korrekte Verwendung der drei Schleifen zu zeigen, und eben nicht die Äquivalenz der drei Schleifenkonstrukte (eine Trivialität für jeden erfahrenen Programmierer) zu zeigen, und damit eher noch mehr Verwirrung als Klarheit zu schaffen. Meinst Du ernsthaft dies sei hilfreich?



  • @john-0 sagte in Was ist der Unterschied zwischen c beide Texte:

    Dein Posting enthält noch immer C++ Code.

    Ja, 1 (in Worten: eine) Zeile.

    @john-0 sagte in Was ist der Unterschied zwischen c beide Texte:

    Meinst Du ernsthaft dies sei hilfreich?

    Lass das doch bitte den Adressaten entscheiden!?

    Da der OP gefragt hat wie zwei Aussagen einzuordnen sind ist es wohl nur logisch daß man eben auf diese eingeht und ggf. wie hier zeigt das sie quatsch sind.

    Alter, mt verlaub, wenn ich mit Dir zusammenarbeiten müsste, ich würde mir die Kugel geben. Dein einziger Beitrag in diesem Thread besteht darin rumzumotzen, wie fast in jedem Thread an dem Du Dich beteiligst.



  • @Wade1234 sagte in Was ist der Unterschied zwischen c beide Texte:

    mal unabhängig davon, dass man bei sauberer programmierung auch wirklich ohne goto auskommt, ist es ja grundsätzlich auch kein problem, in solchen fällen goto zu benutzen.

    In C? Da wirst Du ein Problem mit dem Error Handling haben. Das Problem der verschachtelten Schleifen lässt sich wie gesagt nur mit goto lösen, oder in dem man den Code so umorganisiert, dass man andere Probleme bekommt, weil man Dinge aus dem Kontext reißt.



  • @john-0 Zeig ein Beispiel wo Du meinst goto zu brauchen und ich zeige Dir wie es ohne geht ^^



  • @john-0 genau john, ich lasse diese Frage.



  • @sami12 sagte in Was ist der Unterschied zwischen c beide Texte:

    ich komme nicht weiter, ich lernen gerade c, und kenne diese Sachen noch nicht

    Es wäre Dir vielleicht hilfreich zu verraten, wo genau Deine Verständnisprobleme liegen.



  • @john-0

    enum
    {
         //Rückgabewerte
    }
    
    //Funktionsprototypen
    //XFunktion1: Funktion mit Anweisungen, die VOR der Schleife X ausgeführt werden müssen
    //XFunktion2: Funktion mit Anweisungen, die NACH der Schleife X ausgeführt werden müssen
    
    int MeineFunktionMit10Schleifen()
    {
         int i;
         int j;
         int k;
         int l;
         int m;
         int n;
         int o;
         int p;
         int q;
         int r;
    
         int returncode;
    
         returncode = IFunktion1();
         if(returncode == IFUNKTION1_FEHLER)
         {
         return IFUNKTION1_FEHLER;
         }
    
         for(i = 0; i < 10; i++)
         {
              returncode = JFunktion1();
              if(returncode == JFUNKTION1_FEHLER)
              {
              return JFUNKTION1_FEHLER;
              }
    
              for(j = 0; j < 10; j++)
              {
                   returncode = KFunktion1();
                   if(returncode == KFUNKTION1_FEHLER)
                   {
                        return KFUNKTION1_FEHLER;
                   }
    
                   for(k = 0; k < 10; k++)
                   {
                        returncode = LFunktion1();
                        if(returncode == LFUNKTION1_FEHLER)
                        {
                             return LFUNKTION1_FEHLER;
                        }
    
                        for(l = 0; l < 10; l++)
                        {
                             returncode = MFunktion1();
                             if(returncode == MFUNKTION1_FEHLER)
                             {
                                  return MFUNKTION1_FEHLER;
                             }
    
                             for(m = 0; m < 10; m++)
                             {
                                  returncode = NFunktion1();
                                  if(returncode == NFUNKTION1_FEHLER)
                                  {
                                       return NFUNKTION1_FEHLER;
                                  }
    
                                  for(n = 0; n < 10; n++)
                                  {
                                       returncode = OFunktion1();
                                       if(returncode == OFUNKTION1_FEHLER)
                                       {
                                            return OFUNKTION1_FEHLER;
                                       }
    
                                       for(o = 0; o < 10; o++)
                                       {
                                            returncode = PFunktion1();
                                            if(returncode == PFUNKTION1_FEHLER)
                                            {
                                                 return PFUNKTION1_FEHLER;
                                            }
    
                                            for(p = 0; p < 10; p++)
                                            {
                                                 returncode = QFunktion1();
                                                 if(returncode == QFUNKTION1_FEHLER)
                                                 {
                                                      return QFUNKTION1_FEHLER;
                                                 }
    
                                                 for(q = 0; q < 10; q++)
                                                 {
                                                      returncode = RFunktion1();
                                                      if(returncode == RFUNKTION1_FEHLER)
                                                      {
                                                           return RFUNKTION1_FEHLER;
                                                      }
    
                                                      for(r = 0; r < 10; r++)
                                                      {
                                                           returncode = RFunktionIn();
                                                           if(returncode == RFUNKTIONIN_FEHLER)
                                                           {
                                                                return RFUNKTIONI_FEHLER;
                                                           }
                                                      }
    
                                                      returncode = RFunktion2();
                                                      if(returncode == RFUNKTION2_FEHLER)
                                                      {
                                                           return RFUNKTION2_FEHLER;
                                                      }
                                                 }
    
                                                 returncode = QFunktion2();
                                                 if(returncode == QFUNKTION2_FEHLER)
                                                 {
                                                      return QFUNKTION2_FEHLER;
                                                 }
                                            }
    
                                            returncode = PFunktion2();
                                            if(returncode == PFUNKTION2_FEHLER)
                                            {
                                                 return PFUNKTION2_FEHLER;
                                            }
                                       }
    
                                       returncode = OFunktion2();
                                       if(returncode == OFUNKTION2_FEHLER)
                                       {
                                            return OFUNKTION2_FEHLER;
                                       }
                                  }
    
                                  returncode = NFunktion2();
                                  if(returncode == NFUNKTION2_FEHLER)
                                  {
                                       return NFUNKTION2_FEHLER;
                                  }
                             }
    
                             returncode = MFunktion2();
                             if(returncode == MFUNKTION2_FEHLER)
                             {
                                  return MFUNKTION2_FEHLER;
                             }
                        }
    
                        returncode = LFunktion2();
                        if(returncode == LFUNKTION2_FEHLER)
                        {
                             return LFUNKTION2_FEHLER;
                        }
                   }
    
                   returncode = KFunktion2();
                   if(returncode == KFUNKTION2_FEHLER)
                   {
                        return KFUNKTION2_FEHLER;
                   }
              }
    
              returncode = JFunktion2();
              if(returncode == JFUNKTION2_FEHLER)
              {
                   return JFUNKTION2_FEHLER;
              }
         }
    
         returncode = IFunktion2();
         if(returncode == IFUNKTION2_FEHLER)
         {
              return IFUNKTION2_FEHLER;
         }
    
         return MEINEFUNKTIONMIT10SCHLEIFEN_ERFOLG;
    }
    
    //Funktionsrümpfe
    

    Zugegeben: es ist auch ein wenig unübersichtlich, aber 10 ineinander verschachtelte Schleifen sind auch schon ziemlich extrem. Allerdings kann man am Rückgabewert der Hauptfunktion genau erkennen, wo der Fehler aufgetreten ist. Alternativ könnte man auch sowas machen:

    int MeineFunktionMit10Schleifen()
    {
         int returncode;
    
         returncode = ISchleife();
    
         return returncode;
    }
    
    int ISchleife()
    {
         int i;
    
         int returncode;
    
         //
         //Code, der vor der Schleife ausgeführt werden muss
         //
    
         for(i = 0; i < 10; i++)
         {
              returncode = JSchleife();
              if(returncode != JSCHLEIFE_ERFOLG)
              {
                   break;
              }
         }
    
         //
         //Code der nach der Schleife ausgeführt werden muss
         //
    
         return returncode;
    }
    
    //JSchleife, KSchleife etc analog
    

    beides kommt jedenfalls ohne goto aus.😉



  • @Wade1234 Das erste Snippet ist aber nicht Dein toter Ernst!? Ab spätestens 5 indentation levels in einer Funktion gilt man sogar in C als verrückt.



  • @Swordfish
    naja beim ersten kannst du relativ unkompliziert sehen, wie tief es runter geht und es sind weniger als 200 zeilen. der eigentliche code ist ja in unterfunktionen ausgelagert.



  • @Wade1234 sagte in Was ist der Unterschied zwischen c beide Texte:

    der eigentliche code ist ja in unterfunktionen ausgelagert.

    Ach so. Na dann ist ja gut. 👍🏻



  • aber mir fällt grad auf, dass im zweiten programm statt der break-anweisung auch direkt den returncode zurückgeben könnte. wäre vielleicht besser.



  • @Wade1234 Si Señor! (Aber da kommen dann wieder die Verfechter des single point of return angerannt ...)

    void foo(void) { /* ... */ };
    void bar(void) { /* ... */ };
    void qux(void)
    {
        foo();
    
        bool exit = false;  // bloeder name, ja. demonstration purpose only.
        for (/* ... */; !exit && /* ... */; /* ... */) {
            for (/* ... */; !exit && /* ... */; /* ... */) {
                if (/* something */) {
                    exit = true;
                    continue;
                }
            }
        }
    
        bar();
    }
    


  • @Swordfish sagte in Was ist der Unterschied zwischen c beide Texte:

    @Wade1234 Si Señor! (Aber da kommen dann wieder die Verfechter des single point of return angerannt ...)

    aber dann müsste ich nach der schleife wieder unterscheiden, ob da ein fehler aufgetreten ist, oder nicht, und deshalb der reguläre nach der schleife auszuführende code ausgeführt werden soll, oder nicht, und das wäre irgendwie "doof"......



  • @Wade1234 sagte in Was ist der Unterschied zwischen c beide Texte:

    das wäre irgendwie "doof"......

    weil ... ?


Anmelden zum Antworten