首页 > > 程序设计 > C/C++ >

c++-重载等号，数组，指针，字符串类

2019-12-21 16:02:06来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

c++-重载等号，数组，指针，字符串类

重载

  • 重载=操作符
    • 1先释放旧对象资源
    • 2用一个对象=给另外一个对象
    • 3函数返回值当左值 返回一个引用
    • 4 数组类 Array& operator=(Array& a1);
    • 5 字符串类：MyString& operator=(const MyString& obj);
    • char& operator const;
  • 运算符重载难点
    • 重载=操作符
      • 1先释放旧对象资源
      • 2用一个对象=给另外一个对象
      • 3函数返回值当左值 返回一个引用
      • 4 数组类 Array& operator=(Array& a1);
      • 5 字符串类：MyString& operator=(const MyString& obj);
    • char& operator const;
    • 重载[]数组下标
      • 1 返回元素的引用，支持a[i]当左值 a[i]右值
      • 2 数组类 int& operator;
      • 3 字符串类 char& operator const;
    • && 和 || 不能被重载
    • ()重载
  • 案例：数组类 运算符重载优化
  • 案例：字符串类 运算符重载

等号运算符重载

  • 重载=操作符
    • 1 先释放旧对象资源
    • 2 用一个对象=给另外一个对象
    • 3 函数返回值当左值 返回一个引用
    • 4 数组类 Array& operator=(Array& a1);
    • 5 字符串类：MyString& operator=(const MyString& obj);
    • char& operator const;
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string.h>


using namespace std;

class Student
{
public:
    Student()
    {
        this->id = 0;
        this->name = NULL;
    }

    Student(int id, char *name)
    {
        this->id = id;

        //this->name = name;
        int len = strlen(name);
        this->name = new char[len + 1];
        strcpy(this->name, name);
    }

    Student(const Student &another)
    {
        this->id = another.id;

        //深拷贝
        int len = strlen(another.name);
        this->name = new char[len + 1];
        strcpy(this->name, another.name);
    }

    Student & operator=(const Student &another)
    {
        //1 防止自身赋值
        if (this == &another) {
            return *this;
        }

        //2 先将自身的额外开辟的空间回收掉
        if (this->name != NULL) {
            delete[] this->name;
            this->name = NULL;
            this->id = 0;
        }

        //3 执行深拷贝
        this->id = another.id;

        int len = strlen(another.name);
        this->name = new char[len + 1];
        strcpy(this->name, another.name);


        //4 返回本身
        return *this;
    }

    void printS()
    {
        cout << name << endl;
    }

    ~Student() {
        if (this->name != NULL) {
            delete[] this->name;
            this->name = NULL;
            this->id = 0;
        }
    }
private:
    int id;
    char *name;
};

int main(void)
{

    Student s1(1, "zhang3");
    Student s2(s1);

    s2 = s1;

    Student s3(2, "li4");


    //s2 = s3 = s1;//s2 = 赋值操作符



    s1.printS();
    s2.printS();
    s3.printS();


    return 0;
}

自定义数组类运用重载

main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include "MyArray.h"

using namespace std;



int main(void)
{

 MyArray array1(10);//开辟10元素的数组

    //赋值操作
    for (int i = 0; i < 10; i++) {
        //array1.setData(i, i + 10);
        array1[i] = i + 10;//space[1] = 1+10
    }

    cout << "--------" << endl;

    cout << "array1:" << endl;
    for (int i = 0; i < 10; i++) {
        cout << array1[i] << " ";
    }
    cout << endl;

    MyArray array2 = array1;
    cout << "array2:" << endl;
    for (int i = 0; i < array2.getLen(); i++) {
        cout << array2[i] << " ";
    }
    cout << endl;
    

    cout << " ------------" << endl;
    MyArray array3(5);

    cin >> array3;


    cout << "array3:" << endl;
    cout << array3 << endl;
    cout << endl;

    
    if (array3 != array1)  {
        cout << "不相等" << endl;
    }
    else {
        cout << "相等 " << endl;
    }

    return 0;
}

