[C++知识库]C++特殊成员

C++特殊成员

提示：以下是本篇文章正文内容，下面案例可供参考

一、const成员

1.const数据成

• const类型变量是不可以修改的
• 必须采用初始化参数列表方式进行初始化

#include <iostream>
#include <string>
using namespace std;

class Stu
{
public:
	Stu(string name, int num) :num(num)
	{
		Stu::name = name;	//可以用，也可以不用初始化列表
		//stu::num = 1001;	必须要用初始化参数列表的方法初始化
	}
	void print()
	{
		//num = 1001;	只读，不能修改
		cout << name << "  " << num << endl;
	}
protected:
	string name;
	const int num;	//const数据成员

};
int main()
{
	Stu lisi("lisi", 18);
	lisi.print();
	while (1);
	return 0;
}

运行结果：

2.const成员函数

• 写法上，const写在函数后面
• 常成员函数是不能够修改数据成员，制度数据成员
• 常曾元函数可以与普通函数同时存在
  普通函数和常成员函数相同时，普通对象优先调用普通函数
  普通对象可以调用常成员函数

3.const对象：const修饰的对象

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

#include <iostream>
#include <string>
using namespace std;

class Stu
{
public:
	Stu(string name, int num) :num(num)
	{
		Stu::name = name;	//可以用，也可以不用初始化列表
		//stu::num = 1001;	必须要用初始化参数列表的方法初始化
	}
	void printData()
	{
		cout << name << "\t" << num << endl;
	}
	void print()
	{
		//num = 1001;	只读，不能修改
		cout << name << "  " << num << endl;
	}
	//常成员函数
	void print()const
	{
		// name = "修改"; 错误 常成员函数不能修改数据
		// num =199 ;
		cout << name << "\t" << num<<endl;
		cout << "常成员函数" << endl;

	}
protected:
	string name;
	const int num;	//const数据成员
};
int main()
{
	Stu lisi("lisi", 18);
	lisi.print();			//普通对象调用普通函数
	const Stu zhangsan("常对象",20);	//常对象调用常成员函数
	zhangsan.print();
	//zhangsan.printData();		错误！常对象只能调用普通函数
	while (1);						
	return 0;
}

运行结果：

二、static成员

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

1.static数据成员

• 必须在类外初始化，类外初始化不再需要static修饰，但是需要类名限定
• 类中初始化是错误的，不能采用初始化参数列表方式初始化

#include <iostream>
#include <string>
using namespace std;

class STU
{
public:
	STU(string name, int num) :name(name)
	{

	}
protected:
	string name;
public:
	static int num;	//静态数据成员不允许在类中初始化
};
//类外初始化,不再需要static修饰，但是需要类名限定
int STU::num = 100;
int main()
{
	//静态数据成员的访问,可以不需要对象
	cout << STU::num << endl;


	while (1);
	return 0;
}

运行结果：

• 共有

#include <iostream>
#include <string>
using namespace std;

class STU
{
public:
	STU(string name="") :name(name)
	{
		num++;
	}
protected:
	string name;
public:
	static int num;	//静态数据成员不允许在类中初始化
};
//类外初始化,不再需要static修饰，但是需要类名限定
int STU::num = 1;
int main()
{
	//静态数据成员的访问,可以不需要对象
	cout << STU::num << endl;
	//什么叫做共有
	STU lisi("lisi");
	//静态数据成员可以通过对象去访问
	cout << lisi.num << endl; //此时num等于2
	STU array[3];			 //5
	STU* p = new STU("newSTU");	//6
	cout << STU::num << endl;	
	cout << p->num << endl;
	cout << lisi.num << endl;
	delete p;
	p = nullptr;
	while (1);
	return 0;
}

运行结果：

2.static成员函数

• static写在函数前面即可
• 调用非静态成员，必须要指定对象

#include <iostream>
#include <string>
using namespace std;

