c++定义数组类&运算符重载

知识点9【定义数组类】

myarray.h

#ifndef MYARRAY_H
#define MYARRAY_H

class MyArray
{
private:
    int *arr;//保存动态数组的首元素地址
    int size;//存放实际元素个数
    int capacity;//数组容量（数组最多存放的元素个数）
public:
    MyArray();
    MyArray(int capacity);
    MyArray(const MyArray &ob);
    ~MyArray();

    int Size();
    int Capacity();

    //尾部插入元素
    void push_back(int elem);
    //尾部删除
    void pop_back();
    //遍历数组
    void showArray();
};
#endif // MYARRAY_H

myarray.cpp

#include "myarray.h"
#include <string.h>
#include <iostream>
using namespace std;

MyArray::MyArray()
{
    capacity=5;
    size = 0;
    //申请空间
    arr  = new int[capacity];
    //清空空间内容
    memset(arr,0,sizeof(int)*capacity);
}

MyArray::MyArray(int capacity)
{
    this->capacity = capacity;
    size = 0;
    //申请空间
    arr = new int[capacity];
    memset(arr,0,sizeof(int)*capacity);
}

MyArray::MyArray(const MyArray &ob)
{
    capacity = ob.capacity;
    size = ob.size;

    //arr指向独立的空间
    arr = new int[capacity];
    //将ob.arr指向的内容 拷贝到 arr指向空间中
    memcpy(arr,ob.arr, sizeof(int)*capacity);
}

MyArray::~MyArray()
{
    if(arr!=NULL)
    {
        delete [] arr;
        arr=NULL;
    }
}

int MyArray::Size()
{
    return size;
}

int MyArray::Capacity()
{
    return capacity;
}

void MyArray::push_back(int elem)
{
    //容器满 扩展2倍
    if(size == capacity)
    {
        //1、申请2倍的空间 并清空
        int *tmpArr = new int[2*capacity];
        memset(tmpArr,0,sizeof(int)*2*capacity);

        //2、将旧空间的内容 拷贝到 新空间中
        memcpy(tmpArr, arr, sizeof(int)*capacity);

        //3、释放就空间 并让arr指向新空间
        delete [] arr;
        arr = tmpArr;

        //4、更新容量
        capacity = 2*capacity;
    }

    //尾部插入数据
    arr[size++]=elem;
    return;
}

void MyArray::pop_back()
{
    //判断容易是否为空间
    if(size == 0)
    {
        cout<<"容器为空 无法删除"<<endl;
        return;
    }

    arr[--size]=0;
    return;
}

void MyArray::showArray()
{
    int i=0;
    for(i=0;i<size;i++)
    {
        cout<<arr[i]<<" ";
    }
    cout<<endl;
    return;
}

main.cpp

#include <iostream>
#include "myarray.h"
using namespace std;

int main(int argc, char *argv[])
{
    MyArray arr1;
    arr1.push_back(10);
    arr1.push_back(20);
    arr1.push_back(30);
    cout<<"size = "<<arr1.Size()<<" 容量="<<arr1.Capacity()<<endl;
    arr1.push_back(40);
    arr1.push_back(50);
    arr1.push_back(60);
    cout<<"size = "<<arr1.Size()<<" 容量="<<arr1.Capacity()<<endl;
    arr1.showArray();
    arr1.pop_back();
    arr1.pop_back();
    arr1.showArray();
    return 0;
}

知识点10【运算符重载】

1、运算符重载

运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应 不同的数据类型。

重载运算符 的本质 就是重新实现函数 只是该函数名为（operator+运算符）。

2、重载运算符的步骤

a、明白运算符需要几个运算符对象，因为 运算对象的个数 决定函数参数的个数。

b、运算符左边的对象 是自定义对象还是其他。

如果是自定义对象：可以使用全局函数 或成员函数实现。（成员函数实现可以少一个参数）

如果是其他。必须使用全局函数。（必须设置全局函数为类的友元）。

3、重载<<运算符

#include <iostream>
#include <string.h>
using namespace std;
class Person
{
   friend ostream&  operator<<(ostream &out , Person &ob );
private:
    int num;
    char name[32];
public:
    Person(){}
    Person(int num, char *name)
    {
        this->num = num;
        strcpy(this->name, name);
    }
};

//返回
ostream& operator<<(ostream &out , Person &ob )
{
    out<<ob.num<<" "<<ob.name;
    return out;
}

int main(int argc, char *argv[])
{
    Person lucy(100,"lucy");
    Person bob(200,"bob");

    cout<<lucy<<" "<<bob<<endl;
    return 0;
}

4、cin获取键盘输入

5、重载>>运算符

