class Date
{
public:
Date(int year, int month, int day){_year = year;_month = month;_day = day;}
private:
int _year;
int _month;
int _day;
};

变量定义是在初始化列表，没显示写初始化列表默认是随机值，但是也会走初始化列表

初始化列表

初始化列表：以一个 冒号开始 ，接着是一个以 逗号分隔的数据成员列表 ，每个 " 成员变量 " 后面跟一个放在括号中的初始值或表达式。

class A
{
public:A(int a):_a(a){cout << "A(int a = 0)" << endl;}
private:int _a;
};namespace jzy
{class Date{public:Date(int year, int month, int day):_year(2),_ref(year),_n(1)//,_aa(10){// 剩下3个成员没有在初始化列表显示写出来定义// 但是他也会定义，只是内置类型默认给的随机值// 如果是自定义类型成员会去调用它的默认构造函数// 函数体内初始化_year = year;_month = month;_day = day;}private:// 声明int _year = 1; // 缺省值int _month = 1;int _day;A _aa=100;        // 定义类型成员(且该类没有默认构造函数时)int& _ref;	  // 引用 ： 必须在定义的时候初始化const int _n; // const ： 必须在定义的时候初始化};
}int main()
{jzy::Date d1(2025, 10, 31);return 0;
}

初始化列表没有显示给也会定义，内置类型不做处理，自定义类型会调用它的默认构造（默认缺省值给0，没有缺省值的话会报错-》没有合适的构造函数可以用）

记住，c++规定某些类型比如const和引用必须在定义的时候初始化，初始化列表就是定义的地方，Date d1是定义对象的地方，初始化列表是定义每个成员的地方，因为定义意味着开空间，开了空间才能使用它们

能用初始化列表就用初始化列表，函数体内是赋值，如果初始化列表没有定义还得再次给值，还不如直接在初始化列表定义的时候初始化

成员变量 在类中 声明次序 就是其在初始化列表中的 初始化顺序 ，与其在初始化列表中的先后

次序无关

using namespace std;
class A
{
public:A(int a):_a1(a), _a2(_a1){}void Print() {cout << _a1 << " " << _a2 << endl;}
private:int _a2;int _a1;
};
int main() {A aa(1);aa.Print();
}A. 输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机值

选D

所以要注意初始化的顺序和声明顺序一致

explicit关键字

class A
{
public://explicit A(int a) A(int a):_a(a){}int _a = 0;
};int main()
{A aa1(1);A aa2(2);//内置类型对象 隐式转换成自定义类型对象//能支持这个转换，是有A的int单参数构造函数(支持传一个参数多参数带缺省也可以)支持//不想让隐式类型转换发生，构造函数加explicitA aa3 = 3;const A& ra = 3;//引用会引用临时对象，临时对象有常属性，防止权限扩大要加上const//引用的是拷贝构造生成的对象  并且延长这块拷贝的临时对象的生命周期int* p = NULL;A aa4 = p;// 内置类型  整形和浮点 隐式互相转//int i = 0;//double d = i;//const double& r = i;return 0;
}

这里隐式类型转换只能是构造函数是单参数，并且是相同类型的才能这样写。用explicit修饰构造函数，将会禁止构造函数的隐式转换。

#include<iostream>
using namespace std;
#include<list>
class A
{
public:A(int a) :_a(a){}~A(){cout << this << endl;}int _a = 0;
};class Date
{
public:Date(int year = 1, int month = 1, int day = 1): _year(year), _month(month), _day(day){}private:int _year;int _month;int _day;
};
int main()
{Date d1(2025, 11, 2);Date d2 = (2025, 11, 3); // 等价于 Date d2 = 3;Date d3 = 2025;//C++11Date d4 = { 2025, 11, 2 };//多参数也支持隐式类型转换，被编译器优化了，所以没有析构const Date& d5 = { 2025, 11, 2 };list<A> lt;//void push_back(const A& aa);A aa1(1);lt.push_back(aa1);lt.push_back(A(2));lt.push_back(3);list<Date> lt1;Date d6(2025, 11, 2);lt1.push_back(d6);lt1.push_back(Date(2025, 11, 2));//先生成匿名对象，再拷贝构造给vector，所以会析构lt1.push_back({ 2025, 11, 2 });return 0;
}

static成员

class A
{
public:A() { ++count; }A(const A& t) { ++count; }~A() {cout << "~A()" << endl;}// 静态成员函数，特点：没有this指针static int GetCount(){return count;}private:// 声明static int count;int _a = 0;
};// 定义
int A::count = 0;A func()
{A aa;return aa;
}int main()
{//A::count++;//cout << sizeof(A) << endl;//A aa;func();func();func();//A::count++;// 公有// 属于整个类，属于这个类所有对象// 受访问限定符限制//cout << A::count << endl;//cout << aa.count << endl;A aa;//有名对象A aa;  //为了调用而创建的，所以要-1cout << aa.GetCount()-1 << endl;// A() 这种写法叫做匿名对象，生命周期只在这一行cout << A().GetCount() - 1 << endl;cout << A::GetCount() << endl;cout << A().GetCount() << endl;// 总结一下：静态成员函数和静态成员变量，本质受限制的全局变量和全局函数// 专属这个类，受类域和访问限定符的限制return 0;
}

静态成员变量在类内声明，在类外定义，（因为要走初始化列表，静态成员是类每个对象的公有，不能走初始化列表）

静态成员变量本质也是受类访问限定符限制的变量，在类外不能访问，需要用静态成员函数或者非静态成员函数，再或者将private私有取消才能访问

静态成员函数本质也是受类域限定，属于所有对象，并且没有this指针，不能在静态成员函数内部访问非静态成员变量和函数

【问题】

1. 静态成员函数可以调用非静态成员函数吗？不可以，没有this指针

2. 非静态成员函数可以调用类的静态成员函数吗？可以，静态成员函数所有对象共享，在类内类外都能访问

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

友元分为： 友元函数 和 友元类

友元函数

问题：现在尝试去重载 operator<< ，然后发现没办法将 operator<< 重载成成员函数。 因为 cout 的 输出流对象和隐含的 this 指针在抢占第一个参数的位置 。 this 指针默认是第一个参数也就是左操作数了。但是实际使用中cout 需要是第一个形参对象，才能正常使用。所以要将 operator<< 重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>> 同理。

class Date
{
public:
Date(int year, int month, int day): _year(year), _month(month), _day(day){}
// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
// 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
ostream& operator<<(ostream& _cout){_cout << _year << "-" << _month << "-" << _day << endl;return _cout;}
private:
int _year;
int _month;
int _day;
};

友元函数 可以 直接访问 类的 私有 成员，它是 定义在类外部 的 普通函数 ，不属于任何类，但需要在类的内部声明，声明时需要加friend 关键字。

class Date
{friend ostream& operator<<(ostream& _cout, const Date& d);friend istream& operator>>(istream& _cin, Date& d);
public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}
private:int _year;int _month;int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{_cout << d._year << "-" << d._month << "-" << d._day;return _cout; 
}
istream& operator>>(istream& _cin, Date& d)
{_cin >> d._year;_cin >> d._month;_cin >> d._day;return _cin;
}
int main()
{Date d;cin >> d;cout << d << endl;return 0;
}

友元函数很简单，就是在类内声明，在类外可以用这个类的私有成员，并且友元函数是实现在全局的，没有this指针

友元函数的一些说明

友元类（了解）

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

友元关系是单向的，不具有交换性。

比如上述 Time 类和 Date 类，在 Time 类中声明 Date 类为其友元类，那么可以在 Date 类中直接

访问 Time 类的私有成员变量，但想在 Time 类中访问 Date 类中私有的成员变量则不行。

友元关系不能传递

如果 C 是 B 的友元， B 是 A 的友元，则不能说明 C 时 A 的友元。

友元关系不能继承，在继承位置再给大家详细介绍。

class Time
{friend class Date;   // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类
中的私有成员变量
public:Time(int hour = 0, int minute = 0, int second = 0): _hour(hour), _minute(minute), _second(second){}private:int _hour;int _minute;int _second;
};
class Date
{
public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}void SetTimeOfDate(int hour, int minute, int second){// 直接访问时间类私有的成员变量_t._hour = hour;_t._minute = minute;_t._second = second;}private:int _year;int _month;int _day;Time _t;
};

概念： 如果一个类定义在另一个类的内部，这个内部类就叫做内部类 。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

注意： 内部类就是外部类的友元类 ，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

1. 内部类可以定义在外部类的 public 、 protected 、 private 都是可以的。

2. 注意内部类可以直接访问外部类中的 static 成员，不需要外部类的对象 / 类名。

3. sizeof( 外部类 )= 外部类，和内部类没有任何关系

class A
{
private:int h;
public:// A和B关系// B就是一个普通类，只是受A的类域和访问限定符限制,本质相当于被封装了一下// B天生就是A的友元class B {public:void func(){A aa;// B天生就是A的友元aa.h++;}private:int _b;};
};int main()
{cout << sizeof(A) << endl;A aa;A::B bb;return 0;
}

可以看到内部类不算大小，只有外部类的成员int 4字节

并且内部类天生是外部类的友元，可以随意访问外部类的私有成员

内部类受外部类访问限定符的限制，在外部类外边想用内部类创建对象还要指定类域，因为编译器默认只会在全局找B类，不会突破类域A找B

内部类的作用就是，可以将内部类设置为私有，这样只有A类可以用内部类B，外边无法访问

class A
{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}A& operator=(const A& aa){cout << "A& operator=(const A& aa)" << endl;if (this != &aa){_a = aa._a;}return *this;}~A(){cout << "~A()" << endl;}
private:int _a;
};void func(A aa1)
{}int main()
{// 构造A aa(1);// 拷贝构造func(aa);//构造+拷贝构造->构造 func(A(2));//构造+拷贝构造->构造 func(3);return 0;
}

可以看到构造+拷贝构造确实被优化成直接构造了，出func函数作用域aa1对象销毁，所以会析构