c++ - Brøkregning - Udvikleren.dk - Programmering, webdesign og grafik

Tags: c++

<< < 1 2 3 > >>

Bruger #15308 @ 01.11.09 00:05

Opgaven jeg er gået igang med, lyder således:

- create a class called fraction, and the following numbers are to be used in the program: in main() : 3,4,7 og 20

Programmets output har jeg så selv bestemt til følgende:

3/4 // (Det er den første brøk).
7/20 // (Det er den anden brøk).
21/80 // (De to brøker ganget sammen).
88/80 // (De to brøker, hvor der er fundet en fællesnævner).
11/10 // (Tællesnævneren er forkortet mest muligt).

_________________________________

Min kode er indtil videre:

Kode

#include <iostream>

using namespace std;

class fraction
{
	private:
		int Num_1;         // Numerator
		int Denom_1;       // Denominator
		int Num_2;         // Numerator
		int Denom_2;       // Denominator

};
   int main()

   {

   int Num_1 = 3, Denom_1 = 4;
   int Num_2 = 7, Denom_2= 20;
   int product = ((Num_1/Denom_1)*(Num_2/Denom_2));

    cout << Num_1 << "/" << Denom_1 << endl;
    cout << Num_2 << "/" << Denom_2 << endl;
    cout << product << endl;

    return 0;
   }

Mit problem opstår så når outputtet giver 0 når den skal gange de to brøker sammen. Hvorfor gør den det??? Er det fordi jeg også skal have "public" med hvor jeg har en multiply funktion??

26 svar postet i denne tråd vises herunder
2 indlæg har modtaget i alt 7 karma

Sorter efter stemmer Sorter efter dato

Bruger #4996 @ 02.11.09 20:05

196

Og et spørgsmål til omkring koden ovenover. Jeg er ikke lige helt med på hvad der sker i public, i class fration??

Der er tre linier:
Fraction(int num = 0, int denom = 0) : Num(num), Denom(denom) {}
Dette er en constructor, begge parametre er som default 0, den initialiserer objektet.

friend Fraction operator + (const Fraction& lhs, const Fraction& rhs);
friend std::ostream& operator << (std::ostream& os, const Fraction& fraction);

Dette er to operatorer, de erklæres "friends" for at de kan få adgang til class'ens private members.

Indlæg senest redigeret d. 02.11.2009 20:06 af Bruger #4996

Bruger #14645 @ 02.11.09 19:32

806

Umiddelbart gør koden kun det at den finder fællesnævneren, nemlig 88/80. Men som du nævner er det måske fordi + operatoren kun finder fællesnævneren. Har prøvet at google noget omkring reducering af brøk, men der kommer ikke noget brugbart frem. Findes der ikke en helt konkret funktion der tager sig af reducering.

Du finder den største fælles dividens (Greatest Common Divisor). Det er det største tal som går op i begge tal. Så reducerer du brøken med dette tal, dvs. dividerer både tæller og nævner med denne. På wikipedia kan du se Euclids fremgangsmåde som er nemt at implementere i kode: http://en.wikipedia.org/wiki/Greatest_common_divisor#Using_Euclid.27s_algorithm

Bruger #1151 @ 01.11.09 00:11

421

Fordi du bruger int, som er heltal. Prøv at lav det om til double i din fraction klasse.

Bruger #15308 @ 01.11.09 00:36

Ja selvfølgelig. Det havde jeg slet ikke tænkt over. Men nu får jeg resultatet i decimaltal dvs. 0.2625. Hvordan kan man få det i brøk dvs. som 21/80??

Bruger #4996 @ 01.11.09 01:10

196

Her er én måde at gøre det på:

Kode

#include <iostream>
using namespace std;

class Fraction
{
public:
   Fraction(int num = 0, int denom = 0) : Num(num), Denom(denom) {}
   friend Fraction operator + (const Fraction& lhs, const Fraction& rhs);
   friend std::ostream& operator << (std::ostream& os, const Fraction& fraction);
private:
   int Num;         // Numerator
   int Denom;       // Denominator
};

std::ostream& operator << (std::ostream& os, const Fraction& fraction)
{
   os << fraction.Num << "/" << fraction.Denom;
   return os;
}

