C++ 类(经典案例)

文章概述

本篇文章主要是通过两个经典案例熟悉运算符重载以及自己实现数组类;
初始化的时候可以用NULL,但是赋值的时候不可以的。

---

实现数组类

需求: a.能够设置数组的元素 b. 用一个对象初始化另一个对象 c.获取元素

//a.能够设置数组的元素  b. 用一个对象初始化另一个对象  c.获取元素
class Array
{
private:
    //表示的数组的首地址
    int* p;
    //表示数组最大存放元素的数量
    int length;
public:
    Array(int length)
    {
        if (length<0)
        {
            length = 0;
        }
        this->length = length;
        p = new int[this->length];
    }
    //a.能够设置数组的元素
    void setData(int index,int data)
    {
        p[index] = data;
    }
    //c.获取元素
    int getData(int index)
    {
        return p[index];
    }
    // b.用一个对象初始化另一个对象（由于存在指针变量所以用深拷贝）
    Array(const Array& obj)
    {
        this->length = obj.length;
        p = new int[this->length];
        for (int i=0;i<this->length;i++)
        {
            p[i] = obj.p[i];
        }
    }
    //获得数组元素的长度
    int GetLength()
    {
        return this->length;
    }
    ~Array()
    {
        if (p != NULL)
        {
            delete[]p;
        }
        this->length = 0;
    }
};

int main()
{
    Array arr(10);
    //设置元素
    for (int i=0;i<arr.GetLength();i++)
    {
        arr.setData(i,i);
    }
    //输出元素
    for (int i=0;i<arr.GetLength();i++)
    {
        cout << arr.getData(i) << endl;
    }
    cout << "使用arr初始化brr" << endl;
    //使用arr初始化brr
    Array brr = arr;
    for (int i = 0; i<brr.GetLength(); i++)
    {
        cout << brr.getData(i) << endl;
    }
    return 0;
}

---

对于数组Array重载运算符

需求: a. [] —->arr[0]=5; b.== !=; c.cout<

//a. []---->arr[0]=5;  b.== !=;  c.cout<<arr[0]<<endl; d.<<  >>
class Array
{
    //最好将std中的参数放在前面
    friend ostream& operator<<(ostream& out, Array& obj);
    friend istream& operator>>(istream& in, Array& obj);
private:
    //表示的数组的首地址
    int* p;
    //表示数组最大存放元素的数量
    int length;
public:
    Array(int length)
    {
        if (length<0)
        {
            length = 0;
        }
        this->length = length;
        p = new int[this->length];
    }
    //a.能够设置数组的元素
    void setData(int index,int data)
    {
        p[index] = data;
    }
    //c.获取元素
    int getData(int index)
    {
        return p[index];
    }
    // b.用一个对象初始化另一个对象（由于存在指针变量所以用深拷贝）
    Array(const Array& obj)
    {
        this->length = obj.length;
        p = new int[this->length];
        for (int i=0;i<this->length;i++)
        {
            p[i] = obj.p[i];
        }
    }
    //获得数组元素的长度
    int GetLength()
    {
        return this->length;
    }
    ~Array()
    {
        if (p != NULL)
        {
            delete[]p;
        }
        this->length = 0;
    }
    //1.需求:cout << arr[0];
    int& operator[](int index)
    {
        return p[index];
    }
    //operator==(Arry& obj)
    bool operator==(Array& obj)
    {
        if (this->length!=obj.GetLength())
        {
            return false;
        }
        for (int i=0;i<this->GetLength();i++)
        {
            if (this->p[i]!=obj[i])
            {
                return false;
            }
        }
        return true;
    }
    //operator!=(Arry& obj)
    bool operator!=(Array& obj)
    {
        if (this->operator==(obj))
        {
            return false;
        }
        return true;
    }

};

//operator<<(Array& obj, ostream& out)
ostream& operator<<(ostream& out,Array& obj)
{
    for (int i = 0; i<obj.GetLength(); i++)
    {
        out << obj.p[i] << endl;
    }
    return out;
}