Array.cpp

#include "MyArray.h"


MyArray::MyArray()
{
    cout << "MyArray()..." << endl;
    this->len = 0;
    this->space = NULL;
}

MyArray::MyArray(int len)
{
    if (len <= 0) {
        this->len = 0;
        return;
    }
    else {
        this->len = len;

        //给space开辟空间
        this->space = new int[this->len];
        cout << "MyArray::MyArray(int len) ..." << endl;
    }
}
MyArray::MyArray(const MyArray &another)
{
    if (another.len >= 0) {
        this->len = another.len;

        //深拷贝
        this->space = new int[this->len];
        for (int i = 0; i < this->len; i++) {
            this->space[i] = another.space[i];
        }
        cout << "MyArray::MyArray(const MyArray &another) ..." << endl;

    }
}
MyArray::~MyArray()
{
    if (this->space != NULL) {
        delete[]this->space;
        this->space = NULL;
        len = 0;
        cout << "MyArray::~MyArray() ..." << endl;
    }
}

void MyArray::setData(int index, int data)
{
    if (this->space != NULL) {
        this->space[index] = data;
    }
}
int MyArray::getData(int index)
{
    return this->space[index];
}
int MyArray::getLen() const
{
    return this->len;
}

MyArray&  MyArray::operator=(const MyArray& another)
{
    if (this == &another) {
        return *this;
    }

    if (this->space != NULL) {
        delete[]this->space;
        this->space = NULL; 
        this->len = 0;
    }

    if (another.len >= 0) {
        this->len = another.len;

        //深拷贝
        this->space = new int[this->len];
        for (int i = 0; i < this->len; i++) {
            this->space[i] = another.space[i];
        }
        cout << "MyArray::operator=(const MyArray& another) ..." << endl;

    }

    return *this;
}

int & MyArray::operator[](int index) const
{
    return this->space[index];
}


ostream &operator<<(ostream &os,const MyArray &array)
{
    os << "遍历整个数组 " << endl;
    //array.getLen(); //getLen(&array);
    for (int i = 0; i < array.getLen(); i++) {
        os << array[i] <<" ";//array.operator[]( i)
    }

    os << "调用的<<操作符重载" << endl;

    return os;
}

istream &operator>>(istream &is, MyArray &array)
{
    cout << "请输入" << array.getLen() << "个数" << endl;
    for (int i = 0; i < array.getLen(); i++) {
        cin >> array[i];
    }
    return is;
}


bool operator==(MyArray &array1, MyArray &array2)
{
    if (array1.len != array2.len) {
        return false;
    }

    for (int i = 0; i < array1.len; i++) {
        if (array1.space[i] != array2.space[i]) {
            return false;
        }
    }

    return true;
}
bool MyArray::operator!=(MyArray &another)
{
    return !(*this == another);
}

Array.h

#pragma once
#include <iostream>

using namespace std;

class MyArray
{
public:
    MyArray();
    MyArray(int len);
    MyArray(const MyArray &another);
    ~MyArray();

    void setData(int index, int data);
    int getData(int index);
    int getLen() const ;

    MyArray& operator=(const MyArray& another);

    int & operator[](int index) const;

    friend ostream &operator<<(ostream &os,const MyArray &array);
    friend istream &operator>>(istream &is, MyArray &array);

    friend bool operator==(MyArray &array1, MyArray &array2);
    bool operator!=(MyArray &another);
private:
    int len;
    int *space;
};

重载小括号

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>


using namespace std;

class Sqr
{
public:
    Sqr(int a) {
        this->a = a;
    }

    int operator()(int value)
    {
        return value * value;
    }

    int operator()(int value1, int value2)
    {
        return value1 * value2;
    }


private:
    int a;
};

