类和对象：C++11新特性与知识补充

// 成员变量(值 / 表达式)
Date(int& x, int year = 1, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)
    ,_t(12)
    ,_ref(x)
    ,_n(1)
{
    // error C2512: “Time”: 没有合适的默认构造函数可⽤
    // error C2530 : “Date::_ref” : 必须初始化引⽤
    // error C2789 : “Date::_n” : 必须初始化常量限定类型的对象
}

private:
    int _year;
    int _month;
    int _day;
    Time _t; // 没有默认构造
    int& _ref; // 引⽤
    const int _n; // const

private:
    // 注意这⾥不是初始化，这⾥给的是缺省值，这个缺省值是给初始化列表的
    // 如果初始化列表没有显⽰初始化，默认就会⽤这个缺省值初始化
    int _year = 1;
    int _month = 1;
    int _day;
    Time _t = 1;
    const int _n = 1;
    int* _ptr = (int*)malloc(12);

class A {
public:
    // 构造函数，支持隐式类型转换
    A(int a1) : _a1(a1) {}

    void Print() {
        cout << _a1 << " " << _a2 << endl;
    }

private:
    int _a1 = 1;
    int _a2 = 2;
};

int main() {
    A aa1 = 1; // 隐式类型转换：int -> A  调用构造函数
    aa1.Print();
    
    return 0;
}

class A {
public:
    A(int a1, int a2) : _a1(a1), _a2(a2) {}

    void Print() {
        cout << _a1 << " " << _a2 << endl;
    }

private:
    int _a1 = 1;
    int _a2 = 2;
};

int main() {
    A aa3 = {2, 2}; // C++11 花括号初始化
    aa3.Print();
    
    return 0;
}

A aa1 = 1; // 隐式类型转换：int -> A
aa1.Print();

const A& aa2 = 1; // 隐式类型转换并生成临时对象
aa2.Print();

A aa3 = {2}; // 隐式类型转换：int -> A
aa3.Print();

class A {
public:
    // explicit 构造函数，禁止隐式类型转换
    explicit A(int a1) : _a1(a1) {}

    void Print() {
        cout << _a1 << " " << _a2 << endl;
    }

private:
    int _a1 = 1;
    int _a2 = 2;
};

int main() {
    // A aa1 = 1; // 错误：explicit 构造函数禁止隐式类型转换
    A aa1(1); // 正确：显式类型转换
    aa1.Print();
    
    return 0;
}

class A
{
public :
	A()
	{
		++_scount;
	} 

	A(const A& t)
	{
		++_scount;
	} 
	
	~A()
	{
		--_scount;
	}

	static int GetACount()
	{
		return _scount;
	}

private:
	// 类⾥⾯声明
	static int _scount;
};
// 类外⾯初始化
int A::_scount = 0;

class B; // 前置声明

class A {
    // 友元函数声明
    friend void func(const A& aa, const B& bb);
private:
    int _a1 = 1;
    int _a2 = 2;
};

class B {
    // 友元函数声明
    friend void func(const A& aa, const B& bb);
private:
    int _b1 = 3;
    int _b2 = 4;
};

void func(const A& aa, const B& bb) {
    cout << aa._a1 << endl;
    cout << bb._b1 << endl;
}

int main() {
    A aa;
    B bb;
    func(aa, bb);
    return 0;
}

class A
{ 
private:
	static int _k;
	int _h = 1;

public:
	class B // B默认就是A的友元
	{ 
		public:
			void foo(const A& a)
			{
				cout << _k << endl; //OK
				cout << a._h << endl; //OK
			}
	};
};
int A::_k = 1;

int main()
{
	cout << sizeof(A) << endl;

	A::B b;

	A aa;
	b.foo(aa);

	return 0;
}