类与对象；

代码：

class date
{        
public:
void init(int year, int month, int day)
{                                      //this指针不可以在形参和实参显式的写，但是可以在类里面显示的用
_year = year;//this->_year = year;
_month = month;
_day = day;
}
void print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
void printpos()
{
cout << this << endl;
}
private://类只存变量；
int _year;//加_是为了好区分；
int _month;
int _day;
};
int main()
{
date d1;
d1.init(1, 2, 3);//d1.init(&d1,1, 2, 3);
cout << &d1 << endl;
d1.printpos();
return 0;
}

运行结果：

结果分析：

init函数实际上是void init(date* this,int year, int month, int day)编译器加上this指针数；this指针就是定义的类的地址；this指针不可以在实参和形参显式的写，但是可以显式调用；、

代码：

class a
{
public:
void print()
{
cout << "print()" << endl;
}
private:
int _a;
};
int main()
{
/*a* p = nullptr;
p->print();*///p对象成员函数的地址不存在对象里，而是存在代码区，所以直接那函数名字地址去代码区找，所以没有对p解引用；


a* p = nullptr;
(*p).print();//print依旧不在对象里，所以依旧不会对p解引用；  //只有光写p->a不会崩；p->a=1会崩；
return 0;
}

运行结果：

代码分析：

p对象成员函数的地址不存在对象里，而是存在代码区，所以直接那函数名字地址去代码区找，所以没有对p解引用；是否在p解引用看访问的成员是否在p里面；

二、类的默认成员函数和成员；

1、构造函数；

定义：

构造函数是一个特殊的成员函数，名字与类名相同（date类构造函数 date（x，y））,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

特点：

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

1. 函数名与类名相同。

2. 无返回值。

3. 对象实例化时编译器 自动调用 对应的构造函数。

4. 构造函数可以重载。

date()
{
cout << "date()" << endl;
_year = 1;
_month = 1;
_day = 1;
}
//带参初始化；
date(int year, int month, int day)
{
cout << "date(int year, int month, int day)" << endl;
_year = year;
_month = month;
_day = day;
}
上面两个构造合并；
date(int year=1, int month=1, int day=1)//
{
cout << "date(int year=1, int month=1, int day=1)" << endl;
_year = year;
_month = month;
_day = day;
}

注意：如果通过无参构造函数创建对象时，对象后面不用跟括号（date d1），否则就成了函数声明(date d1())；第一个和第三个语法上可以同时存在 ，但是使用的时候不可以；

如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦

用户显式定义编译器将不再生成。

默认构造的特点：
1、我们写它生成，我们写了它不生成；
2、内置类型：语言原生的类型（指针都是内置类型）；自定义：类、结构；C++默认构造对内置类型不处理、处理自定义类型（C++支持声明给缺省值），会去调用这个成员的默认构造函数；

什么是默认构造：

无参的构造函数、全缺省的构造函数、我们不写编译器自动生成的构造函数都被称为默认构造函数（不传参就会调用），他们只能有一个；

2、析构函数；

概念：

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

特性：

析构函数 是特殊的成员函数，其 特征 如下：

1. 析构函数名是在类名前加上字符 ~ 。

2. 无参数无返回值类型。

3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构 函数不能重载。

4. 对象生命周期结束时， C++ 编译系统系统自动调用析构函数。(例如date类的析构函数是~date（）)。

5、如果系统没有显示定义，会生成默认析构，对于内置类型不处理，自定义类型调用它的析构函数处理。

代码：

class x
{
public:
x(int a=1)
{
cout << "x()" << endl;
_a = a;
}
~x()
{
cout << "~x()" << endl;
}
private:
int _a;
};
int main()
{
x x1;

return 0;
}

运行结果：

结果分析：

构造和析构的最大特性是自动调用。

3、拷贝构造函数；

概念：

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存 在的类类型对象创建新对象时由编译器自动调用。

特征：

拷贝构造函数也是特殊的成员函数，其 特征 如下：