void func(int a)
{

}

int main(void)
{
    Sqr s(10);

    int value = s(2);
    //s.operator()(2);
    
    //将一个对象 当成一个普通函数来调用。
                    //称这种对象是 仿函数，伪函数, 函数对象
     

    cout << value << endl;

    value = s(10, 20);
    
    cout << value << endl;


    return 0;
}

重载new和delete运算符

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <fstream>


using namespace std;

class A
{
public:
    A()
    {
        cout << "A()..." << endl;
    }
    A(int a) {
        cout << "A(int)..." << endl;
        this->a = a;
    }

    //重载的new操作符 依然会触发对象的构造函数
    void * operator new(size_t size)
    {
        cout << "重载了new操作符" << endl;
        return malloc(size);
    }

    void *operator new[](size_t size)
    {
        cout << "重载了new[]操作符" << endl;
        return malloc(size);
    }
    void operator delete(void * p)
    {
        cout << "重载了delete操作符" << endl;
        if (p != NULL) {
            free(p);
            p = NULL;
        }
    }

    void operator delete[](void *p)
    {
        cout << "重载了delete[]操作符" << endl;
        if (p != NULL) {
            free(p);
            p = NULL;
        }
    }

    ~A() {
        cout << "~A().... " << endl;
    }

private:
    int a;
};

int main(void)
{
    //char *array = malloc(sizeof(char)* 80);

    //int *value_p = new int;

    A *array_p = new A[10];


    //array_p->operator new[](sizeof(A[10]));
    delete[] array_p;

    A *ap = new A(10);

    //ap->operator new(sizeof(A));

    delete ap;
    
    return 0;
}

重载&&和||（不建议重载）

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>


using namespace std;


class Test
{
public:
    Test(int value) {
        this->value = value;
    }

    Test operator+(Test &another)
    {
        cout << "执行了+操作符重载" << endl;
        Test temp(this->value + another.value);
        return temp;
    }

    bool operator&&(Test &another)
    {
        cout << "执行了&&操作符重载" << endl;
        if (this->value && another.value) {
            return true;
        }
        else {
            return false;
        }

    }

    bool operator||(Test &another)
    {
        cout << "重载了||操作符" << endl;
        if (this->value || another.value) {
            return true;
        }
        else {
            return false;
        }
    }

    ~Test(){
        cout << "~Test()..." << endl;
    }
private:
    int value;
};

int main(void)
{
    int a = 1;
    int b = 20;


    Test t1(0);
    Test t2(20);

    //重载&&操作符，并不会发生短路现象。

    if (t1 && (t1+t2) ) {   //t1.operator&&(  t1.operator+(t2)  )
        cout << "为真" << endl;
    }
    else {
        cout << "为假" << endl;
    }

    cout << "------" << endl;

    if (t1 || (t1 + t2)) {//t1.operator||(  t1.operator+(t2) )
        cout << "为真" << endl;
    }
    else {
        cout << "为假" << endl;
    }


    return 0;
}

自定义智能指针

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <memory>


using namespace std;

class A
{
public:
    A(int a)
    {
        cout << "A()..." << endl;
        this->a = a;
    }

    void func() {
        cout << "a = " << this->a << endl;
    }

    ~A() {
        cout << "~A()..." << endl;
    }
private:
    int a;
};


class MyAutoPtr
{
public:
    MyAutoPtr(A * ptr)
    {
        this->ptr = ptr;//ptr = new A(10)
    }

    ~MyAutoPtr() {
        if (this->ptr != NULL) {
            cout << "delte ptr" << endl;
            delete ptr;
            this->ptr = NULL;
        }
    }

    A* operator->()
    {
        return this->ptr;
    }


    A& operator*()
    {
        return *ptr;
    }

private:
    A *ptr;
};

