Hilfe in C

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Anzeige
    Hallo Leute brauche eure Hilfe bei einem C Programm.

    Hier ist der Code:
    #include <stdio.h>

    int primfaktor (int x);

    int primfaktor (int x){
    int p=2;
    while (x%p!=0){
    p++;}
    if (x == p){
    return 0;
    }
    while (x%p==0){
    x=x/p;
    while (x%p!=0){
    p++;}
    if (x == p){
    return 0;}
    if(x == p){
    break;}
    }}

    int main (){
    int pf;

    while ((pf= primfaktor(15)) > 1)
    printf("%d\n", pf);
    while ((pf= primfaktor(11))==1 )
    printf ("&d\n", pf);
    printf ("%d\n" , primfaktor(1));
    return 0;
    }

    Am Ende sollte die Primfaktorzerlegung ausgegeben werden untereinander also bei z.b 15 müsste
    3
    5
    -1 ausgegeben werden
    für die 11 einfach 11 ausgegeben werden
    und wenn eine Zahl<2 eingegeben wird soll -2 ausgegeben werden.
    Kann mir einer sagen wo mein Fehler liegt? Bei mir wird am Ende leider nichts ausgegeben
    >> Youtube <<
  • Au weia.

    Also erstmal täte es ungemein helfen, wenn du hier im Forum [code]-Tags verwenden würdest, und ganz besonders dir selbst würde es helfen, den Code zumindest ansatzweise lesbar zu formatieren. :D

    Also nochmal in schön. Ich gebe keine Lösung heraus, aber ich habe mal Kommentare an die Stellen geschrieben, die besonders problematisch sind - vielleicht hilft das ja schon:

    Quellcode

    1. #include <stdio.h>
    2. // Es wird nicht klar, was genau diese Funktion jetzt
    3. // eigentlich zurückgeben soll, und wann. Der einzige
    4. // definierte Wert, den sie jemals zurückliefert, ist 0.
    5. int primfaktor(int x) {
    6. int p = 2;
    7. // Für den Fall x < p ist das hier theoretisch eine
    8. // Endlosschleife. In der Praxis nicht, weil p irgendwann
    9. // überläuft und wenigstens den Wert von x annimmt, aber
    10. // das dauert eine Weile und ich kann mir nicht vorstellen,
    11. // dass das gewollt ist.
    12. while (x % p != 0)
    13. p++;
    14. if (x == p)
    15. return 0;
    16. while (x % p == 0) {
    17. x = x / p;
    18. while (x % p != 0)
    19. p++;
    20. if (x == p)
    21. return 0;
    22. // Das "break" wird niemals ausgeführt, weil die
    23. // Bedingung dieselbe ist wie die Return-Bedingung
    24. // drei Zeilen weiter oben.
    25. if (x == p)
    26. break;
    27. }
    28. // Die Funktion hat an dieser Stelle keinen definierten
    29. // Return-Wert, diese Code-Stelle ist aber durchaus erreichbar.
    30. // Einerseits durch die nicht immer wahre Bedingung der While-
    31. // Schleife, andererseits wird durch das "break" impliziert,
    32. // dass die While-Schleife verlassen werden kann - auch wenn das
    33. // "break" selbst nie erreicht wird.
    34. // Will heißen: Die Funktion kann und wird hier einfach etwas
    35. // zurückgeben, was gerade im richtigen Register oder an der
    36. // richtigen Stelle im Speicher steht.
    37. }
    38. int main() {
    39. int pf = 0;
    40. // Spätestens hier wird das Konzept der "primfaktor"-Funktion
    41. // ad absurdum geführt. Die Funktion hat keine Seiteneffekte,
    42. // sie liefert also - wenn man die Ausgabe denn definiert - für
    43. // einen Eingabewert IMMER dieselbe Ausgabe. Also: Falls das Ergebnis
    44. // von primfaktor(15) eine Zahl größer 1 ist, ist es IMMER größer
    45. // als 1 und die Schleife ist eine Endlosschleife. Wenn nicht, dann
    46. // wird der Code in der Schleife nie erreicht.
    47. while ((pf = primfaktor(15)) > 1)
    48. printf("%d\n", pf);
    49. // Hier gilt dasselbe.
    50. while ((pf = primfaktor(11)) == 1)
    51. printf("&d\n", pf);
    52. // Hier hat man wieder (fast) eine Endlosschleife, diesmal
    53. // aber innerhalb der primfaktor-Funktion, weil 1 < 2.
    54. printf("%d\n", primfaktor(1));
    55. return 0;
    56. }
    Alles anzeigen


    Paar Tips:
    - Lass dir von Compiler Warnungen ausgeben, oder, falls er das schon tut, beachte diese. Dadurch hätte sich zumindest das break-Problem von selbst erledigt.
    - Arbeite mit einem Debugger oder lasse dir zumindest die Werte von diversen Zwischenberechnungen mit printf ausgeben. Dann kannst du erkennen, wo das Programm etwas falsch macht oder einfach stehen bleibt.