istream& operator>>(istream& in, Array& obj)
{
    for (int i = 0; i<obj.GetLength(); i++)
    {
        in >> obj.p[i];
    }
    return in;
}

int main()
{
    Array arr(10);
    for (int i=0;i<arr.GetLength();i++)
    {
        //arr.setData(i,i);
        arr[i] = i;
    }
    //1.需求:cout << arr[0];  operator[](int index)
    cout << arr[2]<<endl ;
    //2.需求:arr[0]=10;（函数的返回值作为左值,应返回引用）修改上面1中的函数
    arr[0] = 10;
    cout << arr[0] << endl;
    //3.需求:b.== !=;  operator==(Arry& obj)
    Array brr(10);
    for (int i=0;i<brr.GetLength();i++)
    {
        brr[i] = i + 1;
    }
    if (arr == brr)
    {
        cout << "相等" << endl;
    }
    if (arr != brr)
    {
        cout << "不相等" << endl;
    }

    //我们可不可以直接输入或者输出Array对象
    Array crr(4);

    for (int i=0;i<crr.GetLength();i++)
    {
        crr[i] = i + 1;
    }
    //4.需求:cout << crr; cout.operator<<()
    cout << crr;
    //5.需求:cin >> crr; 
    cin >> crr;
    cout <<crr << endl;
    return 0;
}

---

实现MyString类

//字符串字面值本质就是字符组成的数组,末尾为空字符结尾
class MyString
{
    //字符串中字符的实际数目
    int number;
    char* p;
public:
    //创建一个空字符串
    MyString()
    {
        number = 0;
        //number+1为了存储最后一个空字符
        p = new char[number+1];
        strcpy_s(p, number + 1,"");
    }
    MyString(const char* obj)
    {
        if (obj==NULL)
        {
            number = 0;
            //number+1为了存储最后一个空字符
            p = new char[number + 1];
            strcpy_s(p, number + 1, "");
        }
        else
        {
            number = strlen(obj);
            //number+1为了存储最后一个空字符
            p = new char[number + 1];
            strcpy_s(p, number + 1,obj);
        }
    }
    //拷贝构造函数
    MyString(const MyString& obj)
    {
        number = obj.number;
        p = new char[number+1];
        strcpy_s(p,number+1,obj.p);
    }
};

int main()
{
    //1.无参数构造函数(创建空的字符串)
    MyString atr;
    //2.有参数构造函数
    MyString btr("abc");
    MyString ctr = NULL;
    //3.拷贝构造函数
    MyString dtr = btr;


    return 0;
}

---

对MyString类重载运算符

MyString类常用的运算符: << >> != == >< =，我们实现这些运算符重载。

