Bruchrechnung mit Kürzen und Vorzeichentausch

Hallo Foren-Gemeinde

wir sollen laut Aufgabe von unserem Prof, eine Funktion schreiben die das addieren von Brüchen in rational, mit Kürzen und Vorzeichen=Zähler übernimmt. Die Funktion soll call-by value deklariert werden. Zeiger und Überladen wurden noch nicht behandelt.

Ich habe es bis jetzt geschafft die Funktion add() zum laufen zu bringen, nur habe ich ein Problem bei der Funktion kuerzen(), sie soll den errechneten Zähler und Nenner kürzen und Prüfen ob der Nenner negativ ist...sollte dies der Fall sein dann natürlich negativer Zähler.

Die Funktion soll ihre Ergebnis auf eine sinnvolle Weise zurückgeben, sodass die Funktion add() diese dann erhält und über cout als "zähler/nenner" normalisiert ausgeben könnte.

Ich hoffe ihr versteht mein Problem, bislang fehlt mir die Möglichkeit der Integration der Resultate von kuerzen() nach add().

rational.h

#ifndef RATIONAL_H
#define RATIONAL_H

struct rational{
	long int numerator;
	long int denumerator;
};

int ggt(int zaehler, int nenner);
void kuerzen(int zaehler, int nenner);
void add(rational bruch1, rational bruch2);

#endif RATIONAL_H

rational.cpp

#include "rational.h"
#include <iostream>

using namespace std;

void add(rational bruch1, rational bruch2)
{

	rational bruch;
	bruch.numerator = bruch1.numerator*bruch2.denumerator + bruch2.numerator*bruch1.denumerator;
	bruch.denumerator = bruch1.denumerator*bruch2.denumerator;

	kuerzen(bruch.numerator,bruch.denumerator);

}

int kuerzen(int zaehler, int nenner)
{
 int g = ggt(zaehler, nenner);

 if (nenner < 0)
 {
	 nenner = -nenner;
	 zaehler = -zaehler;
 }
 if (g>1)
 {
	zaehler /= g;
	nenner /= g;
 }
}

int ggt(int zaehler, int nenner)
{
	if(nenner == 0)
  {
   return zaehler;
  }

  return ggt(nenner, zaehler%nenner);
}

unskilled

Ich habe es bis jetzt geschafft die Funktion add() zum laufen zu bringen

ach echt, was macht sie denn? abgesehen vom compilieren ohne fehler?

stimmt zwar an und für sich, was dort steht, aber wenn ich einfach nur in ein programm a+b; schreibe, stimmt das auch und bringt genau so wenig.
(kleiner tipp: beschreibe mal, was die fkt machen soll und achte mal auf deinen letzten satz.

dann:

//header:
void kuerzen(int zaehler, int nenner);

//source:
int kuerzen(int zaehler, int nenner)
{ /* ... */ }

beides ist falsch.

tipp:

struct struct rational{
    long int numerator;
    long int denumerator;
};

int ggt(int zaehler, int nenner); //also entweder, du kannst hier 2 x-beliebige werte übergeben und nennst sie nicht gleich zaehler und nenner, oder du übergibst einen bruch.

void kuerzen(int zaehler, int nenner); //meines erachtens definitiv eine member-funktion!

void add(rational bruch1, rational bruch2);

int kuerzen(int zaehler, int nenner)
{
 int g = ggt(zaehler, nenner);

 if (nenner < 0)
 {
     nenner = -nenner;
     zaehler = -zaehler;
 }
 if (g>1)
 {
    zaehler /= g;
    nenner /= g;
 }
}

welcher compiler lässt das denn durchgehen? ich nehme mal an DevC++?! Aber egal, definitiv compiler wechseln, wenn so etwas compiliert wird!

bb

pumuckl

unskilled schrieb:

welcher compiler lässt das denn durchgehen?

gcc zum Beispiel, der schmeißt nur ne Warnung...

Syrtox

dann:
//header:
void kuerzen(int zaehler, int nenner);

//source:
int kuerzen(int zaehler, int nenner)
{ /* ... */ }
ist mir auch klar...kann durch öfteres ändern passieren....

tipp:
struct struct rational{
    long int numerator;
    long int denumerator;
};

int ggt(int zaehler, int nenner); //also entweder, du kannst hier 2 x-beliebige werte übergeben und nennst sie nicht gleich zaehler und nenner, oder du übergibst einen bruch.

void kuerzen(int zaehler, int nenner); //meines erachtens definitiv eine member-funktion!

void add(rational bruch1, rational bruch2);
welcher compiler lässt das denn durchgehen? ich nehme mal an DevC++?! Aber egal, definitiv compiler wechseln, wenn so etwas compiliert wird!

VisualStudio 2010 Prof.

bb

Was soll die Funktion machen....addieren der beiden Brüche.... die Funktion add() lief vorher auf umständlicher Weise, jedoch wollte ich nun über eine Funktion das Kürzen und die Vorzeichenprüfung übernehmen lassen.

Nur die Implementierung in add ist mir noch suspect, weil ich nicht weis, wie ich die geprüften und gekürzten Werte in add aufgreifen soll

wxSkip

Lass kuerzen() doch einfach einen rational zurückgeben...

Syrtox

wxSkip schrieb:

Lass kuerzen() doch einfach einen rational zurückgeben...

Aber bei call-by-value kann ich doch nichts über return zurück geben oder soll nun kuerzen() doch nun Typ int sein?

Hast du ein Beispiel...stehe wirklich auf dem Schlauch.

wxSkip

Syrtox schrieb:

wxSkip schrieb:

Lass kuerzen() doch einfach einen rational zurückgeben...

Aber bei call-by-value kann ich doch nichts über return zurück geben oder soll nun kuerzen() doch nun Typ int sein?

Hast du ein Beispiel...stehe wirklich auf dem Schlauch.

Weißt du, was Rückgabe heißt? Nimm einfach

rational kuerzen(rational ungekuerzter_bruch);
rational add(rational lhs, rational rhs)
{
    rational result;
    //... Werte addieren
    return kuerzen(result);
}

Syrtox

Habe es hinbekommen...closed