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)
		:_x(x)
	{}

private:
	int _x；
};

int main()
{
	//StackOnly so1; //栈
	//static StackOnly so2; //静态区

	StackOnly so3 = StackOnly::CreateObj();
	//调用静态成员函数不需要 构造对象
	return 0;
}