C++—类与对象（下）
目录
1、explicit关键字
2、static成员
静态成员变量：
静态成员函数：
3、友元
友元函数
友元类
4、内部类
5、匿名对象
1、explicit关键字
explicit关键字是一种禁止类型转化的关键字。如果你不希望你写出的构造函数允许类型转化，可以把这个关键字放在函数名前。
先来上手体会一下explicit关键字的作用
class Date
{
public:
//单参构造函数，没有使用explicit修饰，具有类型转换作用
//多参数函数只禁止了第一个参数类型转换，后面的由于可以不传，所以仍具有类型转换
//explicit修饰构造函数，禁止类型转换，explicit去掉之后，代码可以通过编译
explicit Date(int year)
:_year(year)
{}
Date& operator=(const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2007);
d1 = 2017;
return 0;
}
2、static成员
用static声明的类成员称为类的静态成员；
用static修饰的成员变量称为静态成员变量；
用static修饰的成员函数称为静态成员函数。
静态成员变量：
静态成员变量存放在静态区，为所有类成员所共享，不属于某个具体的对象。
静态成员变量必须在类外定义，定义时不加关键字，在类中只是一个声明。
class Date
{
public:
static int cnt;//静态成员变量的声明
Date(int year = 1970, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int Date::cnt = 0;//静态成员变量必须在类外定义
静态成员变量要在类的外部进行定义即int Date::cnt = 0
静态成员的访问可以用：类名::静态成员或者对象.静态成员
class Date { public: static int cnt;//静态成员变量的声明 Date(int year = 1970, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; }; int Date::cnt = 0;//静态成员变量必须在类外定义 int main() { //类名::静态成员 Date::cnt += 1; cout << Date::cnt << endl; Date d1; //对象.静态成员 d1.cnt = 2; cout << d1.cnt << endl; return 0; }
静态成员也是类的成员，受public、protected、private 访问限定符的限制
静态成员函数：
定义静态成员函数只需要在函数名前加一个static关键字。
class Date
{
public:
static int cnt;//静态成员变量的声明
static int sum(int d1, int d2)//声明静态函数
{
return d1 + d2;
}
Date(int year = 1970, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int Date::cnt = 0;//静态成员变量必须在类外定义
静态成员函数特性
1、静态成员函数没有隐藏的this指针，不能访问任何非静态成员。
2、静态成员函数可以通过类名来直接调用，无需创建对象实例。
3、友元
在C++中，提供了一种突破封装的方式，这就是友元，使用右元可以访问类的私有(private)或保护（protected)成员。
注意：友元可以更加灵活，但是破坏了封装，会增加耦合度，应该尽量少用。
友元又分为友元类和友元函数
友元函数
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
class Date
{
public:
Date(int year = 1970, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
friend void Print(Date& d); //在类中使用friend关键字进行函数声明即可
private:
int _year;
int _month;
int _day;
};
//这样就可以让非成员函数访问类成员变量
void Print(Date& d)
{
cout << d._year << '-' << d._month << '-' << d._day << endl;
}
int main()
{
Date d1;
Print(d1);
return 0;
}友元函数特性：
1、友元函数不属于类中的一部分，不是类的成员函数。
2、友元函数在类中不能用const修饰。
3、友元函数可以在类定义的任何地方声明，不受public，private等访问限定符的限制。
4、一个函数可以是多个类的友元。
友元类
class Date
{
public:
//利用关键字friend，A是B的友元，B可以访问A，A不可以访问B
//注意友元关系是单向的
friend class Time;
Date(int year = 1970, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
class Time
{
public:
Time(int hour = 20, int min = 1, int sec = 1)
{
_hour = hour;
_min = min;
_sec = sec;
}
void Print()
{
//在Time类中访问Date类的对象
cout << "Date:" << _d._year << '-' << _d._month << '-' << _d._day << endl;
cout << "Time:" << _hour << ':' << _min << ':' << _sec << endl;
}
private:
int _hour;
int _min;
int _sec;
Date _d;
};
int main()
{
Time t1;
t1.Print();
return 0;
}
在上面的示例中，Time是Date的友元类。Time可以访问Date的私有成员。
注意：友元关系是单向的。如果类A是类B的友元，那么类B不一定是类A的友元。
友元关系也没有传递性。
4、内部类
C++中，如果一个类定义在另一个类的内部，这个内部类就叫做内部类。
内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类，可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元类。
代码示例：
class exA
{
public:
class inB
{
public:
void func(const exA& a)
{
//inBl类是exA的友元类，可以访问exA的成员变量
//内部类可直接访问外部类中的static成员
cout << _exsc << endl;//访问static成员
cout << a._exa << endl;
}
private:
int _ina;
int _inb;
};
private:
int _exa;
int _exb;
static int _exsc;
};内部类特性：
1、内部类可以定义在外部类的public、protected、private都是可以的。
2、注意内部类可以直接访问外部类中的static成员，不需要外部类的对象或类名。
3、sizeof(外部类)=外部类，和内部类没有任何关系。
5、匿名对象
C++中匿名对象是指没有被赋予名称的对象，它们通常是在方法调用时临时创建的，并且只能被引用一次。
虽然匿名对象没有名称，但其仍是一个完整的对象，具有对象的所有属性和方法。
需要注意的是，由于没有名称，当使用匿名对象时无法再进行其他操作或访问该对象。
匿名对象使用的语法为：类名(参数)，没有取名。
特性：
1、匿名对象没有名字，在定义对象时，不需要为其分配变量名，可以直接使用，且使用完毕后不需要释放内存，系统会自动回收。
2、匿名对象一般用于临时的对象操作，可以在一些函数中直接使用，无需定义变量。
3、匿名对象一般不能用于多次操作。如果需要多次操作一个对象，应当定义具名对象，否则代码会难以维护。
4、匿名对象的生命周期只有一条语句。
class A
{
public:
void Print()
{
cout << "//打印匿名函数" << endl;
}
private:
int _a;
};
int main()
{
A().Print();//使用匿名对象调用成员函数
return 0;
}