关于类和对象

一.类的定义

## 1）属性：就像一个人一样，变量就像人的身高体重，所以称之为属性

方法：就像一个人会开车一样，函数就是他能实现的功能，所以叫方法

## 2）第二条，例子如下

class Date { void Init(int year,int month,int day) { year=year;//会导致混淆的写法 //所以在定义时后要给变量加东西修饰 _year=year; } int _year; int _month; int _day; };

class Stack { void push(int x,int*a) { //函数的实现 } int *a; int top; int capacity; };

二.访问限定符

class Stack { publuic: //要公开的内容 private: //不公开的内容 };

C++中的struct同样可以用来定义类，与class大致相同，除了访问限定外和继承方式（后面会说到）其他没有区别

假如现在将函数的定义与声明分开，在类里面进行声明在外面定义的话，就要使用：：来引用类里面的变量

class Date { void Init(int year,int month,int day) int _year; int _month; int _day; }; void Data::Init(int year,int month,int day) { //函数内容 }

三.实例化

光用类搞出来的变量是相当于声明，实际上并没有直接开辟空间。形象的理解成类就是一张房子图纸，里面是无法直接住人的，但是实在得用类定义出来时，就相当建好了房子，现在里面可以住人了,这个过程就叫实例化

class Date { int year }; Date b; b.year;//这样就可以访问到

四.实例化对象的内存大小计算

1.只有非静态成员变量才会占内存，静态成员变量和函数是不会占空间的。

2.计算类的内存空间的原则和计算C语言中结构体大小的原则一样，都是对齐算法

1）原因：内存对齐是计算机系统对内存访问的一种优化机制 ——CPU 访问内存时，通常按 “对齐单位”（如 2 字节、4 字节、8 字节）批量读取，而非单字节读取。如果数据的起始地址是对齐单位的整数倍，CPU 能一次读取到目标数据；否则需要多次读取并拼接，降低效率。

2）计算方法：

规则 1：成员变量的偏移量规则

结构体中每个成员变量的偏移量（相对于结构体起始地址的字节数），必须是该成员变量自身大小的整数倍。若不足，则自动填充空白字节。

• 基本类型大小参考（32/64 位系统通用）：
  • char：1 字节，偏移量需是 1 的倍数（无限制）
  • short：2 字节，偏移量需是 2 的倍数
  • int：4 字节，偏移量需是 4 的倍数
  • long：4 字节（32 位）/8 字节（64 位）
  • float：4 字节，double：8 字节
  • 指针：4 字节（32 位）/8 字节（64 位）

规则 2：结构体总大小规则

结构体的总大小，必须是「最终对齐单位」的整数倍。若成员变量排列后的总长度不足，则在结构体末尾填充空白字节。

规则 3：嵌套结构体的对齐规则

若结构体包含嵌套的子结构体，子结构体的偏移量需是「子结构体自身最终对齐单位」的整数倍；且整个父结构体的最终对齐单位，取「父结构体基本类型成员最大大小」与「子结构体最终对齐单位」的较大值。

**最终对齐单位 = min (编译器默认对齐数，结构体中最大基本类型成员的大小)

这个对齐数是指前面有几个字节，联想前面的内存读取，就是为了方便读，所以要预留出。

EG:

struct A { char c1; short s; char c2; };

1+1(为short预留出来的）+2+1=5；

最终对齐单位是：min(4,2)=2;

要是二的倍数，所以算出来是6

3.特殊情况：

对于没有成员变量的类即空类，它们会占一个字节，单纯是为了占位，不让无法表示它存在过

五.关键字this

在实际使用时候传的参数是这样的

Date d1;

Init(&d1,int year,int month,int day)

对于最后一句话的理解：自己不能写this这个关键字，只能靠系统编译的时候自己加上去

1.const在*之前修饰的是指向的对象，在*之后修饰的是const本身

# 五.面向类的特性

六.构造函数

1.构造函数分为全缺省构造函数，带参构造函数，无参构造函数

2.命名规则：按类的名字命名

3.特点就是能自动调用，在实例化对象的时候就可以完成，起到一个初始化的作用。

同时也要注意全缺省和无参不能同时存在，虽然构成函数重载，但是会有调用歧义。

在调用下面无参构造函数时不能这样写

解释：错误写法会造成歧义，因为函数声明也是一样的格式。

4.特殊的成员变量：

1）const成员;要在构造初始化列 表初始化。

2）引用成员：要在构造初始化列表初始化，同时在定义的时候就要绑定对象。

3）static成员：要在类外初始化（因为他是属于类的，而非某个实例化对象。

class student { static int a; ...... }; student::a=10;

class Date { public: Date() { _year=1; _month=1; _day=1; } private: int _year; int _month; int _day; } int main() { //Date d1();//错误写法 Date d1;//正确写法 return 0; }

绝大多数情况下默认构造函数都需要我们自己就去写，在少数情况下比如Myqueue（就是用两个栈来实现队列），且stack有默认构造函数调用的时候就可以自动生成

总结：应写尽写

七.折构函数

第六点是在说假如我们自己编了一个没有释放内存的析构函数，系统还是会自动调用析构函数

注意：在监视的时候可以直接输入this来看类中的成员变量，前提是进入到析构函数里面

同时有两个对象是，先析构后面创建的

##什么时候要写析构函数：

1.没有申请内存时不用写，比如Date

2.申请了但是默认生成的够用比如Myqueue这种情况也不用写

3.其他情况要写，不然可能会造成内存泄漏，就是在类里面申请了空间

八.拷贝构造函数

由于构成函数重载，所以在命名的时候也以类的名字命名

##关于第四条的解释，自动生成的拷贝构造函数只能满足没有申请资源的拷贝工作，对于申请了资源比如stack这样的是需要自己手动拷贝构造函数,这种叫深拷贝

为什么深拷贝要自己写：

假如用的是系统写的浅拷贝，那么对于Stake这样申请了资源的，就会连地址一并拷贝过去，那这样就可以修改本体，显然不合理，并且由于指向的是一块地址，在return时候析构函数会调用两次，对于已经释放的地址再一次释放，会报错

class Stake { public: Stake(int x = 4)//构造函数 { Data* tem = (Data*)malloc(sizeof(Data) * x); if (tem == nullptr) exit(1); _a = tem; _capacity = x; _top = 0; } Stake(const Stake& st) { Data* tem = (Data*)malloc(sizeof(Data) * st._capacity); if (tem == nullptr) exit(1); _a = tem; memcpy(_a,st._a,sizeof(Data)*st.top); _top=st._top; _capacity=st._capacity; } ~Stake()//析构函数专门用来清理申请的内存防止泄露 { free(_a); _capacity = _top = 0; } private: Data* _a; size_t _capacity; size_t _top; };

在调用的时候有两种写法

Stake s1(s2);

Stake s1=s2;

s2是要拷贝的对象

九.运算符重载

bool operate==(Date d1,Date d2) { return d1.year==d2.year&&d1.month==d2.nmonth&&d1.day==d2.day; }

上面这样写法是外置的，也可以写内置的，外置有个问题就是无法访问到private修饰的成员变量，两种同时存在的时候系统会优先调用类里面内置的

class Date { public: Date() { _year=1; _month=1; _day=1; } bool operate==(Date d1) { return _year==d1._year&&_month==d2.month&&_day==d2.day; } private: int _year; int _month; int _day; } int main() { //Date d1();//错误写法 Date d1;//正确写法 return 0; }

返回引用的优势：

1.避免了产生临时对象，调用拷贝构造

2.实现连续赋值，假如返回的是临时对象，那么临时对象当右值无法继续赋值改变

3.直接修改原对象

int& getElement(vector<int>& vec, int idx) { return vec[idx]; // 返回vector中元素的引用 } int main() { vector<int> v = {1,2,3}; getElement(v, 0) = 10; // 直接修改原vector的第一个元素（变为10） return 0; }

关于赋值运算符重载

第二条是为了避免生成拷贝，

Date& operate=(const Date&d) { _year=d._year; _month=d._month; _day=d.day; return *this } Date (const Date& d) { _year=d._year; _month=d._month; _day=d.day; } Date d1(2025,1,12); Date d2(2025,1,13); d1=d2; Date d1(d2); Date d1=d2;

注意区分赋值运算符重载和复制拷贝的区别，赋值运算符重载是有返回类型的，同时在调用的时候也是不一样的，复制拷贝是在初始化的同时进行赋值。下面那种是复制拷贝的两种写法。

何时要手动实现，何时不用与拷贝构造是一样的

十.关于外部获得成员变量

这里插入介绍两个类外面获得成员变量的方法

1.直接写一个函数

class Data { private: int a = 10; public: int getA() const { return a; } // set函数：修改a的值，命名set+变量名 void setA(int newA) { if (newA >= 0) { a = newA; } else { cout << "值不合法，不修改！" << endl; } } }; // 调用 Data d1; d1.setA(20); // 合法，a变成20 cout << d1.getA() << endl; // 输出20 d1.setA(-5); // 不合法，提示错误，a还是20

2。通过运算符重载，比如重载[]来实现。

十一.<<与>>与&的重载实现

在绝大数情况下，&是不用重载实现的，系统默认的就够用了，但是在少数情况下，可以通过重载来实现隐藏自己的地址。下面是代码演示

Date* operator&() { return this; } const Date* operator&()const//这里的第一个const是保证返回类型是const { //第二个是保证在这里面不能修改 return this; } Date* operator&() { return nullptr;//也可以是其他地址 } const Date* operator&()const { return nullptr;//也可以是其他 }

十二.参数列表后面的const

在写函数定义的时候假如在参数列表后面跟一个const,下面代码演示不同

void Date::printt(Date*const this);//这样是this的指向不能改变 //上面这是编译器的const自带的，本来就有const修饰指向不能发生变化 void Date::printt（Date const *this)const;//括号里面的this是自带的，这里只是为了演示方便 void Date::printt（const Date const *this);//和上面等价

注意二者区别，const是和左边的结合，要是左边没有就和右边，第一行代码const修饰*只能保证指向性不变，下面才能保证对象不会被改变，这样可以有效避免传参时发生权限放大

解释：这样接收时候必然是不可修改的，不会存在在print内部可以修改this的数值

十三.初始化列表

class Date { private: Date (int & a,int year,int month,int day) :_year(year） ,_month(month) ,_year ,y(a) ,x(1) ,d1(1) ,_ptr((int*)malloc(12)) { if(_ptr==nullptr) return 1; } private: int _year; int _month; int _day; const int x; int& y; Time d1; int*_ptr; };

1.为什么那三种必须用初始化列表呢：

因为他们要在定义的地方初始化，而C++规定成员变量在初始化列表定义。加上这两类变量的 “不可二次赋值” 特性，而类的构造函数体执行时已经过了它们的合法初始化时机，只能在初始化列表这个唯一的 “初始化节点” 完成赋值。

关于第三种只要你写了任意一个带参且非全缺省的构造函数，编译器就不会再自动生成默认构造函数，这个类就成了「没有默认构造函数的类」。这时就要在唯一合法节点来初始化

初始化列表调用的格式与先前没有区别

2.声明时给缺省值

public: int _year=1; int _month=1; int _day=1;

这个是给初始化列表使用的

3.总结

成员变量全要走初始化列表

1.在初始化列表初始化的成员

2.没有在初始化列表初始化的成员

a.有缺省值用缺省值

b.无缺省值

x.内置类型，看编译器，大概率是随机值

y.自定义类型，调用默认构造，没有就报错

3.上面的三种必须在初始化列表初始化

##值得而注意的是，在类里面成员变量初始化的顺序是按照声明的顺序而非初始化列表里的顺序

**易混淆的点：很多同学可能以为构造函数与开辟空间有关，实际上二者无任何关系，构造函数是用来初始化的，开辟空间是在进入函数时一把开好了的

静态成员变量的初始化

由于静态成员变量是全体对象共有的，所以定义的时候初始化不能在类里面进行要外置

class Date { private: static int _a; } int Date::_a=1;

外面初始化的时候不必再写static

关于第三条，由于他没有this指针所以他无法访问其他成员变量，就是在静态成员函数里面对于非静态的啥也干不了，但是其他可以随便访问静态成员变量

静态变量初始化&销毁的时间：全局的静态变量在main函数开始之前就初始化，局部的在程序运行到那里的时候初始化。销毁的时候静态全在后面，同时全局静态最后。

十四.友元

十五.内部类

class A { private: static int _k; int _h=1; public: class B//默认B就是A的友元 { private: int _b=1; } }

这里的B仅仅 是访问方式发生了变化，其他方面与定义在外面没有任何区别。此时计算A的大小也只能得到_h的大小。