const和static

const和static参考链接

#include <iostream>
using namespace std;

class Time
{
public:
	Time(int h = 1, int m = 1, int s = 1)
		:_h(h)
		, _m(m)
		, _s(s)
	{
		cout << "Time(int h = 1, int m = 1, int s = 1)" << endl;
	}
private:
	int _h;
	int _m;
	int _s;
};

class Date
{
public:
	//初始化列表： 成员变量初始化的地方，也是成员定义的地方
	//           每一个成员变量只能出现一次
	//   :成员变量(初始值或者初始化表达式), 后续的成员变量 
	Date(int y = 1, int m = 1, int d = 1)
		: _ra(d)   //引用类型必须在初始化列表中初始化，
		, _ca(1)  //const成员必须在初始化列表中初始化
		//, _t(23,59,59) //没有默认构造函数的自定义成员必须在初始化列表中初始化
	{
		/*
		//赋值操作
		_year = y;
		_month = m;
		_day = d;

		_year = y;
		_year = y;
		*/
		//_t = Time(23, 12, 12);
	}

	Date(const Date& date)
		:_year(date._year)
		, _month(date._month)
		, _ra(date._ra)
		, _ca(date._ca)
		, _t(date._t)
	{}

	void Display()  //void Display(Date* const this)
	{
		cout << "Display ()" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
		_day = 10;
		cout << "void Display()" << endl;
		//非const成员函数可以调用const成员函数，权限可以被缩小
		fun2();
		fun1();
	}
	//const修饰的为this指针，表示其为const Date* const类型， 此const修饰的为内容，表示内容不能变
	void Display() const  // void Display(const Date* const this)
	{
		cout << "Display () const" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
		//_day = 10;
		cout << "void Display() const " << endl;
		//const成员函数不能调用非const成员函数， 权限不能被放大的
		//fun1();

		fun2();
	}

	void fun1()
	{}

	void fun2() const
	{}

	//取地址成员函数 &  不需要实现&重载函数
	Date* operator&()
	{
		return this;
	}
	//const 取地址成员函数
	const Date* operator&() const
	{
		return this;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
	int& _ra;
	const int _ca;
	Time _t;
};

class Test
{
public:
	//成员的初始化顺序和声明顺序一致，与其在初始化列表中的顺序没有关系
	//尽量和声明顺序保持一致
	// Test t1(10); 结果为_a = 随机值, _b = 10
	Test(int b)
		:_b(b)
		, _a(2 * _b)
	{}
private:
	int _a;
	int _b;
};

//普通函数不用const修饰的，因为函数没有this指针
void fun(int a)//const
{
	cout << "fun" << endl;
}

const成员函数只能调用const成员变量和const成员函数, 不能调用非const成员函数,
非const成员函数可以调用const函数

引用类型和const成员必须在初始化列表中初始化, static成员在内外初始化
没有默认构造函数时,自定义成员必须在默认构造函数初始化

static

单参隐式类型转换(explicit可禁止隐式类型转换)

#include <iostream>
using namespace std;

//定义全局变量
int cnt = 0;
class A
{
public:
	/* explicit: 禁止单参构造函数的隐式类型转换 */
	/*explicit*/ A(int a)
		:_a(a)
	{
		++_cnt;
		cout << "A(Int)" << endl;
	}

	A(int a, int b)
		:_a(a)
	{
		++_cnt;
	}

	A(const A& a)
		:_a(a._a)
	{
		++_cnt;
		cout << "A(const A&)" << endl;
	}
	A& operator=(const A& a)
	{
		if (this != &a)
		{
			_a = a._a;
		}
		cout << "A& operator=" << endl;
		return *this;
	}
	//非静态成员函数可以调用、访问静态成员
	void fun1()
	{
		cout << this->_a << endl;
		cout << _cnt << endl;
		fun2();
		displayA();
	}

	//静态成员函数:  没有this指针, 只能调用/访问静态成员，不能访问非静态成员
	static void displayA()
	{
		cout << "displayA" << endl;
		//cout << this->_a << endl;
		cout << _cnt << endl;
		fun2();
		//fun1();
	}

	static void fun2()
	{

	}

//private:
	int _a;
	static int _cnt; // 静态成员, 类成员，所有对象共享， 存放在数据段， 并不是存放在对象中
};

int A::_cnt = 0;  //静态成员在类外初始化

void fun1()
{
	int a = 1;
	float b = 2.0;
	a = b;  //隐式类型转换

	A a1(10);  

	A a2 = 20;  //隐式类型转换: 20传参，调用构造函数，创建一个匿名对象， 拷贝构造, 编译器优化，直接调用构造函数

	a2 = 30;  // 构造， 赋值运算符

	//A a3 = 20, 30;  //自定义类型的隐式类型转换： 只支持单参构造函数
}

A fun(A a)
{
	A b = a;
	return b;
}

void test1()
{
	A a(20);
	fun(a);
	cout << a._cnt << endl;
}

void test2()
{
	A a1 = 1;
	A a2 = 2;
	A a3 = 3;
	A a4 = 4;
	//静态成员访问形式： 1： 对象访问  2 类名 + 作用域限定符
	cout << &a1._cnt << endl;
	cout << &a2._cnt << endl;
	cout << &a3._cnt << endl;
	cout << &a4._cnt << endl;

	cout << &A::_cnt << endl;

	cout << sizeof(A) << endl;

	a1.displayA();
	A::displayA();
}

	//test4();
	//test5();
	test6();
	return 0;
}

1.所有的对象共享static成员
2.访问形式 : 对象, 类名::
3.static成员函数里面没有this指针, static成员函数只可以调用static成员函数,非static成员函数无限制
4.static成员只能在类外初始化
5.修饰的变量只能在当前文件域中访问