文章目录
1 面向对象
面向过程：注重函数和方法
面向对象：将一件事拆分成不同的对象，注重对象之间的交互
基于面向对象：C++，面向对象+面向过程混编（因为C++兼容C）
纯面向对象：Java，只有面向对象
2 类
2.1 类的写法
代码演示：
#include <iostream>
// 类的关键字：class/struct
struct StuA {
char _name[10];
int _age;
int _id;
void InitA(const char name[],int age,int id) {
strcpy(_name, name);
_age = age;
_id = id;
}
void PrintA() {
std::cout << _name << " ";
std::cout << _age << " ";
std::cout << _id << std::endl;
}
};
class StuB {
public:
char _name[10];
int _age;
int _id;
void InitB(const char name[], int age, int id) {
strcpy(_name, name);
_age = age;
_id = id;
}
void PrintB() {
std::cout << _name << " ";
std::cout << _age << " ";
std::cout << _id << std::endl;
}
};
int main() {
StuA s1;
strcpy(s1._name, "张三");
s1._age = 10;
s1._id = 1;
s1.PrintA();
StuA s2;
s2.InitA("李四", 19, 2);
s2.PrintA();
StuB s3;
strcpy(s3._name, "李丽");
s3._age = 20;
s3._id = 3;
s3.PrintB();
StuB s4;
s4.InitB("李明", 21, 4);
s4.PrintB();
}
运算结果：
说明：
（1）C++中类的关键字有struct和class，其中struct是C中的“升级版”；
（2）类中可以定义成员变量和成员方法；
2.2 类的访问限定
访问限定类型：
private：只能在类内访问
protected：类似private
public：可以在类外访问
默认值(class和struct的区别)：
class中的成员变量和方法默认为private；
struct中的成员变量和方法默认为public（为了兼容C）
使用方法：
在要设定访问限定的成员变量/成员方法前加上访问限定类型词及:，限定类型的范围为下一个限定类型词前的全部内容，如上代码class StuB中的public:，
访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别
2.3 类的封装
定义：
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。通俗来说就是把数据和方法都放进类里面。封装本质是一种管理。
2.4 类的作用域
类单独形成一个作用域，类外调用类内成员需要加类名::
代码演示：
class Test{
public:
void test();
};
void Test::test() {
std::cout << "hello" << std::endl;
}
int main() {
Test a;
a.test();
}
运行结果：
2.5 类的实例化
用类类型创建对象的过程，称为实例化
类不占用实际的内存空间，实例化出的对象占用实际的物理空间，存储类成员变量
2.6 类对象的大小
计算方法：
（1）只有成员变量占用内存空间，成员方法不占用内存空间，成员方法存储在公共代码区
（2）成员变量占用空间大小的计算方法和C结构体大小的计算方法一致（内存对齐）
（3）没有成员变量的类（包括空类）的大小为1字节，用来唯一标识这个类，这1字节不存储有效数据，只是为了占位，表示对象存在
内存对齐规则
- 第一个成员在与结构体偏移量为0的地址处。
- 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
注意：对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。
VS中默认的对齐数为8 - 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
- 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
2.7 this指针
C++编译器给每个非静态的成员函数增加了一个隐藏的指针参数this，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中(成员函数内)所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
this的使用：
（1）this->成员变量：区分成员变量和形参
（2）每个成员函数的参数都隐含一个类名* const this的形参，对象调用成员函数时参数隐含对象的地址，由编译器自动传入
// 日期类
class Date
{
public:
void Display() // void Display(Date* const this)
{
cout << _year << "-" << _month << "-" << _day << endl;
// cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
}
void SetDate(int year, int month, int day) //void SetDate(Date* const this, int year, int month, int day)
{
_year = year; // this->_year = year
_month = month;
_day = day;
}
private:
int _year; // 年
int _month; // 月
int _day; // 日
};
int main()
{
Date d1, d2;
d1.SetDate(2018, 5, 1); // d1.SetDate(&d1,2018,5,1);
d2.SetDate(2018, 7, 1);
d1.Display(); // d1.Display(&d1);
d2.Display();
return 0;
}
this的存储：
局部变量一般存储在栈内，有些编译器（如VS）进行了优化，将this存在了寄存器ecx中。对象中只存储成员变量。
this可以为空吗：
当成员函数内使用成员变量时this不可以为空，因为每个成员变量前也都隐含this：如成员变量_a会被编译器识别为this->_a，此时若this为空则会发生空指针引用，程序崩溃。
class A
{
public:
void PrintA()
{
std::cout << _a << std::endl;
}
void Show()
{
std::cout << "Show()" << std::endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->Show(); // 可以，因为Show()中不使用this
p->PrintA(); // 不可以，因为PrintA()中使用了this->_a
}
2.8默认成员函数
类的默认成员函数有6个：构造函数；析构函数；拷贝构造函数；赋值重载函数；取地址；const取地址操作符重载
2.9 构造函数
功能：
进行初始化
特征：
无返回值；函数名为类名；可以重载；对象实例化时自动调用；类内没有显示定义时编译器会隐式生成一个无参构造函数
实现：
C++将类型分成内置类型和自定义类型，对于自定义类型成员变量会去调用它的默认构造函数。默认构造函数是不需要参数就可以调用的构造函数，分为三类：
- 编译器生成的隐式无参构造函数
- 自定义的隐式无参构造函数
- 自定义的全缺省构造函数
// 以日期类和栈来举例
// 日期类
class Date
{
public:
// 理论上无参和全缺省可以同时写，但是当有对象实例化的时候会产生二义性，程序编译报错
// 无参
Date() {
}
// 全缺省
Date(int year = 1001,int month = 1,int day = 1) {
_year = year;
_month = month;
_day = day;
}
void Display()
{
std::cout << _year << "-" << _month << "-" << _day << std::endl;
}
void SetDate(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year; // 年
int _month; // 月
int _day; // 日
};
int main()
{
Date d1;
d1.Display();
Date d2(2001);
d2.Display();
return 0;
}
运行结果：
构造函数赋值
构造函数体中的语句只能将其称作为赋初值
Date(int year,int month,int day) {
_year = year;
_month = month;
_day = day;
}
初始化列表
格式
类名(形参1,形参2)
:成员变量(形参1)
,成员变量(形参2)
{}
其中:后和{}之前的内容称为初始化列表
public:
// 初始化列表
Date(int year, int month, int day)
:_year(year)
,_month(month)
,_day(day){}
特点
- 每个成员变量只能在初始化列表出现一次
- 引用成员变量、const成员变量、没有默认构造函数的成员必须在初始化列表中初始化
- 初始化列表中的先后次序不是初始化顺序，声明次序才是
- 对于自定义类型成员变量，一定会先使用初始化列表进行初始化
2.10 析构函数
功能：完成对象的一些资源清理工作
特征：
无参；无返回值；形式为~类名；无显式声明编译器会自动生成默认
Date类的析构函数
class Date
{
public:
~Date()
{
cout << "~Date()" << endl;
}
};
2.11 拷贝构造函数
是构造函数的一种重载形式，用已存在的对象创建一个新对象，分为浅拷贝(默认拷贝构造是浅拷贝)和深拷贝
特征：
参数为类类型的引用(避免传值引发无穷递归调用)；类内没有显示定义时编译器会隐式生成一个无参构造函数
Date类的拷贝构造
class Date
{
public:
~Date()
{
cout << "~Date()" << endl;
}
};
2.12 赋值运算符重载
对运算符号进行重载，可以对自定义类型应用，不可重载的运算符有：（1）?: （2）.*（3）.（4）::（5）sizeof
特征：
函数名为operator运算符；有隐形默认形参this；一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝；
Date类的运算符重载
bool Date::operator>(Date d) {
if (_year > d._year) {
return true;
}
else if (_year == d._year && _month > d._month) {
return true;
}
else if (_year == d._year && _month == d._month && _day > d._day) {
return true;
}
else {
return false;
}
}
bool Date::operator>=(Date d) {
if (_year > d._year) {
return true;
}
else if (_year == d._year && _month > d._month) {
return true;
}
else if (_year == d._year && _month == d._month && _day >= d._day) {
return true;
}
else {
return false;
}
}
bool Date::operator<(Date d) {
if (_year < d._year) {
return true;
}
else if (_year == d._year && _month < d._month) {
return true;
}
else if (_year == d._year && _month == d._month && _day < d._day) {
return true;
}
else {
return false;
}
}
bool Date::operator<=(Date d) {
if (_year < d._year) {
return true;
}
else if (_year == d._year && _month < d._month) {
return true;
}
else if (_year == d._year && _month == d._month && _day <= d._day) {
return true;
}
else {
return false;
}
}
bool Date::operator==(Date d) {
if (_year == d._year && _month == d._month && _day == d._day)
return true;
else
return false;
}
bool Date::operator!=(Date d) {
return !(_year == d._year && _month == d._month && _day == d._day);
}
// 实现计算n天后是几号，并将结果覆盖this
Date& Date::operator+=(int day) {
_day += day;
while (_day > GetDay(_year, _month)) {
_day -= GetDay(_year, _month);
_month++;
if (_month > 12) {
_year++;
_month = 1;
}
}
// 出了作用域之后还在的可以用引用返回
// *this就是对象d，可以用
return *this;
}
Date Date::operator+(int day) {
// 拷贝构造，不改变原对象
Date d(*this);
// 用重载的+=改变d
d += day;
return d;
}
// 实现计算n天前是几号
Date& Date::operator-=(int day) {
_day -= day;
while (_day <= 0) {
if (_month == 1) {
_year--;
_month = 13;
}
_month--;
_day += GetDay(_year, _month);
}
return *this;
}
Date Date::operator-(int day) {
Date d(*this);
d -= day;
return d;
}
// 前置++
// 返回++后的值
Date& Date::operator++() {
*this += 1;
return *this;
}
Date Date::operator++(int) {
Date d(*this);
*this += 1;
return d;
}
Date& Date::operator--() {
*this -= 1;
return *this;
}
Date Date::operator--(int) {
Date d(*this);
*this -= 1;
return d;
}
2.13 取地址及const取地址运算符重载
这两个成员函数一般使用编译器默认生成的
const修饰的成员函数
const成员变量为只读变量，只能通过初始化列表初始化
const成员函数不能直接改写成员变量的值，并且只能调用const成员函数
const对象为只读对象，只能调用const成员函数，非const对象也可以调用const成员函数
思考：
- const对象可以调用非const成员函数吗？不可以
- 非const对象可以调用const成员函数吗？可以
- const成员函数内可以调用其它的非const成员函数吗？不可以
- 非const成员函数内可以调用其它的const成员函数吗？可以
2.15 典型类的成员函数分析
日期类Date
1. 构造函数
需要自己生成，为成员变量赋值
2. 析构函数
不需要自己生成，没有资源需要清理
3. 拷贝构造函数
不需要自己生成，默认的浅拷贝足够使用
4. 赋值运算符重载
不需要自己生成
栈Stack
1. 构造函数
需要自己生成
2. 析构函数
需要自己生成，额外开辟了空间
3. 拷贝构造函数
需要自己生成，否则浅拷贝会将现成对象开辟的地址也拷贝给新对象
4. 赋值运算符重载
需要自己生成深拷贝
两个栈形成一个队列MyQueue
class MyQueue{
public:
// 默认生成构造函数和析构函数会对自定义类型成员调用他的构造和析构
void push(int x) {
}
private:
Stack pushST;
Stack popST;
};
1. 构造函数
不需要自己实现
2. 析构函数
不需要自己实现
3. 拷贝构造函数
不需要自己实现
4. 赋值运算符重载
不需要自己实现
2.16 static成员
声明为static的类成员称为类的静态成员，用static修饰的成员变量叫静态成员变量，用static修饰的成员函数叫静态成员函数。
特征
- 静态成员为所有类对象共享，不属于某个具体的实例；
- 静态成员变量需要在类外进行初始化，且不添加static关键字；
- 类静态成员可用类名::静态成员或对象名.静态成员来访问；
- 静态成员没有隐藏的this指针，不能访问任何非静态成员；
- 静态成员可以设置访问限定符和返回值；
- 静态成员函数不可以调用非静态成员函数，非静态成员函数可以调用类的静态成员函数
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
