学习第59天

C++

1. 类型转换构造函数、

   1. 通过转换构造函数和类型转换运算符来做到类型转换、

   2. 主要功能是将其它类型的数据转换成该类类型的对象、

   3. class t
      {
      public:
      	//explicit//禁止隐式类型转换
      	explicit t(int x = 0) :m(x)//类型转换构造函数、可以将一个整型（int）转换成类类型（t）
      	{
      		if (m < 0)m = 0;
      		if (m > 50)m = 50;
      	}
      	int m;//定义成员变量、
      };
      int main()
      {
      	t ta = 10;//隐式类型转换、将10转换成t的对象、调用类类型转换构造函数、加上explicit显示错误、
      	t tb(20);//虽然调用了类型转换构造函数、但是没有进行隐式类型转换、加上explicit未显示错误、
      

   5. 只有一个参数、参数不是本类的const引用、是待转换的数据类型、

2. 类型转换运算符（类型转换函数）

   1. 显示类型转换运算符、

   2. 类对象转换为函数指针、

   3. 能力和类型转换构造函数相反、

   4. 特殊的成员函数、能将一个类类型对象转换成其它数据类型、

   5. operator type（）const——类型转换运算符、括号内为空

      1. const可选、const表示一般不应该改变转换对象内容、但不是必须有const、

      2. type 表示要转换成的某种类型、只要能够作为函数返回的类型都是可以的、（数组指针、函数指针、引用等均可）

      3. 类型转换运算符没有形参、因为一般都是隐式执行、也没办法传递、同样也无法指定返回类型、可以正常的返回type指定的值、

      4. 必须定义为类的成员函数、

      5. class t
         {
         	typedef void	(*tt)(int);//定义函数指针类型、带有一个形参、没有返回类型
         public:
         	static void mc(int v)//静态的成员函数、不依赖对象依赖于类、
         	{
         		int te;
         		te = 5;
         	}
         	operator tt()//新的类型转换运算符、将本类类型对象转换成一个函数指针、
         	{
         		return mc;//必须要返回一个函数指针、函数地址（函数名）便可作为函数指针的返回类型、
         	}
         public:
         	 t(int x = 0) :m(x)//
         	{
         		if (m < 0)m = 0;
         		if (m > 50)m = 50;
         	}
         	 operator int() const//类型转换运算符、
         	{
         		return m;
         	}
         	int m;//定义成员变量、
         };
         int main()
         {
         	t ta= 10;
         	t tb=60;//编译器用60生成临时的t对象（调用t类型转换构造函数）、又调用赋值运算符将临时对象的内容给了tb
         	//int k = tb + 20;//隐式调用
         	int k = static_cast<int>(tb) + 20;//显示强制类型转换符、
         	int k1 = tb.operator int () + 5;//显示调用、没有形参、
         	t mi (12);
         	mi(12);//调用类型转换运算符、转换成函数指针类型、返回函数地址、 有函数地址后再去调用静态成员函数、
         }
         

3. 类型转换的二义性问题、

   1. 编译器不明确转换成哪一种类型、

4. 类成员函数指针、

   1. 指向类成员函数的指针、

   2. 普通成员函数、

      1. 声明普通成员函数指针

         1. 类名：：*函数指针变量 名

      2. 获取类成员函数地址

         1. &类名：：成员函数名、——真正的内存地址、

      3. 使用函数指针——类对象名.*函数指针变量名、如果是对象指针则是指针名->函数指针变量名

      4. class c
         {
         public:
         	void pc(int te)
         	{
         		cout<<"pc普通函数调用"<<te<<endl;
         	}
         	virtual void vc(int te)
         	{
         		cout << "vc虚函数调用" << te << endl;
         	}
         	static void sc(int te)
         	{
         		cout << "sc静态函数调用" << te << endl;
         	}
         };
         int main()
         {
         	void (c:: * mt)(int);//定义类成员指针变量、成员函数是属于类的、不属于对象、只有类就有成员函数地址、
         	mt = &c::pc;//要使用成员函数指针就必须绑定到一个类对象上才能调用、
         	c ca,* pt;
         	pt = &ca;
         	(ca.*mt)(20);//针对ca对象的成员函数、
         	(pt->*mt)(20);//调用指针对象
         }
         

   3. 虚函数、

      1. 	void (c:: * ml)(int) = &c::vc;
         	(ca.*ml)(10);
         	(pt->*ml)(20);
         

   4. 静态成员函数、

      1. void (*mc)(int) = &c::sc;
         	mc(40);//直接调用
         

5. 类成员变量指针、

   1. 普通成员变量、

      1. 不是真正意义上的指针、指向的并非是地址、指向的是成员变量、于类对象指针之间的偏移量、

      2. 类中有虚函数的话就会生成虚函数表、虚函数表是属于类、和对象没有关系、

      3. class c
         {
         public:
             int	ma;//普通成员变量、
             };
         int main()
         {
         int c::*mp = &c::ma;//直接定义类成员变量指针
         	c ct;
         	ct.*mp = 70;//通过类成员变量指针来修改成员变量值、 相当于是mp=70、
             }
         

   2. 静态成员变量、

      1. 属于类、是真正的地址、

      2. class c
         {
         public:
             static int msa;//静态成员变量属于类、
         };
         int c::msa = 5;//定义静态成员变量
         int main()
         {
         int* sp = &c::msa;
         	*sp = 123;   
         }