文章目录
- 1.面向过程和面向对象初步认识
- 2.类的引入
- 3.类的定义
- 3.1声明和定义全部放在类体
- 3.2.声明放在.h,定义放在.cpp
- 4..类的访问限定符及封装
- 4.1封装
- 4.2访问限定符
- 4.3C++中的struct和class
- 5.类的作用域
- 6.类的实例化
- 6.1引入
- 6.2定义
- 7.类对象模型
- 7.1类对象的存储方式
- 1.猜想
- 2.验证
- 8.this指针
- 8.1this指针的引出
- 8.2this指针的特性
- 1.注意
- 2.练习
本篇在 C++入门(上) 及C++入门(下) 的基础上,正式开始学习面向对象程序设计语言–>C++语言。
本文内容:
1.初步认识面向对象
2.类的引入,定义,封装,访问,作用域,实例化
3.类的对象的大小的计算
4.this指针
1.面向过程和面向对象初步认识
C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题。
C++是基于面向对象的,关注的是对象,将一件事情拆分成不同的对象,靠对象之间的交互完
成。
2.类的引入
C语言中:
struct Stack
{
int* a;
int top;
int capacity;
};
void StackInit(struct Stack* ps);
void StackPush(struct Stack* ps, int x);
void StackPop(struct Stack* ps);
typedef struct ListNode_C
{
struct ListNode_C* next;
int val;
}LTNode;
C++:
struct Stack
{
void Init()
{
a = 0;
top = capacity = 0;
}
void Push(int x)
{
// ...
}
void Pop()
{
// ...
}
int* a;
int top;
int capacity;
};
struct ListNode_CPP
{
ListNode_CPP* next;
int val;
};
3.类的定义
class className
{
类体:由成员函数和成员变量组成
}; 注意分号
class:关键字
classname:类的名字
{}中放类的主体
类体中的内容:类的成员
类中的变量:类的属性或成员变量
类中的函数:类的方法或成员函数
3.1声明和定义全部放在类体
成员函数如果在类中定义,编译器会将符合条件的函数当成内联函数处理。
class person
{
public:
void show()
{
cout << _name << "-" << _sex << "-" << _age << endl;
}
private:
char* _name;
char* _sex;
int _age;
};
3.2.声明放在.h,定义放在.cpp
//person.h
class person
{
public:
void show();
private:
char* _name;
char* _sex;
int _age;
};
//person.cpp
#include"person.h"
void person::show()
{
cout << _name << "-" << _sex << "-" << _age << endl;
}
//test.c
int main()
{
return 0;
}
4…类的访问限定符及封装
4.1封装
面向对象的三大特性:封装、继承、多态。
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来
和对象进行交互。
封装本质上是一种管理,让用户更方便使用类。比如:对于电脑这样一个复杂的设备,提供给用
户的就只有开关机键、通过键盘输入,显示器,USB插孔等,让用户和计算机进行交互,完成日
常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。
对于计算机使用者而言,不用关心内部核心部件,比如主板上线路是如何布局的,CPU内部是如
何设计的等,用户只需要知道,怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计
算机厂商在出厂时,在外部套上壳子,将内部实现细节隐藏起来,仅仅对外提供开关机、鼠标以
及键盘插孔等,让用户可以与计算机进行交互即可。
在C++语言中实现封装,可以通过类将数据以及操作数据的方法进行有机结合,通过访问权限来
隐藏对象内部实现细节,控制哪些方法可以在类外部直接被使用。
4.2访问限定符
C++实现封装的方式:用类将对象的属性与方法结合在一块,让对象更加完善,通过访问权限选
择性的将其接口提供给外部的用户使用。
访问限定符:public protected private
注意:
- public修饰的成员在类里类外可以被访问
- protected和private修饰的成员在类里可以被访问,在类外不能直接被访问(此处protected和private是类似的)
- 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符或遇到“ } ”出现时为止
- class的默认访问权限为private,struct为public
- 访问限定符只在编译时有用,当数据映射到内存后,没有任何访问限定符上的区别
4.3C++中的struct和class
问题:C++中struct和class的区别是什么?
C++兼容C语言,C++中struct可以当成结构体使用,也可以用来定义类。struct定义的类默认访问权限是public,class定义的类默认访问权限是private。
5.类的作用域
类定义了一个新的作用域,类的所有成员都在类的作用域中。在类体外定义成员时,需要使用 ::
作用域操作符指明成员属于哪个类域。
类域主要影响访问,局部域可能影响生命周期。
生命周期与存储的位置有关系,存储在栈,堆,静态区,常量区的生命周期各不相同。
作用域跟编译器的搜索规则有关系:先局部后全局。
6.类的实例化
6.1引入
如何区分变量的声明和定义?
未开辟空间的:声明
开辟空间的:定义(全局变量,类、结构体创建了对象。)
sizeof()怎么算类和结构体的大小呢?
类好比一个蓝图,对象好比房子。类也有内存对齐规则。sizeof()去计算时好比只有蓝图但是可以计算可以住多少人。
问题代码:
fun.h
int age;//定义
fun.cpp
#include"fun.h"
test.cpp
#include"fun.h"
报错:链接冲突(声明不会进入符号表,定义才会)
两个.c文件都引用了一份头文件,全局变量会进入符号表,在.opp文件中就会出现两个age
解决办法:
1.声明和定义分离:
fun.h
extern int age;//声明
fun.cpp//既有声明又有定义
#include"fun.h"
int age = 0;//定义
test.cpp//只有声明
#include"fun.h"
Q:此文件只有声明,如何使用age呢?
A:与函数链接类似,在链接时会找到fun.cpp中age的定义
2.使用static
fun.h
链接属性不一样
int age;//所有文件可见,放入符号表
static int age;//当前文件可见,不放入符号表//定义
在下面两个文件中打印size的地址不一样,
说明两个文件中的size只在自己的.cpp文件中使用
fun.cpp
#include"fun.h"
test.cpp
#include"fun.h"
6.2定义
用类类型创建对象的过程,称为类的实例化
- 类是对 对象 进行描述的,是一个模型一样的东西,限定了类有哪些成员,定义出一个类并没
有分配实际的内存空间来存储它;比如:入学时填写的学生信息表,表格就可以看成是一个
类,来描述具体学生信息。
类就像谜语一样,对谜底来进行描述,谜底就是谜语的一个实例。
谜语:“年纪不大,胡子一把,主人来了,就喊妈妈” 谜底:山羊 - 一个类可以实例化出多个对象,实例化出的对象 占用实际的物理空间,存储类成员变量
int main()
{
Person._age = 100; // 编译失败:error C2059: 语法错误:“.”
return 0;
}
Person类是没有空间的,只有Person类实例化出的对象才有具体的年龄
- 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子,类就像是设计图,只设计出需要什么东西,但是并没有实体的建筑存在,同样类也只是一个设计,实例化出的对象才能实际存储数据,占用物理空间
7.类对象模型
问题:类中既可以有成员变量,又可以有成员函数,那么一个类的对象中包含了什么?如何计算
一个类的大小?
7.1类对象的存储方式
1.猜想
猜想了三种比较合理的方式,一起来探讨一下吧!
-
对象中包含类的各个成员
缺陷:每个对象中成员变量是不同的,但是调用同一份函数,如果按照此种方式存储,当一个类创建多个对象时,每个对象中都会保存一份代码,相同代码保存多次,浪费空间。那么如何解决呢? -
代码只保存一份,在对象中保存存放代码的地址
-
只保存成员变量,成员函数存放在公共的代码段
编译链接时就根据函数名去公共代码区找到函数的地址–>call(函数地址)。运行时不会去对象里找函数的地址。
aa1的作用:指明属于哪个域,然后去类对应的公共代码区寻找函数。
到底是哪种呢?
class A
{
public:
void func()
{
cout << "void A::func()" << endl;
}
//private:
char _a;
};
int main()
{
//正常运行
A* ptr = nullptr;
ptr->func();//void A::func()
//说明类对象的存储方式是第三种
//执行这一句代码时去调用func并没有对ptr解引用
//编译器根本不会去 ptr指向的对象里面去找func的地址
//因为函数没有存在ptr指向的对象里面而是存在公共代码区
//编译链接时直接去call func的地址(反汇编可清晰看到)
return 0;
}
2.验证
// 类中既有成员变量,又有成员函数
class A1
{
public:
void f1()
{
}
private:
int _a;
};
// 类中仅有成员函数
class A2
{
public:
void f2()
{
}
};
// 类中什么都没有---空类
class A3
{
};
int main()
{
cout << sizeof(A1) << endl;//4
cout << sizeof(A2) << endl;//1
cout << sizeof(A3) << endl;//1
return 0;
}
一个类的大小,实际就是该类中”成员变量”之和,当然要注意内存对齐.注意空类的大小,空类比较特殊,编译器给了空类一个字节来唯一标识这个类的对象。
类对象的存储也要用到内存对齐规则,忘记了的小伙伴点击传送门 自定义类型之结构体 再去复习一下吧!
8.this指针
8.1this指针的引出
// 单词和单词之间首字母大写间隔 -- 驼峰法 GetYear
// 单词全部小写,单词之间_分割 get_year
// 驼峰法
// a、函数名、类名等所有单词首字母大写 DateMgr
// b、变量首字母小写,后面单词首字母大写 dateMgr
// c、成员变量,首单词前面加_ _dateMgr
class Date
{
public:
//this 是作为一个关键字存在的
//this 指针本质上是一个成员函数的形参,是对象调用成员函数时,将对象地址作为实参传递给 this 形参。所以对象中不存储 this 指针。
//this 指针是成员函数第一个隐含的指针形参,一般情况由编译器通过 ecx 寄存器自动传递,不需要用户传递。
// 实参和形参位置不能显示传递和接收this指针
// 但是可以在成员函数内部使用this指针
//void Init(Date* const this, int year, int month, int day)
void Init(int year, int month, int day)
{
//this = nullptr; err
cout << this << endl;
this->_year = year;
this->_month = month;
this->_day = day;
}
//void Print(Date* const this)
void Print()
{
cout << this << endl;
cout << this->_year << "-" << _month << "-" << _day << endl;
}
private:
int _year; // 年 -> 声明
int _month; // 月
int _day; // 日
};
int main()
{
Date d1;
d1.Init(2022, 7, 17);//d1.Init(&d1, 2022, 7, 17);
Date d2;
d2.Init(2022, 7, 18);//d2.Init(&d2, 2022, 7, 18);
d1.Print();//d1.Print(&d1);
d2.Print();//d2.Print(&d2);
return 0;
}
Date类中有 Init 与 Print 两个成员函数,函数体中没有关于不同对象的区分,那当d1调用 Init 函
数时,该函数是如何知道应该设置d1对象,而不是设置d2对象呢?
C++中通过引入this指针解决该问题,即:C++编译器给每个**“非静态的成员函数“**增加了一个隐藏的指针参数,让该指针指向当前对象(函数运行时调用该函数的对象),在函数体中所有“成员变量”
的操作,都是通过该指针去访问。只不过所有的操作对用户是透明的,即用户不需要来传递,编译器自动完成。
8.2this指针的特性
1.注意
- this指针的类型:类类型* const,即成员函数中,不能给this指针赋值。
- 只能在“成员函数”的内部使用
- this指针本质上是“成员函数”的形参,当对象调用成员函数时,将对象地址作为实参传递给
this形参。所以对象中不存储this指针。 - this指针是“成员函数”第一个隐含的指针形参,一般情况由编译器通过ecx寄存器自动传
递,不需要用户传递
2.练习
1.代码题
#include<iostream>
using namespace std;
class A
{
public:
void PrintA()
{
cout << this << endl;
cout << _a << endl;
cout << _a << endl;
cout << _a << endl;
cout << _a << endl;
cout << _a << endl;
cout << _a << endl;
}
void Print(int x)
{
cout << this << endl;
cout << "Print()" << endl;
}
private:
int _a;
};
int main()
{
Q1:
A* p = nullptr;
p->Print(); //正常运行结果: 00000000 Print()
1.Print()函数没有存在ptr指向的对象里面,而是存在公共代码区
2.编译时编译器根本不会去p指向的对象里面去找Print()的地址
3.编译链接时直接去call Print()的地址
指针调用-->传递this指针 p的值传给this NULL不解引用不会出现问题
Q2:
p->PrintA(); // 运行崩溃
与Q1不同之处在于 this传过去后 相当于this->_a 即对NULL进行了解引用
Q3:
A aa;
aa.Print(1);
return 0;
}
2.理论题
this指针存在于哪里?
#include<iostream>
using namespace std;
class A
{
public:
void Print(int x)
{
cout << this << endl;
cout << "Print()" << endl;
}
private:
int _a;
};
int main()
{
A aa;
aa.Print(1);
return 0;
}
结论:
一般情况下,存在于栈区,因为他是一个形参,与局部变量一起,在函数调用时会建立栈帧。
但如果函数内部频繁使用了this指针,编译器就会进行一定优化,比如在vs下传递this指针是通过ecx寄存器传递的,使得this访问变量提高效率。