class STU
{
public:
	STU(string name="") :name(name)
	{
		num++;
	}
	static void printSTU();
	static void pirntData(STU& lisi)
	{
		cout << lisi.name << "\t" << lisi.num << endl;
	}
protected:
	string name;
public:
	static int num;	//静态数据成员不允许在类中初始化
};
//类外初始化,不再需要static修饰，但是需要类名限定
int STU::num = 1;
//类外初始化,不再需要static修饰
void STU::printSTU()
{
	
	//调用非静态成员，必须要指定对象
	//cout << name << endl; 当这个函数不采用对象去调用，name没有来源
	//静态调用数据，没有什么要求
	cout << num << endl;
	cout << "静态成员函数" << endl;
}
int main()
{
	//静态数据成员的访问,可以不需要对象
	cout << STU::num << endl;
	//什么叫做共有
	STU lisi("lisi");
	//静态数据成员可以通过对象去访问
	cout << lisi.num << endl; //此时num等于2
	STU array[3];			 //5
	STU* p = new STU("newSTU");	//6
	cout << STU::num << endl;	
	cout << p->num << endl;
	cout << lisi.num << endl;
	delete p;
	p = nullptr;
	STU::printSTU();
	lisi.pirntData(lisi);
	while (1);
	return 0;
}

3.static对象

• 释放最后释放的

三、友元

友元？用friend描述的关系。友元只是提供一个场所，赋予对象具有打破类权限限定（无视权限）

1.友元函数

• 普通的友元函数

#include <iostream>
#include <string>
using namespace std;
void printData();
class STU
{
public:
	STU(string name, int age) :name(name), age(age)
	{

	}
	friend void printData()
	{
		//不属于类，不能直接访问
		//cout << name << "\t" << age << endl;
		STU lisi("lisi", 29);
		//友元函数提供一个场所，让对象无视权限
		cout << lisi.name << "\t" << lisi.age << endl;
	}
	void print()
	{
		cout << name << "\t" << age << endl;
	}
	string name;
protected:
	int age;
	friend void printData2(STU& lisi);
};
//不需要friend修饰，不需要类名限定
void printData2(STU& lisi)
{
	cout << lisi.name <<"\t"<< lisi.age << endl;
}
int main()
{
	STU lisi("lisi", 19);
	lisi.print();
	printData2(lisi);
	printData();
	while (1);
	return 0;
}

运行结果：

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

#include <iostream>
#include <string>
using namespace std;
//向前声明
class B
{
public:
	void printA();
	void printData();
protected:

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

运行结果：

2.友元类

#include <iostream>
#include <string>
using namespace std;

class STU
{
friend class STUD;
public:
	STU(string name, int age) :name(name), age(age)
	{}
protected:
	string name;
	int age;
};
class STUD
{
public:
	void print()
	{
		STU lisi("lisi", 18);
		cout << lisi.name << "\t" << lisi.age<<endl;
	}
	void printSTUD(STU& lisi)
	{
		cout << lisi.name << "\t" << lisi.age << endl;
	}
protected:

};
int main()
{
	STU lisi("lisi", 18);
	STUD zhangsan;
	zhangsan.print();
	zhangsan.printSTUD(lisi);

	while (1);
	return 0;
}

运行结果：

4、this指针与explicit

explicit

• 修饰构造函数使用，不让隐式转换使用

#include <iostream>
#include <string>
using namespace std;


class STU
{
public:
	explicit STU(int age) :age(age)
	{

	}
	void print()
	{
		cout << age << endl;
	}
protected:
	int age;
};

int main()
{
	//explicit 不让隐式转换构造
	//STU lisi = 12;
	//STU temp = 1.33;
	STU temp(12);
	temp.print();
	while (1);
	return 0;
}

运行结果：

2.this指针

• 避免形参名和数据成员同名，通指对象的地址
• 充当函数返回值，返回对象自身，用*this表示对象本身
• 静态成员函数中是不能使用this指针的

#include <iostream>
#include <string>
using namespace std;
class STU
{
public:
	STU(string name, int age) :name(name), age(age){}
	//普通函数不存在初始化参数列表
	void initprintData(string name,int age)
	{
		//类名限定帮助计算机去识别
		STU::name = name;
		this->age = age;
	}
	void print()
	{
		cout << name << "\t" << age << endl;
	}
	void printThis()
	{
		cout << this << endl;
	}
	//对象本身
	STU returnSTU()
	{
		return *this;
	}
	//静态的成员对象是没有this指针的
	/*static void printStatic()
	{
		cout << this->name << "\t" << this->age << endl;
	}*/
protected:
	string name;
	int age;
};

int main()
{
	STU lisi("李四", 18);
	lisi.print();
	lisi.initprintData("张三", 18);
	lisi.print();
	cout << &lisi << endl;
	lisi.printThis();
	STU wangwu("王五", 18);
	cout << &wangwu << endl;
	wangwu.printThis();
	lisi.returnSTU().returnSTU().returnSTU().print();

	while (1);
	return 0;
}

运行结果：