1. 拷贝构造函数 是构造函数的一个重载形式 。

2. 拷贝构造函数的 参数只有一个 且 必须是类类型对象的引用 ，使用 传值方式编译器直接报错 ， 因为会引发无穷递归调用。（如果是date(date d)，那么d1（d2）会先d（d2），形成了新的拷贝构造，导致又要  d3（d2），无穷调用）。

若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按

字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝，会造成资源二次释放的问题。

代码：

class stack//还可以定义成员函数;    //类里面不受访问限定符的限制，访问限定符限制的是外面的人使用；
{
public://类一开始默认为私有的；struct一开始默认为公有的；
stack(int n = 4)
{
cout << "stack()" << endl;
cout << "stack(int n = 4)" << endl;
if (n == 0)
{
a = (int*)malloc(sizeof(int) * 4);
if (a == nullptr)
{
perror("malloc fail");
}
size = 0;
capa = 4;
}
else
{
a = (int*)malloc(sizeof(int) * n);
if (a == nullptr)
{
perror("malloc fail");
}
size = 0;
capa = n;
}
}
void push(int x)
{
if (size == capa)
{

size_t newcapa = capa == 0 ? 4 : 2 * capa;
auto x1 = a;
a = (int*)realloc(a, newcapa * (sizeof(int)));
if (a == nullptr)
{
perror("realloc fail");
exit(-1);
}
capa = newcapa;
}
a[size++] = x;
}
void pop()
{
assert(size > 0);
size--;
}
int top()//栈顶元素；
{
return a[size - 1];
}
void print()
{
cout << size << endl << capa << endl;
}
stack(const stack& s)//解决了两次析构问题；（深拷贝）；
{      //s不能改变；防止错误代码；
cout << "stack(stack& s)" << endl;
a= (int*)malloc(s.capa * (sizeof(int)));
if (a == nullptr)
{
perror("realloc fail");
exit(-1);
}
memcpy(a, s.a,sizeof(int)*s.size);
size = s.size;
capa = s.capa;
}
~stack()
{
cout << "~stack()" << endl;
free(a);
        a=nullptr;//这行和下一行不写不算错，算是好习惯；
size = capa = 0;
}
bool isempty()
{
//assert(size>0);//
return size == 0;
}
private:
int* a;
int size ;
int capa ;
};
class date
{
public:
date(int year=2024, int month=11, int day=11)
{
year_ = year;
month_ = month;
day_ = day;
}
void print()
{
cout << year_<<"/" << month_ << "/" << day_ << endl;
}
//date d2(d1);  d是d1的别名，this是d2的指针；
date(const date& d)//如果是date(date d)，那么d1（d2）会先d（d2），形成了新的拷贝构造，导致又要  d3（d2），无穷调用；
{    //防止错误的改变，防止误伤；
cout << "date(date& d)" << endl;
year_ = d.year_;
month_ = d.month_;
day_ = d.day_;
}
~date()
{
cout << "~date()" << endl;
}
private:
int year_;
int month_;
int day_;
};
void func1(date d)
{
d.print();
}
void func2(stack& s)//s的作用域是main函数栈帧，但是问题是s变化s1也变化；
{
s.push(1);
s.push(2);
}
int main()
{
date d1;
func1(d1);
stack s1;
func2(s1);//会出现浅拷贝问题
stack s2(s1);



//以下两种写法一样；
date d2(d1);
date d3 = d1;



return 0;
}

运行结果：

4、赋值运算符重载；

概念：

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其

返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字 operator 后面接需要重载的运算符符号 。

函数原型： 返回值类型  operator 操作符 ( 参数列表 )

注意：

不能通过连接其他符号来创建新的操作符：比如 operator@

重载操作符必须有一个类类型参数

用于内置类型的运算符，其含义不能改变，例如：内置的整型 + ，不 能改变其含义

作为类成员函数重载时，其形参看起来比操作数数目少 1 ，因为成员函数的第一个参数为隐