//全局函数实现 （记得设置成友元）
istream& operator>>(istream &in, Person &ob)
{
    in>>ob.num;
    in.getline(ob.name,sizeof(ob.name));
    return in;
}

void test03()
{
   Person lucy,bob;
   cout<<"请输入两个学号 姓名:";

   //cin>>lucy;//operator>>(cin,lucy);
   cin>>lucy>>bob;

   cout<<lucy<<" "<<bob<<endl;
}

6、重载+运算符

全局函数实现：

Person operator+(const Person &ob1, const Person &ob2)
{
    Person tmp;
    tmp.num = ob1.num+ob2.num;
    strcpy(tmp.name,ob1.name);
    strcat(tmp.name,ob2.name);


    return tmp;
}

void test04()
{
    Person lucy(100,"lucy");
    Person bob(200,"bob");
    Person tom(300,"tom");

    cout<<lucy+bob+tom<<endl;
}

成员函数实现：

//成员函数重载+ (推荐)
Person operator+(const Person &ob)
{
    //lucy+bob  其中num和name就是lucy.num 和lucy.name  ob==bob
    Person tmp;
    tmp.num = num+ob.num;
    strcpy(tmp.name,name);
    strcat(tmp.name,ob.name);

    return tmp;
}

void test04()
{
    Person lucy(100,"lucy");
    Person bob(200,"bob");
    Person tom(300,"tom");

    cout<<lucy+bob+tom<<endl;
}

7、重载>运算符 < == !=

//成员函数重载>
bool operator>(const Person &ob)
{
    return num>ob.num;
}

void test05()
{
    Person lucy(100,"lucy");
    Person bob(200,"bob");


    if(lucy>bob)
    {
        cout<<"大于"<<endl;
    }
    else
    {
        cout<<"不大于"<<endl;
    }

}

8、重载++运算符

如当编译器看 到++a(前置++)，它就调用 operator++(a)

当编译器看到 a++（后置++），它就会去 调用 operator++(a,int).

8.1 重载后置++

//成员重载后置++
Person operator++(int)
{
    //备份旧值
    Person tmp=*this;

    //在自增
    num++;
    strcat(name,tmp.name);

    return tmp;
}
void test06()
{
    Person lucy(100,"lucy");
    Person bob;
    bob=lucy++;
    cout<<"bob = "<<bob<<endl;
    cout<<"lucy = "<<lucy<<endl;
}

//成员重载前置++
Person& operator++()
{
    //先自增
    num++;
    char tmp[32]="";
    strcpy(tmp,name);
    strcat(name,tmp);
    //赋值
    return *this;
}

void test06()
{
    Person lucy(100,"lucy");
    Person bob;
    bob=++lucy;
    cout<<"bob = "<<bob<<endl;
    cout<<"lucy = "<<lucy<<endl;
}

9、重载函数调用运算符（）。

重载函数调用运算符 也叫仿函数。

class Print
{
public:
    //重载函数调用运算符(仿函数)
    Print& operator()(char *str)
    {
        cout<<str;
        return *this;
    }
};

void test07()
{
    //对象和()结合 出发operator()调用
    Print func;
    func("hello world")("xixixi")("hahaha");
    cout<<endl;
    Print()("hello BJ2401")("xixixi")("hahaha");
}

仿函数：为将来的算法 提供策略。

10、无法重载的运算符

11、尽量别重载 && ||

用户 无法实现 && ||的短路特性。

12、智能指针

#include <iostream>
using namespace std;
class Data
{
    friend int main(int argc, char *argv[]);
    friend class SmartPoint;
private:
    int data;
public:
    Data()
    {
        data = 0;
        cout<<"Data无参构造 data="<<data<<endl;
    }
    Data(int data)
    {
        this->data = data;
        cout<<"Data有参构造data = "<<data<<endl;
    }
    ~Data()
    {
        cout<<"Data的析构函数data="<<data<<endl;
    }
};

class SmartPoint
{
private:
    Data *p;
public:
    SmartPoint()
    {
        p=NULL;
    }
    SmartPoint(Data *p)
    {
        this->p = p;
    }
    SmartPoint(const SmartPoint &ob )
    {
        p = new Data;
        p->data = ob.p->data;
    }
    ~SmartPoint()
    {
        delete p;
    }
    Data& operator*()
    {
       return *p;
    }
    Data* operator->()
    {
        return p;
    }
};

int main(int argc, char *argv[])
{
    SmartPoint p(new Data(100));
    //cout<< (p.operator *()).data <<endl;
    cout<<(*p).data<<endl;

    //cout<< (p.operator ->())->data<<endl;
    cout<<p->data<<endl;

    return 0;
}