C++ const static friend this指针

C++ const static friend this指针

const  数据成员

        const类型变量不可修改，只读模式

        必须采用初始化参数列表方式进行初始化

        其他数据成员是否采用初始化参数列表随意

const 成员函数

        写法上 const写在函数后面

        常成员函数是不能够修改数据成员，只能读数据成员

        常函数可以与普通函数同时存在

                普通对象优先调用普通函数

                普通对象可以调用常成员函数

const 对象   const修饰的对象称为常对象

        常对象只能调用常成员函数

#include
using namespace std;

class MM
{
public:
	MM(string name, int num) :num(num)
	{
		MM::name = name;//用不用初始化参数列表随意
		//MM::num=1001;  只能采用初始化参数列表的方式初始化
	}
	void print()
	{
		//num = 1002;//不可修改		只读模式
		cout << name << "t" << num << endl;
	}
	//普通函数
	void printData() 
	{ cout << "普通函数" << endl; }
	//常成员函数
	void printData()const
	{
		//常成员函数内不可修改数据成员
		//name = "bala";
		//num = 2324;
		cout <<"常成员函数" << endl;
	}
	//同名同参同样可以
	void printData2(string name) {}
	void printData2(string name)const {}
protected:
	string name;
	const int num = 1001;	//const 数据成员  可进行初始化 ，可使用但不可修改
};

int main()
{
	MM mm("小飞",23);
	mm.print();
	mm.printData();		//把普通函数注释掉 会调用常成员函数
	
	const MM cmm("小一",34);
	cmm.printData();//  常对象调用常成员函数
	//cmm.print();	
	return 0;
}

static 成员

static成员 不属于对象，属于类，意味着所有对象共有的，调用可以不需要对象

        static 数据成员

                必须在类外初始化（类中不可以，即使是参数列表方式也不可）

                类外初始化不需要static修饰，但需要类名限定

                静态数据成员的访问依然受权限限制，（protected下的num 类外不可访问）

        static 成员函数

                static写在函数前面即可

                类内，类外实现均可

                调用非静态成员 必须要指定对象

                调用静态成员，用不用对象都可以

        static对象

                释放是最后释放的

#include
using namespace std;

class MM
{
public:
	MM(string name="") :name(name)
	{
		count++;
	}
	//静态成员函数 
	static void print();
protected:
	string name;
	static int num ;	
public:
	static int count;
};
// 类外初始化不需要static修饰，但需要类名限定
int MM::num = 234;
int MM::count = 1234;
//类外实现不需要static修饰，但需要类名限定
void MM::print()
{
	//调用非静态数据成员，必须要指定对象
	//cout << name << endl;  //当这个函数不采用对象去调用，name是谁的不确定

	//静态函数调用静态数据成员 用不用对象均可
	cout << count << endl;
	cout << "静态成员函数" << endl;
}
int main()
{
	//静态数据成员的访问可以不需要对象 
	cout<count << endl;
	cout << mm.count << endl;
	delete p;
	p = nullptr;

	//静态成员函数
	MM::print();
	mm.print();


	return 0;
}

友元

用friend修饰 友元只是提供一个场所，赋予对象具有打破类的权限定(无视权限)

注意：只是在友元函数内部才能不受权限限制访问

        友元函数

                普通友元函数

                以另一个类的成员函数充当友元函数，顺序如下

                        B类

                        A类

                        A类的友元函数（B类的成员函数）

#include
using namespace std;
 void print();
class MM
{
public:
	MM(string name, int age) :name(name), age(age)
	{
	
	}
	//类中实现不传参  需要加前置声明
	friend void print()
	{
		//不属于类，不能直接访问成员
		//cout << name << age << endl; //错误
		MM mm("好丽友",23);
		//友元函数提供了一个场所，让对象无视权限
		cout << mm.name << mm.age << endl;
	}
	//类中实现传参
	friend void print(MM& mm)
	{
		//不属于类，不能直接访问成员
		//cout << name << age << endl; //错误
		//MM mm("好丽友",23);
		//友元函数提供了一个场所，让对象无视权限
		cout << mm.name << mm.age << endl;
	}
protected:
	string name;
private:
	int age;
	friend void printData2(MM& mm);
};
//类外实现 不需要friend修饰，不需要类名限定
void printData2(MM& mm)
{
	//打破权限
	cout << mm.age <<"t" << mm.name << endl;
}
void printData(MM& mm)
{
	//普通函数  无法访问
	//cout << mm.age << "t" << mm.name << endl;
}
int main()
{

	//直接调用 没有权限限制 无需对象 无需类名
	MM mm("小鱼",23);
	print();  //没有传参这种情况类中实现会报错，  解决方法 加前置声明
				//传参类中类外都可
	//print(mm);//传参这种情况类中可以实现
	printData(mm);

	return 0;
}

  以另一个类的成员函数充当友元函数   代码

#include
using namespace std;

class A
{
public:
	void printA();
protected:

};

class B
{
public:
	friend void A::printA();
protected:
	string name = "AA";
};
//成员函数的实现一定是在另一个类的下面实现
void A:: printA()
{
	B a;
	cout << a.name << endl;
}


int main()
{
	A a;
	a.printA();

	return 0;
}

友元类

#include 
using namespace std;
class MM 
{
	friend class GG;
public:
	MM(string name, int age) :name(name), age(age) {}
protected:
	string name;
	int age;
};
class GG 
{
public:
	void print() 
	{
		MM mm("mm", 18);
		cout << mm.name << "t" << mm.age << endl;
	}
	void printMM(MM& mm) 
	{
		cout << mm.name << "t" << mm.age << endl;
	}
	MM& returnMM(MM& mm) 
	{
		return mm;
	}
protected:
};

int main()
{
	MM mm("mm", 18);
	GG gg;
	gg.print();
	gg.printMM(mm);
	//cout << gg.returnMM(mm).name << endl;  错误，出了友元类，没有权限

    return 0;
}

explicit

只用于 构造函数，  不让隐式转换构造

#include
using namespace std;

class MM
{
public:
	explicit MM(int age) :age(age) {}
	void print()
	{
		cout << age << endl;
	}
protected:
	int age;
};
int main()
{
	//不加explicit 发生隐式转换
	//隐式转换
	

	return 0;
}

this指针

        避免形参名和数据成员同名，通指对象的地址

        充当函数返回值，返回对象本身。用*this表示对象本身

        静态成员函数中是不能使用this指针

#include
using namespace std;

class MM
{
public:
	MM(int age) :age(age) {}
	void initData(int age)
	{
		this->age = age;
	}
	void print()
	{
		cout << age << endl;
	}
	void printThis()
	{
		cout << this << endl;
	}
	//返回对象本身		返回类型是否是引用类型无所谓
	MM returnMM()
	{
		return *this;
	}
	//  静态成员没有this指针
	static void printStatic()
	{
		//cout << this->name << "t" << this->age << endl;
	}

protected:
	int age;
};
int main()
{
	MM mm(23);
	mm.print();
	mm.initData(234);
	mm.print();
	cout << &mm << endl;
	mm.printThis();

	MM xiaoyang(232);
	cout << &xiaoyang << endl;
	xiaoyang.printThis();

	mm.returnMM();//返回是mm
	mm.returnMM().returnMM().returnMM().print();

	return 0;
}