类与对象练习题（四）---Complex/String类

类与对象练习题（四）—Complex/String类

在刚开始学习c++的时候刷了很多基础题，这些基础题比较适合初学C++的码友，所以在学完就立即进行了整理，一是为了让初学C++的码友有所参考，二也是为了复习一下所学过知识。
但因为当时在整理时，时间有点紧促，可能会出现一些小错误，于是利用五一假期对之前的文章进行检查，修改了一些小错误，可能有些错误我还没有发现，欢迎码友们对其指正。

以下六道题要用到类与对象中的封装，友元函数等基础知识，适合初学类与对象这部分的码友进行练习。

Complex类01

定义一个复数类Complex，该类对象存放一个复数的实部和虚部。设计带有默认形参值的构造函数，实部虚部的默认值均为0；设计一个能够输出复数的Display成员函数（当虚部为0时仅输出实部；输出样式如：18.5、10+3i、10-3.5i、-5.8+9.5i、-4.5-9.6i等）。

//main函数如下(不得修改main函数)：
int main()
{
       double r1,i1;
       cin>>r1>>i1;
       Complex c1(r1,i1);
       c1.Display();
       return 0;
}

Sample Input
2.5 -3.8
Sample Output
2.5-3.8i

#include<iostream>
using namespace std;
class Complex
{
public:
    Complex(double r = 0, double i = 0);
    void Display();
private:
    double m_r;
    double m_i;
};
Complex::Complex(double r, double i)
{
    m_r = r;
    m_i = i;
}
void Complex::Display()
{
    if (m_r == 0&&m_i!=0)
        cout << m_i << "i" << endl;
    else if (m_i == 0)
        cout << m_r << endl;
    else if (m_i > 0)
        cout << m_r << "+" << m_i << "i" << endl;
    else
        cout << m_r << m_i << endl;
}
int main()
{
    double r1, i1;
    cin >> r1 >> i1;
    Complex c1(r1, i1);
    c1.Display();
    return 0;
}

Complex类02

定义一个复数类Complex，该类对象存放一个复数的实部和虚部。设计带有默认形参值的构造函数，实部虚部的默认值均为0；函数ComAdd实现复数加法运算（分别以成员函数方式、友元函数、普通函数方式实现）；设计一个能够输出复数的Display成员函数（当虚部为0时仅输出实部；输出样式如：18.5、10+3i、10-3.5i、-5.8+9.5i、-4.5-9.6i等）。

//类的定义如下：
class Complex
{
private:
       double real,imag;
public:
       Complex(double r=0,double i=0);
       void Display();
       const double GetReal()
       {
              return real;
       }
       const double GetImag()
       {
              return imag;
       }
       Complex ComAdd(const Complex &c); //复数加法运算1
      friend Complex ComAdd1(const Complex &c1,const Complex &c2);// 复数加法运算2
};
普通函数声明如下：
Complex ComAdd2(Complex &c1,Complex &c2); // 复数加法运算3
 
main函数如下(不得修改main函数)：
int main()
{
       double r1,i1,r2,i2;
       cin>>r1>>i1;
       cin>>r2>>i2;
       Complex c1(r1,i1),c2(r2,i2),c3;
 
       c1.Display();
       c2.Display();
       c3=c1.ComAdd(c2); //成员函数实现复数加法运算方式1
       c3.Display();
 
       c3=ComAdd1(c1,c2); //友元函数实现复数加法运算方式2
       c3.Display();
 
    c3=ComAdd2(c1,c2);   //普通函数实现复数加法运算方式3
       c3.Display();
return 0;
}

Sample Input
3 -5.5 6 3
Sample Output
3-5.5i
6+3i
9-2.5i
9-2.5i
9-2.5i

#include<iostream>
using namespace std;
class Complex
{
private:
    double real, imag;
public:
    Complex(double r = 0, double i = 0);
    void Display();
    const double GetReal()
    {
        return real;
    }
    const double GetImag()
    {
        return imag;
    }
    Complex ComAdd(const Complex& c); //复数加法运算1
    friend Complex ComAdd1(const Complex& c1, const Complex& c2);// 复数加法运算2
};
Complex::Complex(double r , double i)
{
    real = r;
    imag = i;
}
void Complex::Display()
{
    if (real == 0)
    {
        cout << imag << "i" << endl;
    }
    else if (imag == 0)
    {
        cout << real << endl;
    }
    else if (imag > 0)
    {
        cout << real << "+" << imag << "i" << endl;
    }
    else
    {
        cout << real << imag << "i" << endl;
    }
}
Complex Complex::ComAdd(const Complex& c)
{
    return Complex(real + c.real, imag + c.imag);
}
Complex ComAdd1(const Complex& c1, const Complex& c2)
{
    return Complex(c1.real + c2.real, c1.imag + c2.imag);
}
Complex ComAdd2(Complex& c1, Complex& c2)
{
    return Complex(c1.GetReal() + c2.GetReal(), c1.GetImag() + c2.GetImag());
}
int main()
{
    double r1, i1, r2, i2;
    cin >> r1 >> i1;
    cin >> r2 >> i2;
    Complex c1(r1, i1), c2(r2, i2), c3;
    c1.Display();
    c2.Display();
    c3 = c1.ComAdd(c2); //成员函数实现复数加法运算方式1
    c3.Display();
    c3 = ComAdd1(c1, c2); //友元函数实现复数加法运算方式2
    c3.Display();
    c3 = ComAdd2(c1, c2);   //普通函数实现复数加法运算方式3
    c3.Display();
return 0;
}

