c++入门 this指针、类的成员函数

---

this指针

一、this指针的引出

1.引入库this指针作用：

C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。this指针尽量用const修饰的

识别类的顺序：（1）先识别类名；（2）识别数据成员；（3）改写函数成员

2.this指针的特性

1. this指针的类型：类类型* const
2. 只能在“成员函数”的内部使用
3. this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4. this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
using namespace std;
/*
this指针调用步骤
第一步： 识别类名 
第二部： 识别类中的成员变量
第三部： 识别成员函数，并对成员函数进行修改
*/
class Student
{
public: 
                            //  this指针--->类对象  永远指向的是当前对象
    //void SetStudentInfo(Student* this, char* name, char* gender, int age)
    void SetStudentInfo(char* name, char* gender, int age)
    {
        cout << this << endl;  //谁调用了这个函数就指向谁
        strcpy(_name, name);   //就相当于strcpy(this->_name,name);
        strcpy(_gender, gender);
        _age = age;            //this放的是对象的地址   
    }
    void PrintInfo()
    {
        cout << _name << " " << _gender << " " << _age << endl;
    }
private:
    char _name[20];
    char _gender[3];
    int  _age;
};
int main()
{
    Student s1, s2;
    s1.SetStudentInfo("zhangsan", "男", 14);
    s2.SetStudentInfo("lisi", "女", 5);
    return 0;
}

函数如果想要操作对象，就必须将类对象的地址传进来，否则没有办法对实参对象进行修改。因此，我们知道类的成员函数实际上也有一个隐藏的指针，指向了调用该函数的对象本身，我们把这个隐藏的指针就叫做是This指针，它的值就是当前被调用的成员函数所在的对象的起始地址。

二、类的6个默认成员函数

构造函数：主要完成初始化工作；
析构函数：主要完成清理工作；
拷贝构造：使用同类对象初始化创建对象；
赋值重载：把一个对象赋值给另一个对象；
取地址重载：：主要是普通对象和const对象取地址

1.构造函数

1.1 概念

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

1.2 特性

构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象，其特征如下：

1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

class Date
{
	public :
 	// 1.无参构造函数
 	Date ()
	 {}
	 
	 // 2.带参构造函数
	 Date (int year, int month , int day )
	 {
		 _year = year ;
		 _month = month ;
		 _day = day ;
	 }
	private :
		 int _year ;
		 int _month ;
		 int _day ;
	};
	void TestDate()
	{
		 Date d1; // 调用无参构造函数
		 Date d2 (2015, 1, 1); // 调用带参的构造函数
		 
	 // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
	 // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
	 Date d3(); 
}

2.析构函数

2.1 概念

前面通过构造函数的学习，我们知道一个对象时怎来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

2.2 特性

析构函数是特殊的成员函数。
其特征如下：

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值。
3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
5. 调用析构函数和构造函数的顺序：最先调用的构造函数，其对应的析构函数最后被调用；后调用的构造函数，其对应的析构函数最先被调用。简单记忆：“先构造的后析构，后构造的先析构”，类似于栈，先进后出

typedef int DataType;
class SeqList
{ 
public :
 SeqList (int capacity = 10)
 {
 _pData = (DataType*)malloc(capacity * sizeof(DataType));
 assert(_pData);
 
 _size = 0;
 _capacity = capacity;
 }
 
 ~SeqList()
 {
 if (_pData)
 {
 free(_pData ); // 释放堆上的空间
 _pData = NULL; // 将指针置为空
 _capacity = 0;
 _size = 0;
 }
 }
 
private :
 int* _pData ;
 size_t _size;
 size_t _capacity;
};

3.拷贝构造函数

3.1 概念

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。拿对象初始化对象时，为拷贝构造函数。

3.2 特性

拷贝构造函数也是特殊的成员函数，其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。
3. 参数必须使用类类型对象引用传递