藏的 this

.* :: sizeof ?: . 注意以上 5 个运算符不能重载。这个经常在笔试选择题中出现。

代码（以date类举例）：

class date
{
public:
date(int year=2024, int month=11, int day=11)
{
_year = year;
_month = month;
_day = day;
}
void print()
{
cout << _year<<"/" << _month << "/" << _day << endl;
}
date(const date& d)；
{   
cout << "date(date& d)" << endl;
_year = d._year;
_month = d._month;
_day = d._day;
}
bool operator<( const date& x2)//运算符重载可以写为全局函数，也可以写为类里面的成员函数；
{
if (_year < x2._year)
{
return true;
}
else if (_year == x2._year && _month < x2._month)
{
return true;
}
else if (_year == x2._year && _month == x2._month && _day < x2._day)
{
return true;
}
else
{
return false;
}
}
bool operator==(const date& x2)
{
return _year == x2._year && _month == x2._month && _day == x2._day;
}
bool operator<=(const date& x2)
{
return ((*this)<x2)|| ((*this) == x2);
}
bool operator>(const date& x2)
{
return !((*this) <= x2);
}
bool operator!=(const date& x2)
{
return !((*this) == x2);
}
~date()
{
cout << "~date()" << endl;
}

private:
int _year;
int _month;
int _day;
};
int main()
{
date d1(2023, 11, 11);
date d2(2024, 12, 12);
//为了对自定义类型进行比较，发明了运算符重载；
int i1 = 10;
int j1 = 100;
i1 < j1;//内置类型转为运算符指令；
cout << (d1< d2) << endl;//自定义类型转为运算符重载；
//cout << (operator<(d2, d1) )<< endl;//可以显示调用；

cout << (d1 < d2) << endl;//上面的自动转为下列公式；
cout << d1.operator<(d2) << endl;
cout << (d2 < d1) << endl;
cout << d2.operator<(d1) << endl;

cout << (d1 == d2)<<endl;
cout << (d1 != d2) << endl;
cout << (d1 <= d2) << endl;
cout << (d1 > d2) << endl;
return 0;
}

