static成员
声明为static
的类成员称为类的静态成员,用static
修饰的成员变量,称之为静态成员变量;用static
修饰的成员函数,称之为静态成员函数。静态的成员变量一定要在类外进行初始
1.静态成员变量是被所有该类对象共享的,并不仅属于某个具体的对象
2.静态成员变量必须在类外定义,定义时且不可以添加 static
关键字
3.类静态成员访问方式
类名::静态成员
、对象.静态成员
4.由于静态成员函数没有隐藏的this
指针,故不能访问任何非静态成员
5.静态成员和类的普通成员一样,也有public
、protected
、private
三种访问级别,同样也可以有返回值、const
修饰符等参数
非静态成员函数可以调用静态成员函数,但静态成员函数不可以调用非静态成员函数
原因:
1.静态成员函数只属于类本身,随着类的加载而存在,不属于任何对象,是独立存在的
2.非静态成员当且仅当实例化对象之后才存在,静态成员函数产生在前,非静态成员函数产生在后,故不能访问
3.内部访问静态成员用类名::静态成员
,而访问非静态成员要用this
指针,静态成员函数没有this
指针,故不能访问。
static
的作用
1.修饰局部变量,改变其生命周期
2.修饰全局函数,全局变量,改变链接属性,只在当前文件可见
3.修饰成员函数,成员函数没有this
指针,该成员函数属于整个类,使用类名就可以调用
4.修饰成员变量,属于整个类,使用类名就可以访问
友元
友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用
友元函数
友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声
明,声明时需要加friend
关键字。
class Date
{
friend ostream& operator<<(ostream& _cout, const Date& d)
{
_cout << d._year << "-" << d._month << "-" << d._day << endl;
return _cout;
}
friend istream& operator>>(istream& _cin,Date& d)
//d是从键盘输入的所以不可以是const
{
_cin >> d._year;
_cin >> d._month;
_cin >> d._day;
return _cin;
}
public:
Date(int year=1900,int month=1,int day=1)
:_year(year)
,_month(month)
,_day(day)
{}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2019, 9, 18);
Date d2(2019, 9, 20);
cin >> d1 >> d2;
cout << d1 << d2;
return 0;
}
友元函数可访问类的私有成员,但不是类的成员函数
友元函数不能用const修饰即
friend const istream& operator>>(istream& _cin,Date& d)
编译器会报错
友元函数可以在类定义的任何地方声明,不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用和原理相同
友元类
友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员
友元关系是单向的,不具有交换性。
ege:比如上述Time
类和Date
类,在Time
类中声明Date
类为其友元类,那么可以在Date
类中直接访问Time
类的私有成员变量,但想在Time
类中访问Date
类中私有的成员变量则不行。
举个实例现有小明,小华两个人,小明说,小华是他的朋友,所以,小华可以去小明家。但小华并没有说小明是他的朋友,所以,小明不可以去小华家
友元关系不能传递
如果B是A的友元,C是B的友元,则不能说明C是A的友元。举个实例你的大学同学A是你的同学,你的中学B也是你的同学,绝大多数情况下,A,B并不是同学
class Date
{
public:
Date(int year=1900,int month=1,int day=1)
:_year(year)
,_month(month)
,_day(day)
{}
void SetTime(int h, int m, int s)
{
_t._hour = h;
_t._minute = m;
_t._second = s;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
class Time
{
friend class Date;
public:
Time(int hour=1,int minute=1,int second=1)
:_hour(hour)
,_minute(minute)
,_second(second)
{}
private:
int _hour;
int _minute;
int _second;
};
内部类
如果一个类定义在另一个类的内部,这个内部类就叫做内部类。注意此时这个内部类是一个独立的
类,它不属于外部类,更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
内部类就是外部类的友元类。注意友元类的定义,内部类可以通过外部类的对象参数来访问外部类中
的所有成员。但是外部类不是内部类的友元。
内部类可以定义在外部类的public、protected、private都是可以的。
注意内部类可以直接访问外部类中的static、枚举成员,不需要外部类的对象/类名。
sizeof(外部类)=外部类,和内部类没有任何关系。
class A
{
private:
static int k;
int h;
public:
class B
{
public:
void foo(const A& a)
{
cout << k << endl;//OK
cout << a.h << endl;//OK
}
};
};
int A::k = 1;
int main()
{
A::B b;
b.foo(A());
return 0;
}