Complex类03

定义一个复数类Complex，该类对象存放一个复数的实部和虚部。设计带有默认形参值的构造函数，实部虚部的默认值均为0；设计一个Set函数，能够重新设计复数的实部与虚部值；设计一个能够输出复数的Display成员函数,输出格式为Complex(x,y)。

//main函数如下(不得修改main函数)：
int main()
{
       double r1,i1,r2,i2;
       cin>>r1>>i1;
       cin>>r2>>i2;
       Complex c1(r1,i1);
       Complex c2;
       c1.Display();
       c2.Display();
       c2.Set(r2,i2);
       c2.Display();
       return 0;
}

Sample Input
-5 0 10 -9
Sample Output
Complex(-5,0)
Complex(0,0)
Complex(10,-9)

#include<iostream>
using namespace std;
class Complex
{
public:
    Complex(double r = 0, double i = 0);
    void Set(double r, double i);
    void Display();
private:
    double m_r;
    double m_i;
};
Complex::Complex(double r, double i)
{
    m_r = r;
    m_i = i;
}
void Complex::Set(double r, double i)
{
    m_r = r;
    m_i = i;
}
void Complex::Display()
{
    cout << "Complex(" << m_r << "," << m_i << ")" << endl;
}
int main()
{
    double r1, i1, r2, i2;
    cin >> r1 >> i1;
    cin >> r2 >> i2;
    Complex c1(r1, i1);
    Complex c2;
    c1.Display();
    c2.Display();
    c2.Set(r2, i2);
    c2.Display();
    return 0;
}

Complex类04

编写复数类，分别利用成员函数、友元函数、普通函数实现复数加法运算。已知main中代码如下，请勿修改。请补充实现类的定义及相关函数实现。提示：Display输出函数的输出格式：Complex(1.5,2.3)，构造函数需要提供默认值0,0

int main()
{
       double r1,i1,r2,i2;
       cin>>r1>>i1;
       cin>>r2>>i2;
       Complex c1(r1,i1);
       Complex c2(r2,i2);
  cout<<"C1:";
       c1.Display();
  cout<<"C2:";
       c2.Display();
       Complex c3;
  //member func.
  c3=c1.ComAdd1(c2);
  cout<<"Member:";
  c3.Display();

  //friend func.
  cout<<"Friend:";
  c3=ComAdd2(c1,c2);
  c3.Display();

  //general func.
  c3=ComAdd3(c1,c2);
  cout<<"General:";
  c3.Display();
       return 0;
}

Sample Input
1 2 3.3 -2
Sample Output
C1:Complex(1,2)
C2:Complex(3.3,-2)
Member:Complex(4.3,0)
Friend:Complex(4.3,0)
General:Complex(4.3,0)

#include<iostream>
using namespace std;
class Complex
{
public:
    Complex(double r=0, double i=0);
    void Display();
    Complex ComAdd1(Complex &C);
    friend Complex ComAdd2(Complex &C1,Complex &C2); 
    double GetR();
    double GetI();
private:
    double m_r;
    double m_i;
};
Complex::Complex(double r, double i)
{
    m_r = r;
    m_i = i;
}
void Complex::Display()
{
    cout << "Complex(" << m_r << "," << m_i << ")" << endl;
}
Complex Complex::ComAdd1(Complex& C)
{
    return Complex(m_r + C.m_r, m_i + C.m_i);
}
Complex ComAdd2(Complex& C1, Complex& C2)
{
    return Complex(C1.m_r + C2.m_r, C1.m_i + C2.m_i);
}
double Complex::GetR()
{
    return m_r;
}
double Complex::GetI()
{
    return m_i;
}
Complex ComAdd3(Complex& C1, Complex& C2)
{
    return Complex(C1.GetR() + C2.GetR(), C1.GetI() + C2.GetI());
}
int main()
{
    double r1, i1, r2, i2;
    cin >> r1 >> i1;
    cin >> r2 >> i2;
    Complex c1(r1, i1);
    Complex c2(r2, i2);
    cout << "C1:";
    c1.Display();
    cout << "C2:";
    c2.Display();
    Complex c3;
    //member func.
    c3 = c1.ComAdd1(c2);
    cout << "Member:";
    c3.Display();

    //friend func.
    cout << "Friend:";
    c3 = ComAdd2(c1, c2);
    c3.Display();

    //general func.
    c3 = ComAdd3(c1, c2);
    cout << "General:";
    c3.Display();
    return 0;
}

