运算符2

补充上一部分的运算符 这次写了这一些运算符 等于==  赋值= 箭头-> 括号运算符 （） 输出运算符>>

#include<iostream>
#include<string> //string类  存放字符串
using namespace std;
class myString
{
    char*str;//指针  用于存放字符串
    int size;//用来管理堆内存的大小 判断内存是否足够
public:
    myString()
    {
        size = 1;
        str = new char[1]{''};//放入一个''
    }
    myString(char* string)//拷贝构造
    {
        size = strlen(string) + 1;        //+1的目的是存放
        str = new char[strlen(string) + 1];
        strcpy(str, string);//拷贝过程
    }
    ~myString()
    {
        if (str != nullptr)
        {
            delete[] str;
            str = nullptr;
        }
    }
    friend bool operator==(const myString&a, const char*b)//重载＝=运算符
    {
        return strcmp(a.str, b) == 0;//比较两个字符串
    }
    friend ostream&operator<<(ostream& os, myString& st)//友元重载输出运算符
    {
        os << st.str;
        return os;
    }
    //返回值是对象   可以返回引用
    friend myString& operator+=(myString& st, const char a[])//友元重载+=运算符 +=需要修改值不能用const 
    {
        if (strlen(st.str) + strlen(a) + 1 >st.size)//判断内存是否足够
        {
            st.size = strlen(st.str) + strlen(a) + 1;
            char*p = new char[st.size];//准备足够的内存
            strcpy(p, st.str);//原先内容拷贝过来
            delete[] st.str;
            st.str = p;//新内存地址赋值给str
        }
        strcat(st.str, a);//把字符串连接起来
    }

    //重载=  使用成员函数 
    myString&operator=(const char*a)
    {
        //如果是赋值nullprt可以另外加上比较去处理
        if (strlen(a) + 1 > size)
        {
            size = strlen(a) + 1;
            delete[] str;//释放原内存
            str = new char[size];
        }
        strcpy(str, a);//拷贝内容
        return *this;//this加*代表 当前对象
    }

};

//你怎么写的  限制了用户如何去使用
struct st{ int x; int y; };
class A
{
    st stu;//结构体类型 成员变量
public:
    st* operator->()        //->箭头运算符 
    {
        return &stu;
    }
    void operator()()        //重载的括号运算符  operator()
    {
        cout << "函数1" << endl;
    }
    void operator()(int x)
    {
        cout << "函数2" << endl;
    }
    int operator()(int x, int y)
    {
        cout << "函数3" << endl;
        return 1;
    }

    void* operator new(size_t size)//这个size是申请内存的大小  单位是字节
    {
        //size是自动计算好了的 不需要管
        cout << "调用new" << endl;
        return malloc(size);//申请内存
    }

    void operator delete(void *p)
    {
        cout << "调用delete" << endl;
        free(p);
    }
    void* operator new[](size_t size)
    {
        return malloc(size);
    }
    void operator delete[](void *p)
    {
        cout << "调用delete[ ]" << endl;
        free(p);
    }
};


/*
new 申请内存  调用构造函数  返回地址 3种操作
delete  调用析构   释放内存  2种操作

重载new 只能申请内存这个操作        可以直接使用malloc操作
重载delete 只能释放内存这个操作    可以使用free操作


new  new[]
delete  delete[]
*/
int main()
{
    A *p = new A;
    delete p;

    p = new A[10];
    delete[] p;


    A a;//对象
    a->x = 2;
    a();
    a(1);
    a(1, 2);        //仿函数  就是用 对象(参数)     使用格式类似函数  所以叫做仿函数

    //A a(1, 2);//前面有类型   才是定义对象
    //a(1, 2);//调用成员函数

    char str[128] = "hello world";    //存放字符串  使用堆内存


    string st = "hello world";  //调用构造
    if (st == "hello world")    //调用重载==
    {
        cout << "-----" << endl;

    }
    st += "yes or no";        //重载+= 运算符
    cout << st << endl;        //重载<<运算符


    myString myst;
    if (myst == "hello world")//等于运算符重载
    {
        cout << "重载运算符 修改函数" << endl;
    }
    myst = "hello world";
    cout << myst << endl;



    cin.get();
    return 0;
}

//this  指向当前对象的指针
// *this  当前对象


//结构体  重载<