目录
感谢各位大佬对我的支持,如果我的文章对你有用,欢迎点击以下链接
🐒🐒🐒 个人主页
🥸🥸🥸 C语言
🐿️🐿️🐿️ C语言例题
🐣🐣🐣 python
🐓🐓🐓 数据结构C语言
🐔🐔🐔 C++
🐿️🐿️🐿️ 文章链接目录
面向过程和面向对象初步认识
C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
我们以洗衣服例：
C语言洗衣服关注的是过程：放洗衣粉 搓衣服 换水 搓衣服 拧干 晾衣服
C++洗衣服关注的是对象： 人 衣服 洗衣粉 ，因为整个过程是由这三个对象共同完成的，不需要关注具体怎么洗衣服
类的引入
C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。
比如：之前在数据结构文章中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数，在C++入门基础（三）中有演示过
struct test
{
int a;
int b;
void Init()
{
cin >> a;
cin >> b;
}
int Add()
{
return a+b;
}
};
int main()
{
struct test t1;
test t2;
cout << "输入t1中a和b的值" << endl;
t1.Init();
cout <<"t1Add:" << t1.a << "+" << t1.b << "=" << t1.Add() << endl;
cout << "输入t2中a和b的值" << endl;
t2.Init();
cout << "t2Add:" << t2.a << "+" << t2.b << "=" << t2.Add() << endl;
return 0;
}
上面代码中struct test t1为C语言的用法，而 test t2是因为C++将结构体升级成了类，因为类名代表类型，test代表这个类的类型，所以struct可以省略掉
上面结构体的定义，在C++中更喜欢用class来代替
有了class之后一般就不像C语言中的结构体那样定义结构体了，比如class test t1一般写成test t1
类的定义
class className
{
// 类体：由成员函数和成员变量组成
}; // 一定要注意后面的分号
class为定义类的关键字，ClassName为类的名字，{}中为类的主体（注意类定义结束时后面分号不能省略）
类体中内容称为类的成员：
类中的变量称为类的属性或成员变量(一般情况下类的成员变量都是私有的,因为不希望有人直接去修改成员变量,一般都是通过成员函数去修改,但是这个不是强制要求的)
类中的函数称为类的方法或者成员函数。
类的两种定义方式
声明和定义全部放在类体中
注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理
class Stack
{
private:
int* a;
int top;
int capacity;
public:
void Init(int n)
{
a = (int*)malloc(sizeof(int) * n);
if (nullptr == a)
{
perror("malloc申请空间失败");
return;
}
capacity = n;
top = 0;
}
void Push(int x)
{
//...
a[top++] = x;
}
};
声名定义分离
声明放在.h文件中，成员函数定义放在.cpp文件中
//Stack.h
#include<iostream>
using namespace std;
class Stack
{
private:
int* a;
int top;
int capacity;
public:
void Init(int n = 4);
void Push(int x);
};
//Stack.cpp
#include"Stack.h"
void Init(int n )
{
a = (int*)malloc(sizeof(int) * n);
if (nullptr == a)
{
perror("malloc申请空间失败");
return;
}
capacity = n;
top = 0;
}
void Push(int x)
{
//...
a[top++] = x;
}
当运行代码的时候,我们发现报错了
注意这个报错不是因为private的原因,因为如果是private的原因报错会明确说出无法访问,并告诉你是private的原因
根据上面的报错,未定义标识符说明这些变量都没有定义,而未定义是因为找不到这些变量的出处,也就是不知道在哪定义的
编译器搜索默认都是在局部域和全局域中搜索,所以因为在Stack.cpp中没有定义这些变量,所以才会报错,所以需要让编译器去搜索Stack.h里的某个域
类的作用域
类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 ::
作用域操作符指明成员属于哪个类域。
除了全局域,其他的域都是用花括号括起来的
域的存在就可以解决函数名重复的问题
class Stack
{
private:
int* a;
int top;
int capacity;
public:
void Init(int n = 4);
void Push(int x);
};
class Queue
{
public:
void Init(int n);
void Push(int x);
};
有了域就可以使两个类中有相同名称的函数
所以上面代码中的报错是将Stack.cpp文件的函数当成了全局函数
域作用限定符是加载函数类型的右边
void Stack::Init(int n )
{
a = (int*)malloc(sizeof(int) * n);
if (nullptr == a)
{
perror("malloc申请空间失败");
return;
}
capacity = n;
top = 0;
}
void Stack::Push(int x)
{
//...
a[top++] = x;
}
成员变量命名规则建议
class Date
{
void Init(int year,int month,int day)
{
year = year;
month = month;
day = day;
}
int year;
int month;
int day;
};
上面的year month day很容易让人产生误会,为了很好的区分,推荐下面的这种写法
class Date
{
void Init(int year,int month,int day)
{
_year = year;
_month = month;
_day = day;
}
int _year;
int _month;
int _day;
};
当运行代码的时候,却发现报错了,显示的是不可访问
而当我们把class换成struct后却又可以正常运行了,说明class中有什么东西限制了访问
访问限定符
C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
- public修饰的成员在类外可以直接被访问
- protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
- 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
- 如果后面没有访问限定符，作用域就到 } 即类结束。
- class的默认访问权限为private，struct为public(因为struct要兼容C)
所以在上面的代码中我们只需要加一个public就可以解决问题了
注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别
有道面试问题上这样的:C++中struct和class的区别是什么
C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来
定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类
默认访问权限是private,并且在继承和模板参数列表位置，struct和class也是有区别的
类的封装
面向对象的三大特性：封装、继承、多态。
封装：将数据和函数都放到类里面,然后通过访问限定符对类的成员进行限制
封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用
户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日
常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。
对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如
何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计
算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以
及键盘插孔等，让用户可以与计算机进行交互即可。
在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来
隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。
类的实例化
用类类型创建对象的过程，称为类的实例化
- 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没
有分配实际的内存空间来存储它
class Stack
{
public:
int* a;
int top;
int capacity;
};
int main()
{
Stack s1;
Stack::top++;
s1.top++;
}
这里的top无法使用就是因为top只是类中的一个声明,没有实例化,所以top没有占用空间,当用top++的时候就会报错
当把Stack::top++屏蔽掉后,只是告诉我们没有初始化局部变量,说明Stack.s1是已经有空间了,我们只需要对类里面的成员变量初始化就可以正常运行了
一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
int main()
{
Person._age = 100;
return 0;
}
Person类是没有空间的，只有Person类实例化出的对象才有具体的年龄。
类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间
类对象模型
类的对象大小的计算
类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算
一个类的大小？
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
int _year;
int _month;
int _day;
};
int main()
{
Date test;
cout << sizeof(test) << endl;
return 0;
}
在之前结构体中有了解过结构体的计算方式,C++的类的计算方式也非常相似,都遵循内存对齐原则
在上图可以知道这个类的大小为12个字节,而类中的成员即有函数,又有3个整形变量,而这3个整形的大小就是12个字节,那这么说函数是不占内存的吗?
显然是不可能的,所以猜测函数可能单独存在一块空间,而那块空间不会被计算到类的大小中去,那函数的空间会不会被共用呢?
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
int _year;
int _month;
int _day;
};
int main()
{
Date test;
Date test2;
test._year;
test2._year;
test.Init(1,2,3);
test2.Init(3,4,5);
cout << sizeof(test) << endl;
return 0;
}
通过汇编可以看出,两个相同的类可以共用同一个函数的空间,
综上可以得知,函数的内存不是和成员变量存在一起的,因为如果每次创建一个类,都需要开辟一看成员函数的空间,而成员函数的内容都是一样的,这样就太浪费空间了
所以存储方式是这样的,成员函数存在一块公共的区域,每次调用这个函数的时候就直接去公共区域里用就行了,这个公共的区域被叫做代码段/代码区
结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐
由于类域的存在,所以可能会存在不同的类用同一个函数名,为了区分,会在调用函数的时候加上类的类名
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
int _year;
int _month;
int _day;
};
class Queue
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
int _year;
int _month;
int _day;
};
在调用class Date和class Queue中的Init函数会将类名Date和Queue也加入进去,这样就不会调错函数了
如果类里面全是函数没有成员变量或者什么都没有的话,他的内存大小是多少呢
class Date
{
public:
void Init()
{
}
};
int main()
{
Date test;
cout << sizeof(test) << endl;
return 0;
}
按照之前的说法没有成员变量结果应该是0才对,其实是C++的规定,没有成员变量的大小为1字节(这个1字节是用来表示定义的对象存在,如果他的内存大小为0就表示他没有存在,取他的地址也为空,这不是我们想要的结果)
所以没有成员变量的类对象大小为1字节,这个1字节是用来占位标识对象实例化时定义出来存在过的
扩展
class Date
{
public:
void Init()
{
cout << "Date Init" << endl;
}
};
int main()
{
Date test;
Date* p1 = &test;
p1->Init();
return 0;
}
这个代码是通过一个指针p1指向test的地址,然后用箭头访问的方式取访问类的成员函数
再来看看下面的这个代码
class Date
{
public:
void Init()
{
cout << "Date Init" << endl;
}
};
int main()
{
Date test;
Date* p2 = nullptr;
p2->Init();
return 0;
}
Date*p2为空指针,但是却可以用p2访问类的成员函数,这是因为用箭头去访问不一定是解引用,这个取决于后面的值在不在指针指向的空间里,因为Init不在p2指向的空间里,所以不存在解引用,在编译的时候会直接调用函数Init,也就是说在编译的时候就确定Init存在哪里了,而不是在运行的时候再去找
结构体内存对齐规则
- 第一个成员在与结构体偏移量为0的地址处。
- 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
VS中默认的对齐数为8 - 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
- 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整
体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