class Date
{
public:
 Date(int year = 1900, int month = 1, int day =1)//构造函数
 {
	 _year = year;
	 _month = month;
	 _day = day;
 }
 Date(const Date& d)//拷贝构造函数，用Data去初始化它本身，两者实质是一样的
 {
	 _year = d._year;
	 _month = d._month;
	 _day = d._day;
 }
private:
	 int _year;
	 int _month;
	 int _day;
};
int main()
{
	 Date d1;
	 Date d2(d1);
	 return 0;
 }

4.运算符重载

4.1 概念

运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

class Complex
{
public:
//参数列表初始化
	Complex(int real = 0,int img = 0 : m_real(real),m_imag(imag))
	{}
	//赋值语序
Complex& operator=(const Complex &C)
{
	if(this != &c)
	{
		m_real=c.m_real;
		m_imag=c.image;
	}
	return *this;
}
	~Complex()
	{}
public:
	Complex operator+(const Complex &c)//成员函数，需要对象驱动，否则无法调用，这里第一个参数省略，由this指针直接进行传递
	{	
		return Complex tmp(m_real+c_real,m_imag+c_imag);	
	}
private:
	int m_real;
	int m_imag;
};
//运算符重载，赋给新的含义,它只是个特殊的函数
void main()
{
	Complex c(1,3),c2(2,5);
	Complex c;
	c = c1 + c2;//+号赋给新的含义
	//c = c1.operator+(c2);本质上
	
}

4.2 特性

注意：
（1）不能通过连接其他符号来创建新的操作符：比如operator@
（2）重载操作符必须有一个类类型或者枚举类型的操作数
（3）用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义
（4）作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参
（5）.* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。（成员指针访问运算符、作用域运算符、长度运算符、三目运算符、成员访问运算符均不能重载）记忆：带点的符号要注意

4.3 赋值运算符重载

友元函数

friend void fun(const Test &t);//友元函数其对象可以直接访问私有数据
friend void operator+(int val,const Complex &c);//友元函数声明加法，需要传递两个参数

成员函数在进行运算符重载时，只需要传递一个参数，另一个参数是由this指针直接传递的
友元函数在进行运算符重载时，需要传递两个参数

int& operator++()    //++a 返回当前对象，所以引用返回 无参为前++
{
   m_i++;
   return *this; 
}
operator++(int i)  //a++  有参数为后++，参数必须为整型
{
   int tmp(*this)//调用拷贝构造函数
   m_i++;
   return tmp; 
}

int& operator--()    //--a 返回当前对象，所以引用返回 无参为前--
{
   m_i--;
   return *this; 
}
operator--(int i)  //a--  有参数为后--，参数必须为整型
{
   int tmp(*this)//调用拷贝构造函数
   --*this;//*this是当前对象，当前对象再--
   return tmp; 
}

i++和++i的区别：前++效率高于后++，因为不产生临时对象。
不带整型参数就是++i（前++），带整型参数就是i++(后++)

//强制类型转换
operator int()
{
	return m_data;
}
private:
int m_data;
void main()
{
	Test t;
	t = (Test)100;
	int value  = t;
}

类里面的六个常用函数 重点重点敲敲黑板

class Test
{
public:
   Test();//构造函数
   Test(const Test &);//拷贝构造函数
   Test& operator=(const Test &); //赋值语句
   ~Test();//析构函数
   Test* operator&();//取地址运算符
   const Test* operator&()const;//常对象的取地址运算符
};

赋值运算符主要有四点：offer p24

1. 参数类型
2. 返回值
3. 检测是否自己给自己赋值
4. 返回*this
5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

string& operator=(const& string &s)
{
  if(this!=&s)
  {
  free(m_data);
  m_data=(char*)malloc(strlen(s.m_data)+1);
  assert(m_data!=NULL);
  strcpy(m_data,s.m_data);
  }
  return *this;
}

浅拷贝：只拷贝一个指向，没有拷贝空间。
深拷贝：拷贝了指向和空间，获得了新空间。
异常安全：程序发生异常后，代码还可以维持状态稳定。（剑指offer p24）