String类01

定义一个CString类，数据成员包括私有数据成员：char *str;成员函数包括构造函数CString（用于实现对数据成员初始化），成员函数Display（用于输出串信息），求串长函数，拷贝构造函数（利用已知对象创建新对象）。编写主函数，定义对象S1，输出对象信息和串长信息；再利用拷贝构造函数创建对象S2，输出对象S2的信息。
输入数据为串信息，利用构造函数传递给数据成员str。
Sample Input
China
Sample Output
China
5
China

#include<iostream>
#include<cstring>
using namespace std;
class Cstring
{
public:
	Cstring(char *s);
	void Display();
	int strlen();
	void copy(Cstring& S);
private:
	char* str;
};
Cstring::Cstring(char *s)
{
	int i = 0;
	while (s[i])
		i++;
	str = new char[i + 1];
	strcpy(str, s);
}
void Cstring::Display()
{
	cout << str << endl;
}
int Cstring::strlen()
{
	int i = 0;
	while (str[i])
		i++;
	return i;
}
void Cstring::copy(Cstring& S)
{
	str = new char[S.strlen() + 1];
	strcpy(str, S.str);
}
int main()
{
	char s[20];
	cin >> s;
	Cstring S1(s);
	S1.Display();
	cout << S1.strlen() << endl;
	Cstring S2 = S1;
	S2.Display();
	return 0;
}

String类02

定义一个CString类，数据成员包括私有数据成员：char *str;成员函数包括构造函数CString（用于实现对数据成员初始化），成员函数Display（用于输出串信息），串比较函数(返回第一个不同字符的ACSII码差值)，串连接函数和串拷贝函数。主函数如下（勿改动），依次测试上述成员函数。

int main()
{    
       char str1[81],str2[81];
       cin>>str1>>str2;
       CString s1(str1);
       s1.Display();
       CString s2(str2);
       s2.Display();
       cout<<s2.MyStrcmp(s1)<<endl;
       s2.MyStrcpy(s1);
       s2.Display();
       s2.MyStrcat(s1);
       s2.Display();
}

Sample Input
China Chinese
Sample Output
China
Chinese
4
China
ChinaChina

#include<iostream>
#include<cstring>
using namespace std;
class CString
{
public:
    CString(char* S);
    void Display();
    int MyStrcmp(CString& S);
    void MyStrcat(CString& S);
    void MyStrcpy(CString& S);
private:
    char* str;
};
CString::CString(char* S)
{
    int len = strlen(S);
    str = new char[len + 1];
    strcpy(str, S);
}
void CString::Display()
{
    cout << str << endl;
}
int CString::MyStrcmp(CString& S)
{
    int len1 = strlen(str);
    int len2 = strlen(S.str);
    int max = len1;
    if (len2 > max)
    {
        max = len2;
    }
    int i;
    for (i = 0; i < max; i++)
    {
        if (str[i] != S.str[i])
        {
            break;
        }
    }
    return str[i] - S.str[i];
}
void CString::MyStrcat(CString& S)
{
    int i, j;
    int len1 = strlen(str);
    int len2 = strlen(S.str);
    for (i = len1, j = 0; i < len1 + len2, j < len2; i++, j++)
    {
        str[i] = S.str[j];
    }
    str[len1 + len2] = '\0';
}
void CString::MyStrcpy(CString& S)
{
    int len = strlen(S.str);
    str = new char[len + 1];
    strcpy(str, S.str);
}
int main()
{
    char str1[81], str2[81];
    cin >> str1 >> str2;
    CString s1(str1);
    s1.Display();
    CString s2(str2);
    s2.Display();
    cout << s2.MyStrcmp(s1) << endl;
    s2.MyStrcpy(s1);
    s2.Display();
    s2.MyStrcat(s1);
    s2.Display();
}

大家好，我是Lucky_追梦仔。一个正在学习编程的小白，希望我的博文，可以帮助到您学习，或者解决您遇到的问题。