explicit关键字 和 static成员

1、explicit 关键字

//（1）作用：单参数的构造函数支持 隐式类型的转换，但是在 构造函数 前面加上explict，就解除了这种支持。class Date
{
public:Date(int year):_year(year){cout<< "  Date(int year)" << endl;}Date(const Date& d){cout<< "Date(const Date& d)" << endl;}private:int _year;
};int main()
{Date d1(2022);   //直接调用构造Date d2 = 2022;  // 构造 + 拷贝构造 + 编译器优化 -> 直接调用构造//（单参数的构造函数支持）隐式类型的转换// Date d2 = 2022; 的实现过程为：整型2022转化为Date类型的tmp{构造 Date tmp(2022)}; 然后再 Date d2(tmp){拷贝构造};const Date& d3 = 2022; //隐式类型的转化，产生的中间值: tmp为Date类型的 且只可读不可写。return 0;
}

//（2）、隐式类型转换的应用(好用一些而已)
// string(const char* str)
// {}void func(const string& s) //传参 尽量用引用，引用 尽量用const
{}int main(){string s1("hello");string s2= "hello";string str("insert");func(str);//为了传 "insert"过去，还需要先构造 str，比较麻烦。不如用 隐式类型 的转换，直接传"insert"过去。func("insert"); // const string& s= "insert";return 0;}

//（3）补充：匿名对象：生命周期只在这一行。
class Date
{
public:Date(int year):_year(year){cout<< "  Date(int year)" << endl;}~Date(){cout << "  ~Date()" << endl;}private:int _year;
};int main()
{Date d1(2023);Date(2022); //匿名对象：生命周期只有这一行return 0;
}

//匿名对象的一些使用场景
class Solution
{
public:int Sum_Solution(int n){//......return 0;}};int main()
{//匿名对象Solution slt;slt.Sum_Solution(10);Solution().Sum_Solution(10);return 0;
}

2、static成员（静态成员变量属于类的（只有所属这个类的对象才能修改），不同于全局变量（任何对象都能修改））

2.1 定义和性质

//声明为 static的类成员 称为 类的静态成员， 用static修饰的成员变量，称之为 静态成员变量；用staticx修饰的成员函数，称之为 静态成员函数。
//静态成员变量一定要在类外进行定义（初始化）。
//对比：普通成员变量在初始化列表进行定义，而静态成员变量必须要在类外进行定义；//性质：
//1、静态成员为所有 类对象所共享，不属于某个具体的对象，存放在静态区。
//2、静态成员变量 必须在 类外定义， 定义时不添加static关键字，类中只是声明。
//3、静态类成员即可用  类名::静态成员 或者 对象.静态成员 来访问。
//4、静态成员函数没有隐藏的this指针，不能访问任何非静态成员。
//5、静态成员也是类的成员，受public\protected\private 访问限定符的限制。//额外：静态成员函数无法调用非静态成员函数（因为静态成员函数没有this指针）。
//      非静态成员函数可以调用静态成员函数（因为静态成员函数属于类）。class A
{
public:A(){++_scount;}A(const A& t){++_scount;}//静态成员函数 —— 没有this指针(无法访问普通成员变量，只能访问静态成员变量)static int GetCount(){return _scount;}private://静态成员变量，属于整个类；生命周期是整个程序运行期。static int _scount;
};//类外面定义初始化(静态成员变量 )
int A::_scount = 0;int main()
{A aa1;A aa2;return 0;
}

2.2 静态成员的使用场景

//（1）新方法计算：1+2+3......+n ;class Sum
{
public:Sum(){_sum += _i;++_i;}static int GetSum(){return _sum;}private:static int _sum;static int _i;
};int Sum::_sum = 0;
int Sum::_i = 1;class Solution
{
public:int Sum_Solution(int n){Sum a[n];return Sum::GetSum();}};

//（2）要求：设计一个只能在栈上定义对象的类
class StackOnly
{
public:static StackOnly CreateObj(){StackOnly so;return so;}private://构造函数StackOnly(int x = 0, int y = 0):_x(x), _y(0){}private:int _x = 0;int _y = 0;
};int main()
{//StackOnly so1; //栈//static StackOnly so2; //静态区StackOnly so3 = StackOnly::CreateObj();//调用静态成员函数不需要 构造对象return 0;
}