面向对象和面向过程区别
如：
设计简单外卖系统
面向过程：关注实现下单，接单，送餐=>体现在代码层面—函数/方法
面向对象：关注实现类对象及类对象间的关系，用户，商家，骑手以及他们之间的关系，他体现到代码层面–类的设计，以及类之间的关系
c++基于面向对象：面向对象与面向过程可以混编（c++兼容c）
Java纯面向对象：只有面向对象
类的引入
定义类可以用struct，class
定义一个最简单的类
c++里面兼容c里面结构体的用法
同时struct在c++里面也升级成了类
c++类的结构体不同的是除了可以定义变量，还可以定义函数
struct Student
{
//成员变量
char _name[10];//加个_就是一个成员变量
int _age;
int _id;
//成员方法
void init(const char* name, int age, int id)
{
strcpy_s(_name, name);//为了避免与定义的变量冲突，所以在成员变量里加个_来区分
_age = age;
_id = id;
}
void PRINT()
{
cout << _name << endl;
cout << _age << endl;
cout << _id << endl;
}
};
```cpp
int main()
{
//struct Student s1;//兼容c
Student s2;//升级到类，Student类型，也是类型
Student s3;
//这样一个一个弄就很麻烦，我们可以用成员函数
/*strcpy_s(s2.name, "hda");
s2.age = 12;
s2.id = 1;*/
s2.init("zhangshan", 12, 1);
s3.init("lisi", 15, 2);
s2.PRINT();
s3.PRINT();
Stack st;
st._init();
st._push(1);
int top=st.Top();
return 0;
}
面向对象----编程有三大特性：封装，继承，多态
封装：1.数据和方法放到了一起，在类里面
2.访问限定符
public，private，protect
访问限定符说明
public修饰的成员可以在类外面直接访问
private和protect修饰的成员不可以在类外面直接访问
class 的默认访问限定符是private，struct的默认访问限定符是public
在使用的时候，最好明确他的访问限定符，不要用默认访问限定符
封装是一种更好的严格管理,我们要执行的一切操作都要通过类里面的函数，乱操作可能会有问题
1。数据和方法都封装到类里面了
2.可以给你访问的定义成public，不想给你访问的定义成private
class Stack//调用这个接口是没有问题的
{
public:
void _init()//封装达到 的效果
{
_a = nullptr;
_top = _capacity = 0;
}
int Top()
{
assert(_top > 0);
return _a[_top - 1];
}
void _push(int x)
{
}
private:// 限制我们直接访问
int* _a;
int _top;
int _capacity;
};
class Student//Student1类名，class
{
//成员变量，不加访问限定符也是默认private
char _name[10];//加个_就是一个成员变量
int _age;
int _id;
//成员方法
public://访问限定符是从该访问限定符位置到下一个访问限定符的位置，如果后面没有访问限定符，就默认访问结束
void init(const char* name, int age, int id)
{
strcpy_s(_name, name);
_age = age;
_id = id;
}
//private://这下面就变成了私有
void PRINT()
{
cout << _name << endl;
cout << _age << endl;
cout << _id << endl;
}
};
计算类或类对象的大小
class Stack//调用这个接口是没有问题的
{
public:
void _init()//封装达到 的效果
{
_a = nullptr;
_top = _capacity = 0;
}
int Top()
{
assert(_top > 0);
return _a[_top - 1];
}
void _push(int x)
{
}
private:// 限制我们直接访问
int* _a;
int _top;
int _capacity;
};
//计算类或类对象大小，只看成员变量，考虑内存对齐，c++对齐和c结构体一致
int main()
{
//对象中存了成员变量，不存成员函数，成员函数在一个公共的代码区（代码段），
Stack s1;
Stack s2;
s1.top_ = 0;
s2.top_ = -1;
//不同对象调用成员函数，调用的是同一个
s1.init();//是到公共区域里面去找init
cout << sizeof(Stack) << endl;//=12，只和成员变量的总大小有关
cout << sizeof(s1) << endl;
//空类会给1个字节，不存储有效数据，只是占位，表示对象存在
return 0;
}
this指针
隐藏的this指针
调用成员函数时，不能显示传实参给this，
定义成员函数时，也不能显示声明传给this
在成员函数内部可以显示使用this
class Date
{
public:
//void Init(Date*this,int year, int month, int day)
void Init(int year,int month,int day)
{
//year = year;//假如year前后不加_区别，在局部范围内2022就是year，而不是year_
//Date::year = year;//指定这个year是Date里面的
year_ = year;
month_ = month;
day_ = day;
}
//void Print(//Date*this)//this->year_,this->month_,this->day
void Print()
{
//一般我们都不会显示的写this，没必要，但是实际上就是this->year_
cout <<this-> year_ << " " << month_ << " " << day_ << endl;
}
private:
//int year;
int year_;
int month_;
int day_;
};
int main()
{
Date d1;
d1.Init(2022, 1, 15);
d1.Print();
Date d2;//只考虑成员变量不考虑成员函数
d2.Init(2022, 1, 16);
d2.Print(//&d2);
}
面试题
1.this指针是存在哪的？严格来说是存在栈的，（形参）
有些编译器会放到寄存器里面，放到了ecx中，
2.this指针也可以为空
#include<iostream>
using namespace std;
class A
{
public:
//A* const this
void show()
{
cout << "show" << endl;
}
//A *const this
//进行了this->_a，对空指针解引用
void PrintA()
{
//this->_a
cout << a_ << endl;
}
private:
int a_;
};
int main()
{
A* p = nullptr;
p->show();//程序正常运行
//不会出现语法错误，，
//1。p是一个空指针，p调用成员函数不会编译报错，因为空指针不是语法错误，编译器检查不出来
//2.p虽然是个空指针，但是p调用成员函数也不会出现空指针访问，因为成员函数没有存在对象里面，
//3.这里会把p作为实参传递给隐藏this指针，
p->PrintA();//运行崩溃，出现了空指针，报在PrintA，
}