void test1()
{
#if 0
    A* ap = new A(10);

    ap->func();
    (*ap).func();

    delete ap;
    auto_ptr<int> ptr(new int);
#endif
    auto_ptr<A> ptr(new A(10));

    ptr->func();
    (*ptr).func();
}


void test2()
{
    MyAutoPtr my_p(new A(10));

    my_p->func(); //my_p.ptr -> func()
    (*my_p).func(); //  *ptr.func()
}
int main(void)
{
    
    //test1();
    test2();

    return 0;
}

自定义字符串类

main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include "MyString.h"

using namespace std;

int main(void)
{
    string s1;
    MyString s1("abc");
    MyString s2("123");

    //cout << s1 + s2 << endl;

    cout << s1 << endl;
    cout << s2 << endl;


#if 0
    MyString s1("abc");
    MyString s2(s1);
    MyString s3 = "123";


    cout << s1 << endl;
    cout << s2 << endl;

    s1[1] = 'x';

    cout << s1 << endl;

    s1 = s3;

    cout << s1 << endl;

#endif
    return 0;
}

String.cpp

#include "MyString.h"


MyString::MyString()
{
    this->len = 0;
    this->str =NULL;
}

MyString::MyString(const char *str)
{
    if (str == NULL) {
        this->len = 0;
        this->str = new char[0 + 1];
        strcpy(this->str, "");
    }
    else {
        int len = strlen(str);
        this->len = len;

        this->str = new char[len + 1];
        strcpy(this->str, str);
    }
}

//初始化时候被调用的
MyString::MyString(const MyString &another)
{
    this->len = another.len;
    this->str = new char[this->len + 1];
    strcpy(this->str, another.str);
}



MyString::~MyString()
{
    if (this->str != NULL) {
        cout << this->str << "执行了析构函数" << endl;
        delete this->str;
        this->str = NULL; 
        this->len = 0;
    }
}

char & MyString::operator[](int index)
{
    return this->str[index];
}

MyString &  MyString::operator=(const MyString &another)
{
    if (this == &another) {
        return *this;
    }

    if (this->str != NULL) {
        delete[] this->str;
        this->str = NULL;
        this->len = 0;
    }

    this->len = another.len;
    this->str = new char[this->len + 1];
    strcpy(this->str, another.str);

    return *this;
}

ostream & operator<<(ostream &os, MyString&s)
{
    os << s.str;
    return os;
}

istream & operator>>(istream &is, MyString &s)
{
    //1 将s之前的字符串释放掉
    if (s.str != NULL) {
        delete[] s.str;
        s.str = NULL;
        s.len = 0;
    }

    //2 通过cin添加新的字符串
    char temp_str[4096] = { 0 };
    cin >> temp_str;

    int len = strlen(temp_str);
    s.str = new char[len + 1];
    strcpy(s.str, temp_str);
    s.len = len;

    return is;
}

MyString MyString::operator+(MyString &another)
{
    MyString temp;

    int len = this->len + another.len;

    temp.len = len;

    temp.str = new char[len + 1];
    memset(temp.str, 0, len + 1);
    strcat(temp.str, this->str);
    strcat(temp.str, another.str);

    return temp;
}

String.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

class MyString
{
public:
    MyString();
    //MyString(int len); //创建一个长度是len的string对象
    MyString(const char *str);
    MyString(const MyString &another);
    ~MyString();

    //重载操作符[]
    char &operator[](int index);



    //重载操作符>>
    friend istream & operator>>(istream &is, MyString &s);

    //重载=操作符
    MyString & operator=(const MyString &another);

    //重载==操作符

    //重载!=操作符


    //重载+操作符
    MyString operator+(MyString &another);


    //重载操作符<<
    friend ostream & operator<<(ostream &os, MyString&s);

private:
    int len;
    char *str;
};

原文链接:https://www.cnblogs.com/ygjzs/p/12076998.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：c++-重载运算符（+-，++，--，+=，-=，cin，cout）

下一篇：c++-类与类的关系

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签