//字符串字面值本质就是字符组成的数组,末尾为空字符结尾
class MyString
{
    friend ostream& operator<<(ostream&out,MyString& str);
    friend istream& operator>>(istream&in, MyString& str);
    //字符串中字符的实际数目
    int number;
    char* p;
public:
    //获得指针
    char* getP()
    {
        return p;
    }
    //常量指针不能通过指针修改指向的内存的值
    const char*getPconst()
    {
        return p;
    }
    //创建一个空字符串
    MyString(int len=0)
    {
        if (len=0)
        {
            number = 0;
            //number+1为了存储最后一个空字符
            p = new char[number + 1];
            strcpy_s(p, number + 1, "");
        }
        else
        {
            number = len;
            //number+1为了存储最后一个空字符
            p = new char[number + 1];
            memset(p,0,number);
        }
    }
    MyString(const char* obj)
    {
        if (obj==NULL)
        {
            number = 0;
            //number+1为了存储最后一个空字符
            p = new char[number + 1];
            strcpy_s(p, number + 1, "");
        }
        else
        {
            number = strlen(obj);
            //number+1为了存储最后一个空字符
            p = new char[number + 1];
            strcpy_s(p, number + 1,obj);
        }
    }
    //拷贝构造函数
    MyString(const MyString& obj)
    {
        number = obj.number;
        p = new char[number+1];
        strcpy_s(p,number+1,obj.p);
    }
    //重载=运算符 gtr ="abc";
    MyString& operator=(const char* obj)
    {
        //释放以前的内存
        if (p != NULL)
        {
            delete[]p;
            p = NULL;
        }
        //根据obj的长度开辟新的内存
        number = strlen(obj);
        p = new char[number + 1];
        //复制值
        strcpy_s(p, number + 1, obj);
        return *this;
    }
    //重载=运算符  gtr = etr;
    MyString& operator=(MyString& obj)
    {
        //释放以前的内存
        if (p != NULL)
        {
            delete[]p;
            p = NULL;
        }
        //根据obj的长度开辟新的内存
        number = strlen(obj.p);
        p = new char[number + 1];
        //复制值
        strcpy_s(p, number + 1, obj.p);
        return *this;
    }
    //重载[](下标)运算符 str[0] = '1';
    char& operator[](int index)
    {
        return p[index];
    }
    ~MyString()
    {
        if (p!=NULL)
        {
            delete[]p;
            number = 0;
            p = NULL;
        }
    }
    //重载== (etr=="sd")
    bool operator==(const char* str)
    {
        //判断字符数量
        if (number!=strlen(str))
        {
            return false;
        }
        return !strcmp(p,str);
    }
    //重载== (etr==str)
    bool operator==(const MyString& str)
    {
        //判断字符数量
        if (number != strlen(str.p))
        {
            return false;
        }
        return !strcmp(p, str.p);
    }
    //重载!= (etr=="sd")
    bool operator!=(const char* str)
    {
        return !operator==(str);
    }
    //重载!= (etr==str)
    bool operator!=(const MyString& str)
    {
        return !operator==(str);
    }
    //重载> (a>b)
    int operator>(const MyString& str)
    {
        //-1表示a<b  1表示a>b  0表示a=b
        return strcmp(p,str.p);
    }
    //重载> (a>b)
    int operator>(const char* str)
    {
        //-1表示a<b  1表示a>b  0表示a=b
        return strcmp(p, str);
    }
    //重载< (a<b)
    int operator<(const MyString& str)
    {
        return strcmp(str.p,p);
    }
    int operator<(const char* str)
    {
        return strcmp(str, p);
    }
};

//重载<<运算符
ostream& operator<<(ostream&out, MyString& str)
{
    out << str.p ;
    return out;
}

//重载>>运算符
istream& operator>>(istream&in, MyString& str)
{
    in >> str.p;
    return in;
}

int main()
{
    //1.无参数构造函数(创建空的字符串)
    MyString atr;
    //2.有参数构造函数
    MyString btr("abc");
    MyString ctr = NULL;
    //3.拷贝构造函数
    MyString dtr = btr;

    ////4.重载<<运算符
    MyString etr("efgh");
    cout << etr<<endl;      

    //5.重载=运算符
    MyString gtr;
    gtr = "abc";
    cout << gtr << endl;
    gtr = etr;
    cout << gtr << endl;

    //6.重载[](下标)运算符
    MyString str("2234");
    str[0] = '1';
    cout << str << endl;

    //7.重载==
    if (etr=="efgh")
    {
        cout << "相等" << endl;
    }
    else
    {
        cout << "不相等" << endl;
    }

    if (etr == str)
    {
        cout << "相等" << endl;
    }
    else
    {
        cout << "不相等" << endl;
    }
    //8.!=
    if (etr != "efgh")
    {
        cout << "不相等" << endl;
    }
    else
    {
        cout << "相等" << endl;
    }
    if (etr != str)
    {
        cout << "不相等" << endl;
    }
    else
    {
        cout << "相等" << endl;
    }
    //9. 重载大于 
    MyString a("abc");
    MyString b("adcs");
    int x = a > b;
    cout << x << endl;
    int x1 = a > "a";
    cout << x1 << endl;
    //10. 重载小于
    int y = a < b;
    cout << y << endl;
    int y1 = a < "a";
    cout << y1 << endl;
    //11. 默认参数 重载>>运算符
    MyString d(128);
    cin >> d;
    cout << d;

    return 0;
}