C++特殊成员_随笔

C++特殊成员 C++特殊成员

文章目录

- C++特殊成员
一、const成员
- 1.const数据成
- 2.const成员函数
- 3.const对象：const修饰的对象
二、static成员
- 1.static数据成员
- 2.static成员函数
- 3.static对象
三、友元
- 1.友元函数
- 2.友元类
4、this指针与explicit
- explicit
- 2.this指针

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

一、const成员 1.const数据成

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

#include 
#include 
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 
#include 
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< 
运行结果：
  
二、static成员 
 **static成员它是不属于对象，是属于类的，意味着是所有对象共有的，调用可以不需要对象，
 当然你可以用对象调用，static成员依旧受权限限定。**
 
1.static数据成员 
必须在类外初始化，类外初始化不再需要static修饰，但是需要类名限定
类中初始化是错误的，不能采用初始化参数列表方式初始化 
#include 
#include 
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 
#include 
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 
#include 
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 
#include 
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 
#include 
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 
#include 
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< 
运行结果：
  
4、this指针与explicit 
explicit 
修饰构造函数使用，不让隐式转换使用 
#include 
#include 
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 
#include 
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指针的
	
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;
}
 
运行结果：
 					
										


					
						欢迎分享，转载请注明来源：内存溢出
原文地址: http://outofmemory.cn/zaji/5594855.html

C++特殊成员

发表评论

评论列表（0条）