Fraction operator + (const Fraction& lhs, const Fraction& rhs)
{
   Fraction t(rhs.Denom*lhs.Num + lhs.Denom*rhs.Num, lhs.Denom*rhs.Denom);
   return t;
}

int main()
{
   Fraction num1(1, 10);
   Fraction num2(2, 5);
   Fraction res = num1 + num2;
   std::cout << num1 << " + " << num2 << " = " << res << std::endl;
}

Jeg er ikke sikker på at + operatoren er matematisk korrekt, og den bør nok forsøge at reducere resultatet, til mindst mulige fællesnævner.

Bruger #15308 @ 02.11.09 15:03

Umiddelbart gør koden kun det at den finder fællesnævneren, nemlig 88/80. Men som du nævner er det måske fordi + operatoren kun finder fællesnævneren. Har prøvet at google noget omkring reducering af brøk, men der kommer ikke noget brugbart frem. Findes der ikke en helt konkret funktion der tager sig af reducering.

Og et spørgsmål til omkring koden ovenover. Jeg er ikke lige helt med på hvad der sker i public, i class fration??

Bruger #15308 @ 02.11.09 23:25

Ok. Jeg har lige læst linket, og mange tak for hjælpen.

Bertel nu er jeg med på hvad der sker i de tre linjer. Her er midt bud på en GCD, men der er stadigvæk noget galt:

Kode

#include <iostream>
using namespace std;

class Fraction
{
public:
   Fraction(int num = 0, int denom = 0) : Num(num), Denom(denom) {}
   friend Fraction operator * (const Fraction& lhs, const Fraction& rhs);
   friend Fraction operator + (const Fraction& lhs, const Fraction& rhs);
   friend std::ostream& operator << (std::ostream& os, const Fraction& fraction);

private:
   int Num;         // Numerator
   int Denom;       // Denominator
};

std::ostream& operator << (std::ostream& os, const Fraction& fraction)
{
   os << fraction.Num << "/" << fraction.Denom;
   return os;
}

Fraction operator * (const Fraction& lhs, const Fraction& rhs)
{
   Fraction t(rhs.Num*lhs.Num,lhs.Denom*rhs.Denom);
   return t;
}

Fraction operator + (const Fraction& lhs, const Fraction& rhs)
{
   Fraction t(rhs.Denom*lhs.Num + lhs.Denom*rhs.Num, lhs.Denom*rhs.Denom);
   return t;
}

int main()
{
   Fraction num1(3, 4);
   Fraction num2(7, 20);
   Fraction res_1 = num1 * num2;
   Fraction res_2 = num1 + num2;
   Fraction res_3 = num1 / num2;
   int dividend, divisor, remainder;

   cout << num1 << endl;
   cout << num2 << endl;
   std::cout << num1 << " * " << num2 << " = " << res_1 << std::endl;
   std::cout << num1 << " + " << num2 << " = " << res_2 << std::endl;

   if (num1 > num2)
   {
	   dividend = num1;
	   divisor = num2;
   }

   else
   {
	   dividend = num2;
	   divisor = num1;
   }

   do
   {
	   std::cout << dividend << " / " << divisor << " = " << res_3 << std::endl;
	   }
}

Bruger #4996 @ 02.11.09 23:52

196

Du mangler nogle operatorer for at din kode kan oversætte, du skal bruge en operator for / og >

Det give ikke rigtig mening at assigne en Fraction til en int.

Jeg forstår ikke rigtig hvad du vil vise med koden, måske fordi jeg ikke har studeret Euclids algorime.

Bruger #15308 @ 03.11.09 00:06

Ja kan godt se der er noget helt galt. Jeg har nu læst nærmere om GCD, og istedet lavet en gcd reduce funktion, men så ved jeg bare ikke hvad der skal stå som output (der hvor jeg har sat ???):

Kode

#include <iostream>

using namespace std;

class Fraction
{
public:
   Fraction(int num = 0, int denom = 0) : Num(num), Denom(denom) {}
   friend Fraction operator * (const Fraction& lhs, const Fraction& rhs);
   friend Fraction operator + (const Fraction& lhs, const Fraction& rhs);
   friend std::ostream& operator << (std::ostream& os, const Fraction& fraction);

private:
   int Num;         // Numerator
   int Denom;       // Denominator
};

std::ostream& operator << (std::ostream& os, const Fraction& fraction)
{
   os << fraction.Num << "/" << fraction.Denom;
   return os;
}

Fraction operator * (const Fraction& lhs, const Fraction& rhs)
{
   Fraction t(rhs.Num*lhs.Num,lhs.Denom*rhs.Denom);
   return t;
}

Fraction operator + (const Fraction& lhs, const Fraction& rhs)
{
   Fraction t(rhs.Denom*lhs.Num + lhs.Denom*rhs.Num, lhs.Denom*rhs.Denom);
   return t;
}

int gcd(int Num, int Denom)
{
    while (Num > 0)
    {
        if (Denom > Num)
        {
            int t = Num;
            Num = Denom;
            Denom = t;
        }

        Num -= Denom;
    }

    return Denom;
}

void reduce(int Num, int Denom, int *reduced_Num, int *reduced_Denom)
{
    int d = gcd(Num, Denom);

    *reduced_Num = Num / d;
    *reduced_Denom = Denom / d;

int main()
{
   int Num, Denom,reduced_Num, reduced_Denom;

   Fraction num1(3, 4);
   Fraction num2(7, 20);
   Fraction res_1 = num1 * num2;
   Fraction res_2 = num1 + num2;

   cout << num1 << endl;
   cout << num2 << endl;
   std::cout << num1 << " * " << num2 << " = " << res_1 << std::endl;
   std::cout << num1 << " + " << num2 << " = " << res_2 << std::endl;
   std::cout << Num << " / " << Denom << " = " << ????? << std::endl;
}

Bruger #4996 @ 03.11.09 00:33

196

Jeg har hacket noget sammen der ser ud til at virke, det er absolut mere grimt end godt er:

Kode

#include <iostream>

using namespace std;

class Fraction
{
public:
   Fraction(int num = 0, int denom = 0) : Num(num), Denom(denom) {}
   friend Fraction operator * (const Fraction& lhs, const Fraction& rhs);
   friend Fraction operator + (const Fraction& lhs, const Fraction& rhs);
   friend std::ostream& operator << (std::ostream& os, const Fraction& fraction);

// private:
   int Num;         // Numerator
   int Denom;       // Denominator
};

std::ostream& operator << (std::ostream& os, const Fraction& fraction)
{
   os << fraction.Num << "/" << fraction.Denom;
   return os;
}

Fraction operator * (const Fraction& lhs, const Fraction& rhs)
{
   Fraction t(rhs.Num*lhs.Num,lhs.Denom*rhs.Denom);
   return t;
}

Fraction operator + (const Fraction& lhs, const Fraction& rhs)
{
   Fraction t(rhs.Denom*lhs.Num + lhs.Denom*rhs.Num, lhs.Denom*rhs.Denom);
   return t;
}

int gcd(int Num, int Denom)
{
   while (Num > 0)
   {
      if (Denom > Num)
      {
         int t = Num;
         Num = Denom;
         Denom = t;
      }

      Num -= Denom;
   }

   return Denom;
}

void reduce(int Num, int Denom, int *reduced_Num, int *reduced_Denom)
{
    int d = gcd(Num, Denom);

    *reduced_Num = Num / d;
    *reduced_Denom = Denom / d;
}

int main()
{
   int Num, Denom;

   Fraction num1(3, 4);
   Fraction num2(7, 20);
   Fraction res_1 = num1 * num2;
   Fraction res_2 = num1 + num2;

   cout << num1 << endl;
   cout << num2 << endl;
   std::cout << num1 << " * " << num2 << " = " << res_1 << std::endl;
   std::cout << num1 << " + " << num2 << " = " << res_2 << std::endl;

   Num = res_2.Num;
   Denom  = res_2.Denom;
   Fraction reduced;
   reduce(Num, Denom, &reduced.Num, &reduced.Denom);

   std::cout << Num << " / " << Denom << " = " <<  reduced << std::endl;
}

Du bør lave gcd og reduce om til funktioner i classen, derved skulle du gerne kunne undgå den mærkelige kode i main. I C++ bruger man helst referecer i stedet for pointere, når det er muligt, det er det her.

<< < 1 2 3 > >>

Brøkregning

Karma barometer (30 dage)

Modtaget

Givet

Favorit hos
Forum tråde
Artikler