初学c++（3）之类的特殊成员

系列文章目录

---

文章目录

• 系列文章目录
• 前言
• 一、const成员
• 二、static成员
• 三、友元
• 四、this指针与explicit
• 总结

---

前言

c++中的类中存在许多的特殊成员，它们有许多的特殊权限，在以后的使用中会让你很方便；本篇介绍几个常用的特殊成员；

---

一、const成员

• const数据成员

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

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

例：

class P
{public:
	P(int po):po(po)//以参数列表方式初始化
	{}
protected:
	const int po;
private:};
int main()
{
P one（9）;
}

• const成员函数

  • 写法上, const写在函数后面

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

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

    • 普通函数和常成员函数相同时,普通对象优先调用普通函数

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

• const对象： const修饰的对象

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

class P
{public:
	P(int po):po(po)
	{}
	void shuru()const
	{
		cout << "常量" << endl;
	}
	void shuru()
	{
		cout << "变量"<<"   "<<po<<endl;
	}

protected:
	const int po;
private:};

int main()
{
	P pi=190;
	pi.shuru();//普通对象可以调用const类型的函数，但当两个函数同名时默认调用普通函数；
	const P pii = 1000;
	pii.shuru();//const类型的对象只能调用const类型的函数；
}

二、static成员

static成员是不属于对象，是属于类的，意味着是所有对象共有的，调用可以不需要对象，当然你可以用对象调用但static成员依旧受权限限定

• static数据成员

  • 必须在类外初始化，不再需要static修饰，但是需要类名限定

  • 类中初始化是错误的，不能采用初始化参数列表方式初始化

• static成员函数

  • static写在函数前面即可

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

• static对象

  • 释放是最后释放的

例：

class P
{public:
	P(int po):po(po)//不能使用初始化参数列表方式初始化static类型的数据，并只能在类外初始化
	{
		
	}
	
	static void prin(P& i)
	{
		i.shuru();//static的属性的函数或数据是所以类公有的所以无法直接调用对象的数据，必须要指定对象；
	}
	
static int id;//所有的类都可以使用此变量；
protected:
	
	const int po;
private:};

 int P::id = 20;//初始化，注意：没初始化前无法使用

int main()
{
   
	P pi=190;
	
	
	pi.id = 5;    P::id = 6;//这两种方法使用的变量是同一个；
}

三、友元

友元可赋予对象具有打破类的权限定(无视权限)；

友元函数可以直接访问类中的保护属性下的数据

例子

class P
{public:
	friend void teshe(P& i);//也可以在类中定义但要在类外部作声明否则会找不到函数；
	P(int po):po(po)
	{
		
	}

protected:
	
	const int po;
private:};

void teshe(P& i)
{
	cout << i.po;//直接访问保护属性下的数据；
}

int main()
{ 
	P pi=190;
	teshe(pi);//调用友元函数，不需要对象引用直接就可以访问对象
	const P pii = 1000;
}

 也可以在一个类中访问另外一个类的数据；

class A
{friend class B;
public:
	void youyanA(B& i);//访问了B的保护数据

protected:
	int AA=10;
private:
};

class B
{friend class A;
public:
	void youyanB(A& i)
	{
		cout << i.AA << endl;//访问了A的保护数据
	}
protected:
	int BB=5;
private:
};

void A::youyanA(B& i)//定义一定要在类创建之后
{
	cout << i.BB << endl;
}

int main()
{
	A a;
	B b;
	b.youyanB(a);
	a.youyanA(b);
	return 0;
}

四、this指针与explicit

this指针只能在类中使用，指向所用类；

使用例子：

class B
{
public:
	
	void print(int BB)
	{
		this->BB = this->BB + BB;//可区别变量与对象的数据
		cout << this->BB;
	}
	B peing()
	{
		return *this;//可当返回值
	}
protected:
	int BB=5;
private:
};

explicit构造类函数传值时发生隐式转换，将explicit写在构造函数前即可；

class A
{public：
explicit A(int y):A(y){}
protected:
	int AA=5;
private:
}
int main
{

//A ai=10//会产生错误
A ai(10)//只能采用这种方式创建对象
return 0;}

---

总结

本篇介绍了在类中常用的特殊成员；