C++ ----类与对象（上）
Posted L_add
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++ ----类与对象（上）相关的知识，希望对你有一定的参考价值。
类与对象
1.面向过程和面向对象的初步认识
C语言是面向过程，关注过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
举例：外卖系统
面向过程：下单、接单、送餐的三个过程
面向对象：客户，商家，骑手，关注的是这三个类对象之间的关系
2.类的引入
C语言中，结构体只能定义变量
typedef int DataType;
struct Stack
{
DataType* a;
int size;
int capacity;
};
void StackPush(struct Stack* ps,DataType x);
//数据和方法是分离的，重点关注的是过程-》函数方法
C++中，结构体内不仅可以定义变量，也可以定义函数
typedef int DataType;
struct Stack//class Stack
{
void Init(int Initsize = 4)
{
a = (DataType*)malloc(sizeof(DataType));
size = 0;
capacity = Initsize;
}
void Push()
{
//...
}
//...
DataType* a;//成员变量的声明
int size;
int capacity;
};
int main()
{
Stack st;//类//定义
st.Init();//定义
//...
return 0;
}
类-》定义出一个新的类型
类由两部分构成：
1、成员变量（属性）
2、成员函数（行为）
C++中struct兼容C的所有用法，同时C++中把struct升级成类
C++中更喜欢用 class来代替struct
3.类的定义
//f.h
class Stack//声明和定义分离
{
void Init(int Initsize = 4);
void Push();
DataType* a;
int size;
int capacity;
};
//f.cpp
void Stack::Init(int Initsize = 4)
{
a = (DataType*)malloc(sizeof(DataType));
size = 0;
capacity = Initsize;
}
void Stack::Push()
{
//...
}
//...
4.类的访问限定符及封装
4.1访问限定符
C++实现封装的方式：用类将对象的属性与方法结合在一起，让对象更完整，通过访问权限选择性的将其接口提供给外部的用户使用
访问限定符说明
1、public修饰的成员在类外可以被直接访问
2、protected和private修饰的成员在类外不能被直接访问（此时protected和private是类似的）
3、访问权限作用域从该访问限定符出现的位置开始到下一个访问限定符出现时为止
4.class默认访问权限是private,struct为public(struct要兼容C)
4.2封装
面型对象三大特性：封装、继承、多态（不止）
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互
**封装的本质是一种管理。**数据和方法都封装到类中，不想给别人访问的，使用protected/private把成员封装起来。
5.类的作用域
类定义了一个新的作用域类的所有成员都在类的作用域中。在类体外定义成员，需要使用：：作用域解析符指明成员属于哪个类域。
class Person
{
public:
void Print();
private:
char name[20];
int num[10];
};
//需要指定Print是属于Person这个类域
void Person::Print()
{}
6.类的实例化
用类类型创建对象的过程，称为类的实例化
int main()
{
//类
Stack s1;//类的实例化
Stack s2;//类的实例化
return 0;
}
1、类是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的存储空间来存储它
2、一个类可以实例化出多个对象，实例化出的对象，占用实际的物理空间，存储类成员的变量
举例：
类相当于设计图，
类实例化出的对象就像使用设计图造出的房子
7.类对象模型
7.1类对象的存储方式
只保存成员变量，成员函数存放在公共的代码段
class A1
{
public:
void f1(){}
private:
int _a;
};
class A2
{
public:
void f2(){}
};
class A3
{};
int main()
{
A1 a1;
cout << sizeof(a1) << endl;
A2 a2;
cout << sizeof(a2) << endl;
A3 a3;
cout << sizeof(a3) << endl;
}
大小是1 是占位，表示对象存在过
7.2结构体内存对齐规则
1、第一个成员在与结构体偏移量为0的地址处
2、其他成员变量要对齐到对齐数的整数倍的地址处
对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值
3、结构体总体大小为：最大对齐数（所有变量类型最大者与默认对齐数取最小）的整数倍
4、如果嵌套了结构体，嵌套的结构体对齐到自己最大对齐数的整数倍处，结构体的整数大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
8.this指针
8.1this指针的引出
C++编译器给每个“非静态的成员函数”增加了一个隐藏的指针参数，让该指针指向当前对象（函数调用时该函数的对象），在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动来完成
class Date
{
public:
//编译器会增加一个隐含参数-》this
//void Init(Date* this,int year, int month, int day)
void Init(int year, int month, int day)
{
//year = year;//优先原则优先访问自己 可以
//Date::year = year //类域 可以
_year = year;
_month = month;
_day = day;
}
private:
//凡是命名变量，建议命名风格区分
int _year; // int year;
int _month;//int month;
int _day;// int day;
};
int main()
{
Date d1;
d1.Init(2021, 5, 24);
//d1.Init(&d1,2021,5,24);
Date d2;
d2.Init(2021, 5, 25);
//d2.Init(&d2,2021,5,25);
return 0;
}
哪个对象去调用函数成员，成员函数中访问的就是哪个对象中的成员变量（通过this指针）
class Date
{
public:
//1、this指针是隐含的，是编译器编译时加的，我们不能在调用和函数定义中加
//2可以在成员变量中使用this指针
void Init(int year, int month, int day)
{
this->_year = year;
this->_month = month;
this->_day = day;
cout << "this:" << this << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
cout << "d1:" << &d1 << endl;
d1.Init(2021, 5, 24);
Date d2;
cout << "d2:" << &d2 << endl;
d2.Init(2021, 5, 25);
return 0;
}
8.2this指针的特性
1、this指针的类型：类型* const
2、只能在成员函数的内部使用
3、this指针本质上是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参，所以对象中不存储this指针
4、this指针是成员函数第一个隐含的指针形参，一般由编译器通过ecx寄存器自动传递，不需要用户传递。
class A
{
public:
//成员函数中接受到的this是空指针
void PrintA()
{
cout << _a << endl;//error,进行了解引用操作
//this->_a
}
void Show()
{
cout << "Show()" << endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->PrintA();//能通过，不能运行，空指针
//
p->Show();//正常运行
//p->Show()等等这些函数，没有对p指针进行解引用
//因为Show等成员函数的地址没有存到对象里面
//成员函数的地址存放在公共代码段
return 0;
}
以上是关于C++ ----类与对象（上）的主要内容，如果未能解决你的问题，请参考以下文章