#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
//如何让定义一个类
// 封装
// 1、将数据和方法定义到一起。
// 2、把想给你看的数据给你看，不想给你看的封装起来。 通过访问限定符来实现
class Stack
{
public:
//1.成员函数
void Push(int x);
//void Push(int x)
//{
// //...函数体
//}//这种是在类里面定义
void Pop();//这里是类的申明，类外面定义
bool Empty();
//....
private:
//2.成员变量
int _a;
int _size;
int _capacity;//这里是声明
};
//在类外面定义成员函数
void Stack::Push(int x)
{
//...
}
// 1、C语言中,struct是用来定义结构体的
// 2、C++中，兼容C的struct定义结构体的用法。但是同时struct也可以用来定义类
// 3、C++中使用class和struct定义类的区别？ -》默认的访问限定符
//C
struct ListNode_C
{
int* _val;
struct ListNode_C* _next;
struct ListNode_C* _prev;
};
//C++
struct ListNode_CPP//默认共有
//class ListNode_CPP//默认私有
{
int* _val;
//ListNode_CPP* _next;//这个地方不需要加struct
struct ListNode_CPP* _next;//这个地方也可以这样用，C++兼容C
ListNode_CPP* _prev;//这是C++当成类的用法
//还可以定义成员函数
ListNode_CPP* Create(int val);
};
// 1、声明和定义的区别？ 声明是一种承诺，承诺要干嘛，但是还没做，定义就是把这个事落地了
//类中既有成员变量，又有成员函数
class A1
{
public:
void f1()
{
}
private:
int _a;
char _ch;
};
//类中仅有成员函数
class A2
{
public:
void f2()
{
}
};
//类中既没有成员函数，也没有成员变量
class A3
{
};
int main()
{
//类实例化出对象，相当于定义出了类的成员变量
Stack s1;
Stack s2;
Stack s3;
//s1._a = nullptr;//私有的，不能访问
s1.Push(1);
//对象中只存储成员变量，不存储成员函数？为什么？
cout << sizeof(s1) << endl;
// 因为一个类实例化出N个对象，每个对象的成员变量都可以存储不同的值，但是调用的函数确是同一个
// 如果每个对象都放成员函数，而这些成员函数却是一样的，会浪费空间
// 如何计算一个类实例化出的对象的大小，计算成员变量之和，并且考虑内存对齐规则
// 没有成员变量的类的大小是1，面试题：为什么是1，而不是0。开1个字节不是为了存数据，而是占位
cout << sizeof(A1) << endl;
cout << sizeof(A2) << endl;
cout << sizeof(A3) << endl;
return 0;
}
实例化 -》就是用自己定义的类型定义出对象
1、内置类型，基本类型 int/char/double
2、自定义类型，class/struct
class Date
{
// this是谁调用这个成员函数，this就指向谁
public:
void Init(int year, int month, int day)//void Init(Date* this, int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()//void Print(Date* this)
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
d1.Init(2025, 2, 20); //(&d1,2025,2,20);
d1.Print(); //(&d1);
return 0;
}
this指针存在哪里？ (也就是存在进程地址空间的哪个区域？)
答：栈上的，因为它是一个形参。（ps:vs下是在ecx这个寄存器，来传递）
1、下面程序能编译通过吗？
2、下面程序会崩溃吗？在哪里崩溃？
class A
{
public:
void PrintA()
{
cout << _a << endl;
//cout << this->_a << endl;//会对空指针this进行解引用，会导致程序崩溃
}
void Show()
{
cout << "Show()" << endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr; //因为p->PrintA();用的是指针，所以p->Print(p)传的也是指针p
p->PrintA(); //崩溃
p->Show(); //正常运行
//成员函数存在公共的代码段，所有p->Show（）这里不会去p指向的对象上找
//访问成员函数，才会去找
A a;
a.PrintA();//p->Print(&a);这个地方a是对象，所以传的是&a，反正传的都是对象的地址
return 0;
}
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任
务并不是开空间创建对象，而是初始化对象。
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。
class Date
{
public:
//构造函数-》在对象构造时调用的函数，这个函数完成初始化工作
Date(int year, int month, int day)//构造函数没有返回值
{
_year = year;
_month = month;
_day = day;
}
Date()//函数重载
{
_year = 0;
_month = 1;
_day = 1;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
//对象实例化时自动调用
Date d1(2025, 2, 20);
d1.Print();
Date d2;//Date d2();不能加括号，调无参的不需要加括号，否则编译器不认识
d2.Print();
return 0;
}
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦
用户显式定义编译器将不再生成。
class Time
{
public:
Time()
{
cout << "Time()" << endl;
_hour = 0;
_minute = 0;
_second = 0;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
// 如果用户显式定义了构造函数，编译器将不再生成
// 我们没有显式定义的构造函数，这里编译器生成无参默认的构造函数（语法双标）
// 1、针对内置类型的成员变量没有做处理
// 2、针对自定义类型的成员变量，调用它的构造函数初始化
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
基本类型(内置类型)
int _year;
int _month;
int _day;
自定义类型
Time _t;
};
int main()
{
Date d1;//调用编译器生成的构造函数
d1.Print();
return 0;
}
7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。
class Date
{
public:
//更好的方式：全缺省
Date(int year = 0, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//不能和全缺省同时出现，因为调用的时候会出现歧义，Date d1;
//Date()//函数重载
//{
// _year = 0;
// _month = 1;
// _day = 1;
//}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;//调用默认构造函数 -》1、自己实现无参的构造函数 2、自己实现的全缺省构造函数
//3、编译器自动实现的构造函数 Date d1;的特点是不用传参数
d1.Print();
Date d1(2025, 3, 20);
d1.Print();
return 0;
}
class Date
{
public:
更好的方式：全缺省
Date(int year = 0, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
不能和全缺省同时出现，因为调用的时候会出现歧义，Date d1;
Date()//函数重载
{
_year = 0;
_month = 1;
_day = 1;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2;
return 0;
}
