Exigences:
1. Créez une classe de score. Les membres de la catégorie de fraction comprennent le numérateur et le dénominateur, et les opérations comprennent la réduction, la division, l'addition, la soustraction, la multiplication, la division, l'affectation de copie, le calcul réciproque, la comparaison, l'affichage et l'entrée;
2. 2. Les opérations d'ajout (+), de soustraction (-), de multiplication (*), de division (/), de comparaison (>,> =, <, <=), de copie d'assignation (=) sont implémentées par surcharge d'opérateur;
3. Exigences de la fonction: capable de traiter des opérations mixtes de données int, double, float et d'objets fractionnaires;
4．Le scénario de test couvre toutes les fonctions (y compris les calculs entre les scores et les calculs entre les scores et les données int, double et float), et il doit inclure le graphique des résultats en cours d'exécution, la description de l'objectif du test et l'analyse des résultats en cours d'exécution;
5. Le code est propre et standardisé
6. Attaché avec un diagramme des résultats en cours d'exécution, il explique et analyse
certaines questions connexes sur les cas de test, les objectifs des tests et les résultats en cours d'exécution :
1. Décrivez brièvement la différence entre les fonctions membres et les fonctions amis, et analysez les fonctions qui doivent être implémentées par fonctions membres et quelles fonctions nécessitent la réalisation de méta-fonctions UF;
①La fonction membre fait partie de la définition de classe et est appelée par un objet spécifique. Les fonctions membres peuvent accéder implicitement aux membres de l'objet appelant sans utiliser d'opérateurs membres. Les fonctions Friend ne font pas partie de la classe, elles sont donc appelées appels de fonction directs. Les fonctions Friend ne peuvent pas accéder implicitement aux membres de la classe, mais doivent utiliser des opérateurs membres pour les objets passés en tant que paramètres. En tant que fonction non membre de la classe, et lorsque les données auxquelles accéder est une fonction membre privée de l'objet, elle doit être déclarée en tant que fonction amie de la classe.
② Lorsqu'une fonction de surcharge d'opérateur est utilisée comme fonction membre d'une classe, il est nécessaire que le côté gauche de l'opérande soit un objet, et les paramètres de la fonction peuvent être des objets du même type ou des variables ordinaires.
③Parce que l'opérateur d'affectation de copie par défaut est une fonction membre, la fonction friend ne peut pas remplacer la fonction membre, de sorte que la surcharge d'opérateur de copie de copie (=) doit également être une fonction membre. Les quatre opérations arithmétiques des fractions et les opérations de comparaison peuvent utiliser soit des fonctions membres, soit des fonctions d'ami. Cependant, lorsque des opérations impliquant des objets fractionnaires et différents types de données sont impliquées, des fonctions d'ami doivent être utilisées.
2. Décrivez brièvement la différence entre le passage de valeur et la citation, et analysez les méthodes de passage de paramètre requises par différentes fonctions, et décrivez brièvement les raisons;
① L'appel de valeur transmet une copie de la variable, et les deux derniers appels passent la variable elle-même, alors passez Dans l'appel de valeur, seule la copie de la variable est modifiée, pas la variable elle-même. Au contraire, les deux derniers appels peuvent être utilisés lorsque la variable elle-même doit être modifiée.
②Lorsque la variable passée est grande, le résultat de l'appel par valeur est faible efficacité, car il passera par un processus de copie de type paramètre vers le paramètre réel, et les deux derniers appels seront plus efficaces car la variable elle-même est passée.
③La différence entre l'appel par référence et l'appel par pointeur est que le paramètre de référence doit pointer vers un objet et que le référent ne peut pas être modifié dans la fonction. Au contraire, il n'y a pas de problème de ce type dans l'appel par pointeur. Le pointeur peut être un pointeur nul qui ne pointe vers rien au début., Et peut pointer vers différents objets dans la fonction.
④Les quatre opérations arithmétiques et les opérations de comparaison du type fraction n'ont pas besoin de créer des variables temporaires, ce qui peut améliorer l'efficacité; et l'opération d'affectation de copie se présente sous la forme d'un transfert de valeur, qui n'affecte pas les paramètres réels;
Code C ++:
#include<iostream>
#include<cmath>
using namespace std;
class Fraction
{
double nume; //分子
double deno; //分母
public:
Fraction(double nume = 0, double deno = 1); //默认参数
void reduction(); //约分
void tongfen(Fraction& , Fraction& ); //通分
void display(); //显示分数
void input(); //输入分数
//重载四则运算符
friend Fraction operator +(Fraction& , Fraction&); //加法
friend Fraction operator -(Fraction& , Fraction&); //减法
friend Fraction operator *(Fraction& , Fraction&); //乘法
friend Fraction operator /(Fraction& , Fraction&); //除法
Fraction operator =(Fraction); //复制赋值
//重载比较操作符
friend bool operator > (Fraction&, Fraction&); //大于
friend bool operator >=(Fraction&, Fraction&); //大于等于
friend bool operator < (Fraction&, Fraction&); //小于
friend bool operator <=(Fraction&, Fraction&); //小于等于
};
Fraction::Fraction(double nu, double de)
{
nume = nu;
deno = de;
}
//输入
void Fraction::input()
{
char ch;
cin >> nume >> ch >> deno;
while (deno == 0)
{
cout << "分母不能为0，请重新输入：" << endl;
cin >> nume >> ch >> deno;
}
nume *= 1000; //处理小数，只能精确到后三位
deno *= 1000;
}
//显示
void Fraction::display()
{
reduction();
if (nume == 0)
cout << '0' << endl;
else if (deno == 1)
cout << nume << endl;
else
cout << nume << '/' << deno << endl;
}
//约分
void Fraction::reduction()
{
int m, n, r;
n = fabs(deno);
m = fabs(nume);
r = m % n;
while (r) // 求m，n的最大公约数
{
m = n;
n = r;
r = m % n;
}
deno /= n; // 化简
nume /= n;
if (deno < 0) // 将分母转化为正数
{
deno = -deno;
nume = -nume;
}
}
//通分
void Fraction::tongfen(Fraction& x,Fraction& y)
{
x.deno = (x.deno * y.deno);
x.nume = (x.nume * y.deno);
reduction();
cout << x.nume << '/' << x.deno << endl;
}
// 分数复制赋值
Fraction Fraction:: operator=(Fraction f)
{
Fraction temp;
temp.nume = f.nume;
temp.deno = f.deno;
nume = temp.nume;
deno = temp.deno;
return temp;
}
//加法
Fraction operator+(Fraction& x, Fraction& y)
{
Fraction temp;
temp.nume = x.nume * y.deno + x.deno * y.nume;
temp.deno = x.deno * y.deno;
return temp;
}
//减法
Fraction operator-(Fraction& x, Fraction& y)
{
Fraction temp;
temp.nume = x.nume * y.deno - x.deno * y.nume;
temp.deno = x.deno * y.deno;
return temp;
}
//乘法
Fraction operator*(Fraction& x, Fraction& y)
{
Fraction temp;
temp.nume = x.nume * y.nume;
temp.deno = x.deno * y.deno;
return temp;
}
//除法
Fraction operator/(Fraction& x, Fraction& y)
{
Fraction temp;
temp.nume = x.nume * y.deno;
temp.deno = x.deno * y.nume;
return temp;
}
//大于
bool operator >(Fraction& x, Fraction& y)
{
if (x.nume * y.deno - x.deno * y.nume > 0)
return true;
else
return false;
}
//大于等于
bool operator >=(Fraction& x, Fraction& y)
{
if (x.nume * y.deno - x.deno * y.nume >= 0)
return true;
else
return false;
}
//小于
bool operator <(Fraction& x, Fraction& y)
{
if (x.nume * y.deno - x.deno * y.nume < 0)
return true;
else
return false;
}
//小于等于
bool operator <=(Fraction& x, Fraction& y)
{
if (x.nume * y.deno - x.deno * y.nume <= 0)
return true;
else
return false;
}
//主函数
int main() {
Fraction x, y, s;
cout << "请输入x:" << endl;
x.input();
cout << "请输入y:" << endl;
y.input();
s = x + y;
cout << "x+y="; s.reduction(); s.display();
s = x - y;
cout << "x-y="; s.display();
s = x * y;
cout << "x*y="; s.display();
s = x / y;
cout << "x/y="; s.display();
s = x > y;
cout << "x>y的结果true为1，false为0："; s.display();
s = x >= y;
cout << "x>=y的结果true为1，false为0："; s.display();
s = x < y;
cout << "x<y的结果true为1，false为0："; s.display();
s = x <= y;
cout << "x<=y的结果true为1，false为0："; s.display();
cout << "x对y通分结果为："; x.tongfen(x, y);
s = x = y;
cout << "x=y="; s.display();
}
Résultats d'exploitation:
les méthodes actuelles sont insuffisantes et limitées:
1) J'ai été paresseux lors du traitement des données doubles et flottantes, directement multipliées par 1000, ce qui équivaut à une conversion en type int, donc il ne peut être calculé qu'à trois décimales; s'il est amélioré, vous pouvez entrer la forme de la chaîne, puis la convertir;
lorsqu'elle est affichée, le résultat de l'opération de comparaison n'est pas traité, seuls 0 et 1 sont affichés, pas convertis en vrai ou faux, ce qui est pratique pour la visualisation et la compréhension.