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未显示错误、
      
    4. 只有一个参数、参数不是本类的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;   
        }
        
内容来源于网络如有侵权请私信删除