类概述介绍

一、相关概念
1.类函数
定义在类中的函数必须先在类中作原型声明，然后在类外定义，两者顺序不能颠倒。
2.类对象指针
指针型的类对象，是一个指针变量，可用于保存类对象在内存中存储空间的首地址。可通过类对象指针调用对象中的方法，相当于指针调用。
3.const成员函数
类中不改变数据的成员函数，用const进行标识，也称只读函数。
4.访问控制
类中成员与普通变量、函数的区别在于其访问权限的控制是由类内部定义的。
包括私有成员-private (只允许本类的成员函数访问，类外部的访问都是非法的)，公有成员-public (任何来自类外部的访问都必须通过该成员才能访问，实质是类的外部接口)，保护成员-protected (与私有类型性质一致)
二、对对象的操作
1.访问格式：
对private访问：只有该类中的成员可以对其进行访问。成员.访问属性/方法
对public数据访问：外部类中的成员可以对其进行访问，成员.访问属性
对public方法/函数访问：类型+类名：：+成员名称
2.直接访问数据改变对象属性
前提是数据是公有类型，安全性低，一般不使用

#include
using namespace std;
class Clock{//定义一个类 
	public://共有类型：成员能被其它类的函数直接访问、调用
		int hour,minute,second;//成员数据 
	public://公有成员：其它类的成员可通过公有成员访问内部数据,相当于外部接口 
		void setTime(int H,int M,int S);//成员函数的声明 
		void showTime();
};
void Clock::setTime(int h,int m,int s) {//通过访问成员函数对其进行定义 
	hour=h;minute=m;second=s;
}
void Clock::showTime(){
	cout<<"time  "<<hour<<":"<<minute<<":"<<second<<endl;
}
int main()
{
	Clock time;//定义一个Clock实体类，即一个Clock对象 
	time.hour=7;//直接访问数据，对数据进行操作 
	time.minute=27;
	time.second=37; 
	time.showTime();
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.调用函数改变属性
数据是私有类型，只能通过调用公有型方法进行改变

#include
using namespace std;
class Clock{//定义一个类 
	private://私有类型：成员不能被其它类的函数直接访问、调用，必须通过公有型函数进行访问 
		int hour,minute,second;//成员数据 
	public://公有成员：其它类的成员可通过公有成员访问内部数据,相当于外部接口 
		void setTime(int H,int M,int S);//成员函数的声明 
		void showTime();
};
void Clock::setTime(int h,int m,int s) {//通过访问成员函数对其进行定义 
	hour=h;minute=m;second=s;
}
void Clock::showTime(){
	cout<<"time  "<<hour<<":"<<minute<<":"<<second<<endl;
}
int main()
{
	Clock time;//定义一个Clock实体类，即一个Clock对象 
	Clock *clock;//定义一个Clock对象指针 
	clock=&time;//存放Clock对象-time的首地址 
	time.setTime(9,10,30); //调用time对象中的方法 
	//time.showTime();
	clock->showTime();//可通过指针调用time对象中的方法 
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

三、静态成员
为了实现数据之间共享，类的静态成员是属于类的，因此外部成员不能对其进行访问。
1.静态数据成员
多个对象所共有的，存储在固定内存空间，供所有该类的对象共同使用。
静态数据是静态存储的，具有静态生存期，必须对其进行初始化
定义：static 类型 成员变量名
初始化格式：返回类型 作用域类名：：静态数据成员名

#include
using namespace std;
class Myclass{//定义类 
	private:
		int a,b,c;
		static int sum;//定义静态成员变量 
	public:
		void Myclass1(int a,int b,int c);
		void GetSum(){//直接在类内部对其进行定义
	cout<<"sum="<<sum<<endl;
};
};
int Myclass::sum=0;//通过静态访问，初始化静态成员变量 
void Myclass::Myclass1(int A,int B,int C)//形参，通过形参将实参值传入 
{//访问函数并对其进行定义 
	a=A;b=B;c=C;
	sum+=a+b+c;
}
int main()
{
	Myclass m;
	m.Myclass1(1,2,3);
	m.GetSum(); 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.静态成员函数
声明格式：static 类型 函数名();
访问格式：与对public函数访问相同
调用/使用对象函数时无需用对象名
调用格式：类域名::静态成员函数名(参数列表);

#include
using namespace std;
class M{
	private:
		int A;
		int B=1;
	public:
	    void M1(int a){
			A=a;B+=a;
		}
		static void f(M m);//声名静态成员函数 
};
void M::f(M m)
{//定义函数 
	cout<<"A="<<m.A<<endl;
	cout<<"B="<<m.B<<endl;
}
int main()
{
	M m1,m2;
	m1.M1(1);
	m2.M1(3);
	M::f(m1);//调用静态成员函数 
	M::f(m2);
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

四、友元
可直接调用类中的保护成员(protected)，但其不具有交换性和传递性。
声明：friend 类型 外部函数名(参数列表) ;

#include
#include
using namespace std;
class A{
	protected:
		char name[20];
		char address[20];
	public:
		B(char *name,char *addr)
		{
			strcpy(A::name,name);
			strcpy(A::address,addr);
		}
	friend void show(A a);//声明一个友元函数 
};
void show(A a){//函数定义
	cout<<a.name<<endl;//访问保护数据类型 
	cout<<a.address<<endl;
}
int main()
{
	A a1;
	a1.B("你好","C++");
	show(a1);
 } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25