int getmonthday(int year,int month)//得到每年每月的天数。
{
int monthday[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
if (month == 2&&((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
{//先判断是不是2月；
monthday[2]+=1;
}
return monthday[month];
}
date& operator+=(int day)
{
_day += day;
while (_day > getmonthday(_year, _month))//多次循环，直到天数小于该月的天数；
{
_day -= getmonthday(_year, _month);
_month++;
if (_month > 12)
{
_year++;
_month = 1;
}
}
return *this;
}
//+=的时候返回的是*this，出了作用域还在，可以用引用返回；+返回的是d2，出了作用域就不在了，使用传值返回；
date operator+(int day)
{
date d2(*this);//不写这个是+=

//d2._day += day;
//while (d2._day > getmonthday(d2._year, d2._month))//多次循环，直到天数小于该月的天数；
//{
//d2._day -= getmonthday(d2._year,d2._month);
//d2._month++;
//if (d2._month > 12)
//{
//d2._year++;
//d2._month = 1;
//}
//}
//return d2;
d2 += day;
return d2;
}

date& date::operator-=(int day)
{
if (day < 0)
{
return *this += (-day);
}
_day -= day;
while (_day < 1)
{
_month--;
if (_month < 1)
{
_year--;
_month = 12;
}
_day += getmonthday(_year, _month); 
}
return *this;
}
date& date::operator+=(int day)
{
if (day < 0)
{
return *this -= (-day);
}
_day += day;
while (_day > getmonthday(_year, _month))
{
_day -= getmonthday(_year, _month);
_month++;
if (_month > 12)
{
_year++;
_month = 1; 
}
}  

return *this;
}

ostream& operator<<(ostream& out, date& d)//<< 可以更好的打印自定义类型；
{
out << d._year << "/" << d._month << "/" << d._day << endl;
return out;//为了多个一块打印；
}
istream& operator>>(istream& in, date& d)
{
in >> d._year >> d._month >> d._day; 

return in;
}

date& date::operator++()
{
*this += 1;
return *this;
}
date date::date::operator++(int)//int 只是为了匹配；
{
date d(*this);
*this += 1;
return d;
}

Date& operator=(const Date& d)
 {
 if(this != &d)
       {
            _year = d._year;
            _month = d._month;
            _day = d._day;
       }
        
        return *this;
 }

初始化列表

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

代码：

class date
{
public:

date(int year, int month, int day, int x, int& rex)
: _year(year)                                  
, _month(month)
, _rex(rex)
, _x(x)//这就是定义的地方，在此位置初始化；//如果给了缺省值，这行不写也行（这行写的原因是给值，如果有缺省，可以不用写）
, a1(1)//没有默认构造，在定义的地方初始化；
{//括号上面是定义的地方（初始化列表）； //先走上面，再走函数体；所有成员都在上面定义
//_x = x;//const这个位置不行

_day = day;//普通成员可以在里面定义(因为普通成员不需要在定义的地方初始化)；
}
void func1()
{
++_rex;
}
private://支持给缺省值；缺省值给初始化列表；如果初始化列表没有显示给值，就用缺省值；显式给值，不用缺省值；
int _year;//每个成员的声明（不开空间）
int _month;
int _day;

//成员必须在定义的时候初始化
const int _x;//const 成员必须在定义的时候初始化，以后不能修改；
int& _rex;//引用也必须在定义的时候初始化；
A a1;
};

代码分析：

初始化列表；每个成员定义的地方；（开空间）；（初始化列表是构造函数的一部分）；初始化列表是成员定义的地方，不管写不写，都处理；初始化列表在没有写的一些变量，内置类型随机值，自定义类型调用默认构造；

初始化列表初始化的顺序是按声明的顺序；

1. 每个成员变量在初始化列表中 只能出现一次 ( 初始化只能初始化一次 )

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量；

const 成员变量；

自定义类型成员 ( 且该类没有默认构造函数时 )；

参数隐式类型转换；

单参数；

代码：

class A
{
public:
/*explicit*/ A(int a)//explicit 可以禁止单参数隐式类型转换
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& a)
:_a(a._a)
{
cout <<"A(const A& a)"<< endl;
}
~A()
{
cout << "~A" << endl;
}
private:
int _a;
};
int main()
{
A a(1)；
    A b = 2;
    const A& x= 2;
    return 0;
}

代码分析：

单参数隐式类型转换（传参可以直接传参数值，自动转为类）；c++支持单参数隐式类型转换，用2调用a 构造函数创造临时对象，再用这个对象拷贝构造给b，后来创建对象时候，c++后来优化，不先构造对象，而是用2直接创造对象；x这里不能优化，用2调用a 构造函数创造临时对象，临时对象具有常性，权限不能放大，引用要加const；

运行结果：

C++11支持多参数隐式类型转换；

代码：

class B
{
public:
/*explicit*/ B(int b1,int b2) //explicit 可以不允许隐式类型转换发生
:_b1(b1)
,_b2(b2)
{
cout << "B(int b1,int b2)" << endl;
}
B(const B& b)
:_b1(b._b1)
,_b2(b._b2)
{
cout << "B(const B& b)" << endl;
}
private:
int _b1;
int _b2;
};
int main()
{
    B b(1, 2);
B b1 = { 1,2 }
const B& c = { 1,2 };
    return 0;
}

代码分析：

与单参数类似，传参就能自动构造类，连续的构造拷贝构造可以省略;多参数隐式类型转换，用1，2调用b 构造函数创造临时对象，再用这个对象拷贝构造给b;引用的时候注意临时对象具有常性。

运行结果：

explicit：

用 explicit 修饰构造函数，将会禁止构造函数的隐式转换 。

static；

概念：

声明为 static 的类成员 称为 类的静态成员 ，用 static 修饰的 成员变量 ，称之为 静态成员变量 ；用 static 修饰 的 成员函数 ，称之为 静态成员函数 。 静态成员变量一定要在类外进行初始化。

特性：

1. 静态成员 为 所有类对象所共享 ，不属于某个具体的对象，存放在静态区。

2. 静态成员变量 必须在 类外定义 ，定义时不添加 static 关键字，类中只是声明。

3. 类静态成员即可用 类名 :: 静态成员 或者 对象 . 静态成员 来访问。

4. 静态成员函数 没有 隐藏的 this 指针 ，不能访问任何非静态成员。

5. 静态成员也是类的成员，受 public 、 protected 、 private 访问限定符的限制。

代码：

class A 
{
public:
A()
{
n++;
m++;
}
A(const A& a)
{
int x = getm();
n++;
m++;
}
//必须要创建新的对象才能调用print函数；
static int getm() 

//getm只能读不能改；
{
/*x++;*///静态成员函数不能访问非静态成员变量，因为没有this指针；
return m;
}
static void print()//加了static，表示函数体内没有this指针；
{
cout << m << " " << n << endl;
}
~A()
{
m--;
}
private:
//static int n = 0;//加了static就是全部类用的(存在静态区),属于所有对象，属于类域；//这里不能给缺省值；因为初始化列表是给某对象用的；static不是某个对象的变量，所有不走初始化列表；
//static int m = 0;

static int n;//static成员变量不是私有成员变量，所以不需要this指针，如果是公有的话，只需要突破类域；
static int m;//在外面定义；

int x;
};
int A::m = 0;
int A::n = 0;
int main()
{
A aa1;
A aa2;
A();
A();
//cout << "目前创建:" << A::n << " " << "目前使用:" << A::m << endl;//如果成员变量私有化，不能这样访问；
A::print();//print()是static函数，没有this指针，可以通过类域，变量名，变量指针调用；
aa1.print();
A* x = nullptr;//因为调用函数不需要this指针，只需要突破类域；
x->print();
aa1.print();
}

代码分析：

m、n是static变量，要在外面定义；但是受访问限定符限制，所以类外面不能直接访问；print是static函数，因为静态成员函数没有this指针，且是公有，所以只需要突破类域就能访问；突破类域有三种方式：域访问限定符（：：）、指针->、类变量。

运行结果：

友元；

友元函数：

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。有在类外面访问类成员的需求；（>>、<<重载函数）；(定义私有成员的目的就是不被随便访问，所以最好不要定义太多友元函数)；友元关系不具有传递性；（不到万不得已不要定义友元）。

说明:

友元函数 可访问类的私有和保护成员，但 不是类的成员函数。

友元函数 不能用 const 修饰。

友元函数 可以在类定义的任何。地方声明， 不受类访问限定符限制。

一个函数可以是多个类的友元函数。

友元函数的调用与普通函数的调用原理相同。

代码：

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;
}

代码分析：

>>和<<是date的友元函数，所以可以访问私有成员变量。

友元类：

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

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

友元关系不能传递

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

代码：

class Time
{
friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成，但是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;
};
int main()
{
return 0;
}

代码分析：

上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time。反过来却不行。

内部类；

概念：

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

注意：

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

特性：

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

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

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

内部类类受外部类类域和访问限定符的限制，本身是两个独立的类。

代码：

class A
{
public:
class B//
{      //内部类是外部类的友元；内部类可以通过变量名+.访问私有成员变量；
public:
void func()
{
A a;
a._a = 10;//内部类是外部类的友元；内部类可以通过变量名+.访问私有成员变量；
}
private:
int _b;
};
private:
int _a;
};
int main()
{
cout << sizeof(A) << endl;
A aa1;
A::B bb1;
return 0;
}

代码分析：

B类受A类类域和访问限定符的限制，本身是两个独立的类；sizeof( 外部类 )= 外部类。

运行结果: