c++基础学习笔记——04-c++day05

在学习c++基础总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

04-c++day05

目录：
一、类和对象
1、强化训练——数组类的封装
2、加号运算符重载
3、左移运算符重载
4、前置后置递增运算符重载
5、指针运算符重载
6、赋值运算符重载
7、[]运算符重载
二、总结

 

一、类和对象

1、强化训练——数组类的封装

练习：

数组类的封装.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include"MyArray.h"

void test01()
{
    //堆区创建数组
    MyArray* array = new MyArray(30);
    
    MyArray* array2 = new MyArray(*array);//new方式指定调用拷贝构造
    MyArray array3 = *array;//构造函数返回的本体
    
    
    //MyArray* array4(array);//等价于MyArray* array4 = array;这个是声明一个指针，和array执行的地址相同，所以不会调用拷贝构造
    
    delete array;
    
    //尾插法测试
    for(int i = 0; i < 10; i++)
    {
        array2->push_Back(i);
    }
    
    //获取数据测试
    for(int i = 0; i < 10; i++)
    {
        cout << array2->getData(i) << endl;
    }
    
    //设置值测试
    array2->setData(0, 1000);
    
    cout << array2->getData(0) << endl;
    
    //获取数组大小
    cout << "array2的数组大小为：" << array2->getSize() << endl;
    //获取数组容量
    cout << "array2的数组容量为：" << array2->getCapacity() << endl;
    
    //获取、设置数组内容？如何用[]进行设置和访问？？？
    //cout << array3[0] << endl;
    //array3[0] = 1000;
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

MyArray.h

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

class MyArray
{
public:
    MyArray();//默认构造，默认100容量
    MyArray(int capacity);
    MyArray(const MyArray& array);
    
    ~MyArray();
    
    //尾插法
    void push_Back(int val);
    
    //根据索引获取值
    int getData(int index);

    //根据索引设置值
    void setData(int index, int val);
    
    //获取数组大小
    int getSize();
    //获取数组容量
    int getCapacity();
    
private:
    int* pAddress;//指向真正存储数据的指针
    int m_Size;//数组大小
    int m_Capacity;//数组容量
};

MyArray.cpp

#include"MyArray.h"

//默认构造
MyArray::MyArray()
{
    this->m_Capacity = 100;
    this->m_Size = 0;
    this->pAddress = new int[this->m_Capacity];
}
//有参构造 参数 数组容量
MyArray::MyArray(int capacity)
{
    cout << "有参构造调用" <<endl;
    this->m_Capacity = capacity;
    this->m_Size = 0;
    this->pAddress = new int[this->m_Capacity];
}
//拷贝构造
MyArray::MyArray(const MyArray& array)
{
    cout << "拷贝构造调用" <<endl;
    this->pAddress = new int[array.m_Capacity];
    this->m_Size = array.m_Size;
    this->m_Capacity = array.m_Capacity;
    
    for(int i = 0; i < array.m_Size; i++)
    {
        this->pAddress[i] = array.pAddress[i];
    }
}
//析构
MyArray::~MyArray()
{
    if(this->pAddress != NULL)
    {
        cout << "析构调用" <<endl;
        delete[] this->pAddress;
        this->pAddress = NULL;
    }
}

void MyArray::push_Back(int val)
{
    //判断越界？用户自己处理
    this->pAddress[this->m_Size] = val;
    this->m_Size++;
}

int MyArray::getData(int index)
{
    return this->pAddress[index];
}

void MyArray::setData(int index, int val)
{
    this->pAddress[index] = val;
}

//获取数组大小
int getSize()
{
    return this->m_Size;
}
//获取数组容量
int getCapacity()
{
    return this->m_Capacity;
}

2、加号运算符重载

---

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

运算符重载(operator overloading)只是一种”语法上的方便”,也就是它只是另一种函数调用的方式。

在c++中，可以定义一个处理类的新运算符。这种定义很像一个普通的函数定义，只是函数的名字由关键字operator及其紧跟的运算符组成。差别仅此而已。它像任何其他函数一样也是一个函数，当编译器遇到适当的模式时，就会调用这个函数。
语法：
   定义重载的运算符就像定义函数，只是该函数的名字是operator@,这里的@代表了被重载的运算符。函数的参数中参数个数取决于两个因素。
1）运算符是一元(一个参数)的还是二元(两个参数)；
2）运算符被定义为全局函数(对于一元是一个参数，对于二元是两个参数)还是成员函数(对于一元没有参数，对于二元是一个参数-此时该类的对象用作左耳参数)

   [两个极端]
   有些人很容易滥用运算符重载。它确实是一个有趣的工具。但是应该注意，它仅仅是一种语法上的方便而已，是另外一种函数调用的方式。从这个角度来看，只有在能使涉及类的代码更易写，尤其是更易读时(请记住，读代码的机会比我们写代码多多了)才有理由重载运算符。如果不是这样，就改用其他更易用，更易读的方式。
   对于运算符重载，另外一个常见的反应是恐慌：突然之间，C运算符的含义变得不同寻常了，一切都变了，所有C代码的功能都要改变！并非如此，对于内置的数据类型的表示总的所有运算符是不可能改变的。

---

如果想让自定义数据类型进行+运算，那么就需要重载+运算符。

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

class Person
{
public:
    Person()
    {
        
    }
    Person(int a, int b):m_A(a),m_B(b)
    {
        
    }
    
    //+号运算符重载 成员函数
    /*
    Person operator+(Person& p)
    {
        Person tmp;
        tmp.m_A = this->m_A + p.m_A;
        tmp.m_B = this->m_B + p.m_B;
        teturn tmp;
    }
    */
    
    int m_A;
    int m_B;
};

//利用全局函数 进行+号运算符的重载
Person operator+(Person& p1, Person& p2)
{
    Person tmp;
    tmp.m_A = p1->m_A + p2.m_A;
    tmp.m_B = p1->m_B + p2.m_B;
    teturn tmp;
}
Person operator+(Person& p1, int a)//二元
{
    Person tmp;
    tmp.m_A = p1->m_A + a;
    tmp.m_B = p1->m_B + a;
    teturn tmp;
}

void test01()
{
    Person p1(10, 10);
    Person p2(10, 10);
    
    Person p3 = p1 + p2;//p1+p2 从什么表达式转变的？p1.operator+(p2)、operator+(p1, p2)
    Person p4 = p1 + 10;//重载的版本
    cout << "p3的m_A:" << p3.m_A << " m_B:" << p3.m_B << endl;
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

3、左移运算符重载

不要随意乱用符号重载，内置数据类型的运算符不可以重载。

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

class Person
{
    friend ostream& operator<<(ostream& cout, Person& p1);
    
public:
    Person(){}
    Person(int a, int b)
    {
        this->m_A = a;
        this->m_B = b;
    }
    
    /* 重载左移运算符不可以写到成员函数中
    void operator<<()
    {
        
    }
    */

private:    
    int m_A;
    int m_B;
};
//全局函数中
ostream& operator<<(ostream& cout, Person& p1)//第一个参数cout，第二个参数p1
{
    cout << "m_A = " << p1.m_A << "m_B = " << p1.m_B;
    return cout;
}


void test01()
{
    Person p1(10, 10);
    
    cout << p1 << endl;
    
    
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

4、前置后置递增运算符重载

---

自增自减(++/--)运算符重载

 重载的++和--运算符有点让人不知所措，因为我们总是希望能根据它们出现在所作用对象的前面还是后面来调用不同的函数。解决办法很简单，例如当编译器看到++a(前置++)，它就调用operator++(a),当编译器看到a++（后置++），它就会去调用operator++(a,int).

优先使用++和--的标准形式，优先调用前置++。

如果定义了++c，也要定义c++，递增操作符比较麻烦，因为他们都有前缀和后缀形式，而两种语义略有不同。重载operator++和operator--时应该模仿他们对应的内置操作符。

对于++和--而言，后置形式是先返回，然后对象++或者--，返回的是对象的原值。前置形式，对象先++或--，返回当前对象，返回的是新对象。其标准形式为:

调用代码时候，要优先使用前缀形式，除非确实需要后缀形式返回的原值，前缀和后缀形式语义上是等价的，输入工作量也相当，只是效率经常会略高一些，由于前缀形式少创建了一个临时对象。

---

 练习：自己实现int 类型MyInteger，内部维护int数据。

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

class MyInteger
{
    friend ostream& operator<<(ostream& cout, MyInteger& myInt);
public:
    MyInteger()
    {
        m_Num = 0;
    }
    
    //前置++重载
    MyInteger& operator++()
    {
        this->m_Num++;
        return *this;
    }
    
    //后置++重载
    MyInteger operator++(int)//占位参数
    {
        //先保存目前数据
        MyInteger tmp = *this;
        m_Num++;
        return tmp;
    }
    
    int m_Num;
};

ostream& operator<<(ostream& cout, MyInteger& myInt)
{
    cout << myInt.m_Num;
    return cout;
}

void test01()
{
    MyInteger myInt;
    
    //前置++
    cout << ++myInt << endl;
    
    //后置++
    cout << myInt++ << endl;
    
    cout << myInt << endl;
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

5、指针运算符重载

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

class Person
{
public:
    Person(int age)
    {
        this->m_Age = age;
    }
    
    void showAge()
    {
        cout << "年龄为：" << this->m_Age << endl;
    }
    ~Person()
    {
        cout << "Person的析构调用" << endl;
    }
    
    
    int m_Age;
};

//智能指针
//用来托管自定义类型的对象，让对象进行自动的释放
class smartPointer
{
public:
    smartPointer(Person* person)
    {
        this->person = person;
    }
    
    //重载->让智能指针对象像Person *p一样去使用
    Person* operator->()
    {
        return this->person;
    }
    
    //重载*
    Person& operator*()
    {
        return *this->person;
    }
    
    ~smartPointer()
    {
        cout << "智能指针析构了" << endl;
        if(this->person != NULL)
        {
            delete this->person;
            this->person = NULL;
        }
    }
    
private:
    Person* person;
};

void test01()
{
    //Person p1(10);//自动析构
    
    //Person* p1 = new Person(10);
    //delete p1;
    
    smartPointer sp(new Person(10));//sp开辟到了栈上，自动释放
    sp->showAge();//sp->->showAge();编译器优化了写法（sp->返回才是真正指针）
    
    (*sp).showAge();
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

6、赋值运算符重载

系统默认给类提供 赋值运算符写法 是简单值拷贝，导致如果类中有指向堆区的指针，就可能出现深浅拷贝的问题。

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

//一个类默认创建：默认构造、析构、拷贝构造、operator=赋值运算符（进行简单的值传递）
class Person
{
public:
    Person(int a)
    {
        this->m_A = a;
    }
    
    
    int m_A;
};


void test01()
{
    Person p1(10);
    
    Person p2(0);
    
    p2 = p1;//赋值
    
    cout << "p2的m_A:" << p2.m_A << endl;
}

class Person2
{
public:
    Person2(char* name)
    {
        this->pName = new char[strlen(name) + 1];
        strcpy(this->pName, name);
    }
    
    //重载= 赋值运算符
    Person2& operator=(const Person2& p)
    {
        //先判断，如果原来已经堆区有内容，先释放
        if(this->pName != NULL)
        {
            delete[] this->pName;
            this->pName = NULL;    
        }
        
        this->pName = new char[strlen(p.pName) + 1];
        strcpy(this->pName, p.pName);
        
        return *this;
    }
    
    
    
    ~Person2()
    {
        if(this->pName != NULL)
        {
            delete[] this->pName;
            this->pName = NULL;
        }
    }
    
    char* pName;
};

void test02()
{
    Person2 p1("狗蛋");
    
    Person2 p2("狗剩");
    
    Person2 p3(" ");
        
    p3 = p2 = p1;//链式
    
    cout << p2.pName << endl;
    cout << p3.pName << endl;
}


int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

7、[]运算符重载

对练习1优化，对数组索引操作

数组类的封装.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include"MyArray.h"

void test01()
{
    //堆区创建数组
    MyArray* array = new MyArray(30);
    
    MyArray* array2 = new MyArray(*array);//new方式指定调用拷贝构造
    MyArray array3 = *array;//构造函数返回的本体
    
    
    MyArray* array4(array);//等价于MyArray* array4 = array;这个是声明一个指针，和array执行的地址相同，所以不会调用拷贝构造
    
    delete array;
    
    //尾插法测试
    for(int i = 0; i < 10; i++)
    {
        array2->push_Back(i);
    }
    
    //获取数据测试
    for(int i = 0; i < 10; i++)
    {
        cout << array2->getData(i) << endl;
    }
    
    //设置值测试
    array2->setData(0, 1000);
    
    cout << array2->getData(0) << endl;
    
    //获取数组大小
    cout << "array2的数组大小为：" << array2->getSize() << endl;
    //获取数组容量
    cout << "array2的数组容量为：" << array2->getCapacity() << endl;
    
    //获取、设置数组内容?如何用[]进行设置和访问
    array3.push_Back(10000);
    cout << array3.getData(0) << endl;
    cout << array3[0] << endl;
    array3[0] = 100;
    cout << array3[0] << endl;
}

int main()
{
    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

MyArray.h

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

class MyArray
{
public:
    MyArray();//默认构造，默认100容量
    MyArray(int capacity);
    MyArray(const MyArray& array);
    
    ~MyArray();
    
    //尾插法
    void push_Back(int val);
    
    //根据索引获取值
    int getData(int index);

    //根据索引设置值
    void setData(int index, int val);
    
    //获取数组大小
    int getSize();
    
    //获取数组容量
    int getCapacity();
    
    //[]运算符重载
    int& operator[](int index);
    
    
private:
    int* pAddress;//指向真正存储数据的指针
    int m_Size;//数组大小
    int m_Capacity;//数组容量
};

MyArray.cpp

#include"MyArray.h"

//默认构造
MyArray::MyArray()
{
    this->m_Capacity = 100;
    this->m_Size = 0;
    this->pAddress = new int[this->m_Capacity];
}
//有参构造 参数 数组容量
MyArray::MyArray(int capacity)
{
    cout << "有参构造调用" <<endl;
    this->m_Capacity = capacity;
    this->m_Size = 0;
    this->pAddress = new int[this->m_Capacity];
}
//拷贝构造
MyArray::MyArray(const MyArray& array)
{
    cout << "拷贝构造调用" <<endl;
    this->pAddress = new int[array.m_Capacity];
    this->m_Size = array.m_Size;
    this->m_Capacity = array.m_Capacity;
    
    for(int i = 0; i < array.m_Size; i++)
    {
        this->pAddress[i] = array.pAddress[i];
    }
}
//析构
MyArray::~MyArray()
{
    if(this->pAddress != NULL)
    {
        cout << "析构调用" <<endl;
        delete[] this->pAddress;
        this->pAddress = NULL;
    }
}

void MyArray::push_Back(int val)
{
    //判断越界？用户自己处理
    this->pAddress[this->m_Size] = val;
    this->m_Size++;
}

int MyArray::getData(int index)
{
    return this->pAddress[index];
}

void MyArray::setData(int index, int val)
{
    this->pAddress[index] = val;
}

//获取数组大小
int getSize()
{
    return this->m_Size;
}
//获取数组容量
int getCapacity()
{
    return this->m_Capacity;
}
//[]运算符重载
int& operator[](int index)
{
    return this->pAddress[index];
}

 

二、总结

1    加号运算符重载
1.1    如果想让自定义数据类型 进行+运算，那么就需要重载 + 运算符
1.2    在成员函数 或者 全局函数里 重写一个+运算符的函数
1.3    函数名 operator+ () {}
1.4    运算符重载 也可以提供多个版本
2    左移运算符重载
2.1    不要随意乱用符号重载
2.2    内置数据类型 的运算符不可以重载
2.3    cout << 直接对Person自定义数据类型 进行输出
2.4    写到全局函数中 ostream& operator<< ( ostream & cout, Person & p1  ) {}
2.5    如果重载时候想访问 p1的私有成员，那么全局函数要做Person的友元函数
3    前置 后置 ++ 运算符重载
3.1    自己实现int类型 MyInteger
3.2    内部维护以int数据
3.3    MyInteger myInt
3.4    myInt ++ 后置  ++myInt  前置
3.5    重载++运算符 operator++() 前置   operator++(int) 后置
3.6    前置理念 先++ 后返回自身   后置理念 先保存住原有值  内部++ 返回临时数据
3.7    练习  自己实现递减运算符重载 --
4    智能指针实现
4.1    Person类有showAge 成员函数
4.2    如果new出来的Person对象，就要让程序员自觉的去释放  delete
4.3    有了智能指针，让智能指针托管这个Person对象，对象的释放就不用操心了，让智能指针管理
4.4    为了让智能指针想普通的Person*指针一样使用 就要重载 -> 和*
5    赋值运算符重载
5.1    系统默认给类提供 赋值运算符写法 是简单值拷贝
5.2    导致如果类中有指向堆区的指针，就可能出现深浅拷贝的问题
5.3    所以要重载 = 运算符
5.4    如果想链式编程 return*this
6    []运算符重载
6.1    返回数组索引的引用
6.2    int & operator[](int index)
6.3    return this->pAddress[index]

 

在学习c++基础总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。