C++学习系列文章

C++构造函数初始化https://mp.csdn.net/mp_blog/creation/editor/124911403

C++的拷贝构造https://mp.csdn.net/mp_blog/creation/editor/124911603

---

文章目录

• 系目录列文章

  目录

  C++学习系列文章

  文章目录

  前言

  一、[ ]运算符的重载

  使用步骤

  [ ]的重载

  二、[ ]运算符的重载

  使用步骤

  [ ]的重载

  2.读入数据

  总结

  ---

---

前言

例如：C++运算符重载的部分内容

一、[ ]运算符的重载

示例：[ ]运算符的重载主要是让对象当中的指针申请的内存空间可以使用[ ]运算符写入或读取相应位置的内容。

使用步骤

[ ]的重载

代码如下（示例）：

    //这是指针的引用，我们可以借助这个对指针内部的内容进行修改
    int& operator[](int x)
    {
        return pdatas[x];
    }

二、（ ）运算符的重载

示例：（）运算符的重载主要是有两个方法，（1）是当作函数对象，就是可以向函数一样调用的对象（2）是进行强制类型转换。

使用步骤 （）的重载

代码如下（示例）：

     //重载（）运算符
    double operator()(double weight,double price)
    {
        return weight * price;
    }
    //希望能把  数组变成  int 类型
    //这一点要注意，int，就是要强制转换的类型要放在operator后面
     operator int()
    {
         return len;
    }    
    MyArray mdata(5);
    //这是由于单参构造组成的，但是如果加上了explicit,就不支持这种=15组成15个数组，防止隐式转换
    MyArray mdatas = 15;
    //()的第二种运用，可以强制类型转换
    cout << static_cast(mdata) << endl;
    cout << (int)mdata << endl;

    //自动识别（）
    cout << mdata(5, 1.2) << endl;

    cout << mdata.operator()(5, 1.2) << endl;  


     //运算符=的重载，是比较麻烦的，当然这里只是存在于，使用等号的两个数组的大小不一致的时候
    //MyArray& operator=(MyArray& ma)
    //{
    //    判断是不是自己赋值给自己
    //    先申请一段内存  拷贝被复制对象的内存数据
    //    释放自己的内存
    //    让指针指向新内存
    //    if (this != &ma)
    //    {
    //        len = ma.len;
    //        这里需要考虑一下，如果是先申请一段内存的话
    //        不能直接使用pdatas来申请内存，
    //        因为如果使用pdatas来申请内存，那么原先pdatas指向的那块内存就找不到了
    //        就出现内存泄露了
    //        int* ptemp = new int[len];
    //        memcpy(ptemp, ma.pdatas, sizeof(int) * len);
    //        delete[] pdatas;
    //        pdatas = ptemp;
    //    }
    //    return *this;

三、->和*运算符的重载

示例：->运算符的重载主要是让堆内存可以像栈内存一样，在不使用的时候，自己给他释放掉。

*运算符的重载主要是由于->运算符是将对象变成了指针，因此想要按照指针的形式调用里面的值。

使用步骤 ->与*的重载

代码如下（示例）：

#include 
#include 
using namespace std;

class A
{
public:
	A()
	{
		pi = new int(1);
		cout << "A()" << endl;
	};

	~A()
	{
		delete  pi;
		pi = NULL;
		cout << "~A()" << endl;
	};

	A(const A& a)
	{
		pi = new int(*(a.pi));
	};
	A operator=(A& a)
	{
		*pi = *(a.pi);
		return *this;
	}
	void show()
	{
		cout << "A show()" << endl;
	}
private:
	int* pi;
};

class MyAutoPtr
{
public:
	//初始化列表的顺序是，先谢了哪个成员变量先初始化谁
	MyAutoPtr( A* PA):pa(pa)
	{

	};
	~MyAutoPtr()
	{
		delete pa;
		pa = NULL;
	};
	//如何让当前类型支持->
	//想要让他支持->则它必须是一个A*的指针类型，因此返回值类型为A*
	A* operator->()
	{
		return pa;
	}
	//支持*类型的指针
	A& operator*()
	{
		return *pa;
	}

private:
	A* pa;
};



int main()
{
	{
		//由于在栈里面，他可以自己释放
		A a;
		//由于在堆里面，它并不能自由释放，因此引入智能指针使他能够即使在堆内存中也自己释放
		A* pa = new A();


		//他是memory 库当中的内容，是一个智能指针能够自动释放堆内存，在这里将pa交给了autoPtr来管理了
		auto_ptr autoPtr(pa);

		MyAutoPtr map(pa);
		//autoPtr是一个指针，但是他也是一个函数名
		(*autoPtr).show();
		autoPtr->show();

		//因为它并不能被当成指针，下面开始把它当成指针来对待
		map->show();

		(*map).show();

	}
}

---

总结

例如：运算符的重载主要有这几个[ ] ,( ), =等，其中=的最为麻烦，其他的都还好说，[ ]的使用场景是帮助数组内部的对空间可以使用下标读取写入堆内存空间数据，（ ）的使用场景包括，当作参数一样来调用，强制类型转换等等，是一个非常特殊的运算符，=的使用场景包括赋值等等；->与*运算符的重载主要使用在将堆内存像栈内存一样在不使用的时候自动释放掉，但是他只能对应于一个对象。