类和对象->四个默认成员函数->运算符重载

最新推荐文章于 2022-07-28 10:33:42 发布

Quinn0918

最新推荐文章于 2022-07-28 10:33:42 发布

阅读量1.2k

点赞数 2

分类专栏： C++ 文章标签：类和对象

本文链接：https://blog.csdn.net/Quinn0918/article/details/73718626

版权

C++ 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

类和对象

类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例（Instance），拥有类的成员变量和成员函数。

与结构体一样，类只是一种复杂数据类型的声明，不占用内存空间。而对象是类这种数据类型的一个变量，或者说是通过类这种数据类型创建出来的一份实实在在的数据，所以占用内存空间。
类的定义
类是用户自定义的类型，如果程序中要用到类，必须提前说明，或者使用已存在的类（别人写好的类、标准库中的类等），C++语法本身并不提供现成的类的名称、结构和内容。

一个简单的类的定义：

#include<iostream>
using namespace std;
class Student{
private:
    //成员变量
    char *name;
    int age;
    float score;
public:
    //成员函数
    void say(){
        cout << name << "的年龄是" << age << "，成绩是" << score << endl;
    }
};

class是 C++ 中新增的关键字，专门用来定义类。Student是类的名称；类名的首字母一般大写，以和其他的标识符区分开。{ }内部是类所包含的成员变量和成员函数，它们统称为类的成员（Member）；由{ }包围起来的部分有时也称为类体，和函数体的概念类似。
访问限定符：public也是 C++ 的新增关键字，它只能用在类的定义中，表示类的成员变量或成员函数具有“公开”的访问权限。
与之对应的是private关键字，有“保护”权限。
注意在类定义的最后有一个分号;，它是类定义的一部分，表示类定义结束了，不能省略。
整体上讲，上面的代码创建了一个 Student 类，它包含了 3 个成员变量和 1 个成员函数。

类只是一个模板（Template），编译后不占用内存空间，所以在定义类时不能对成员变量进行初始化，因为没有地方存储数据。只有在创建对象以后才会给成员变量分配内存，这个时候就可以赋值了。

类可以理解为一种新的数据类型，该数据类型的名称是 Student。与 char、int、float 等基本数据类型不同的是，Student 是一种复杂数据类型，可以包含基本类型，而且还有很多基本类型中没有的特性，以后大家会见到。
创建对象

有了 Student 类后，就可以通过它来创建对象了，例如：

Student liLei;  //创建对象

Student是类名，liLei是对象名。这和使用基本类型定义变量的形式类似：

int a;  //定义整型变量

从这个角度考虑，我们可以把 Student 看做一种新的数据类型，把 liLei 看做一个变量。

在创建对象时，class 关键字可要可不要，但是出于习惯我们通常会省略掉 class 关键字，例如：

class Student LiLei;  //正确
Student LiLei;  //同样正确

除了创建单个对象，还可以创建对象数组：

Student allStu[100];

该语句创建了一个 allStu 数组，它拥有100个元素，每个元素都是 Student 类型的对象。
访问类的成员

创建对象以后，可以使用点号.来访问成员变量和成员函数，这和通过结构体变量来访问它的成员类似，如下所示：

#include<iostream>
using namespace std;
//类通常定义在函数外面
class Student{
public:
    //成员变量
    char *name;
    int age;
    float score;
public:
    //成员函数
    void say(){
        cout << name << "的年龄是" << age << "，成绩是" << score << endl;
    }
};
int main(){
    //创建对象
    Student stu;
    stu.name = "小明";
    stu.age = 15;
    stu.score = 92.5f;
    stu.say();
    return 0;
}

运行结果：
小明的年龄是15，成绩是92.5

stu 是一个对象，占用内存空间，可以对它的成员变量赋值，也可以读取它的成员变量。
面现对象封装性
封装是实现信息隐蔽的一种技术，其目的是使类的定义和实现分离。C++的一个特性，相信很多的人自认为理解，完全的理解，至少我是这么认为的，在三个特性中我认为封装性最容易理解，但是随着对面向对象的了解和认识，我对封装性有了新的认识，感觉以前的认识十分的片面。正如上面所说封装性是c++语言的特性，而语言是用来约束程序员的，以前的理解就是类像一个包，而里面有一些数据，程序员的代码不能随便访问。然而这种封装是比较片面的。

Everything has a purpose，而封装存在的理由就是重用，重用就是写的一个代码库可以在很多地方重用，而且易于扩充。在一块内存中可以被许多应用程序运用，从开发的角度这样十分的省事，不必做重复的工作，在使用的角度，十分的节约内存，以前一个程序要加载一个库，现在几个程序只需加载一个库就可以了。这就是重用，使用以前的概念是无法实现这个目的的。聪明的程序员解决了这个问题。使用com组件技术，做到了二进制级别的代码重用。相当于扩充了操作系统，因为操作系统就是一个开放的接口，供应用程序调用功能。这就需要二进制级别的封装，

而由于一样的c++代码由不同的编译器编译出来的代码不一样，造成了代码之间的兼容问题。因为你封装起来的东西给了使用不同编译器的程序员获得的代码是不一样的，这样就不具备扩充性和灵活性。不能实现代码重用。

所以c++语言级别的封装性是十分狭隘的。

各种角度看封装

用户：我只需要个能用的，能升级的产品。

客户程序员：我需要的是可扩展的，封装的，插件式的库，这个库的东西不能影响到程序框架中的其他部分

库程序员：给客户程序员一个接口和一个二进制级别的代码。以实现可扩充行和可重用性。

内存：对我而言没有封装，计算机的一个基本概念，越往底层限制的东西越少。

编译器：我编译出来的代码要具有封装性，必须处理我和同行之间的差异。

C++语言：无辜的我是用来限制程序员的。但是也可以使用我的巧妙规则开提高你的水平，来实现你所需要的重用和扩充性。

对象的大小、计算
对象的大小计算依旧遵守内存对齐的原则
结构体内存对其规则：
1.第一个成员在与结构体变量偏移量为0的地址处。
2.其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
//对齐数=编译器默认的一个对齐数与该成员大小的较小值。
VS中默认的值为8
gcc中的默认值为4
3.结构体总大小为最大对齐数（每个成员变量除了第一个成员都有一个对齐数）的整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体
的对齐数）的整数倍。

空类对象(无成员变量的类)的大小也不一样，VC中为1。
实例化的原因（空类同样可以被实例化），每个实例在内存中都有一个独一无二的地址，为了达到这个目的，编译器往往会给一个空类隐含的加一个字节，这样空类在实例化后在内存得到了独一无二的地址，所以大小为1。
　当然在不同的编译器上得到的结果可能不同，但是这个实验告诉我们，不管类是否为空类，是否有成员变量，这个类在创建对象的时候都是需要分配空间的。

四个默认成员函数

1.构造函数
成员变量为私有的，要对它们进行初始化，必须用一个公有成员函数来进行。同时这个函数应该有且仅在定义对象时自动执行一次，这时
调用的函数称为构造函数（constructor）。
构造函数是特殊的成员函数，其特征如下：
1. 函数名与类名相同。
2. 无返回值。
3. 对象构造（对象实例化）时系统自动调用对应的构造函数。
4. 构造函数可以重载。
5. 构造函数可以在类中定义，也可以在类外定义。
6. 如果类定义中没有给出构造函数，则C++编译器自动产生一个缺省的构造函数，但只要我们定义了一个构造函数，系统就不会自动
生成缺省的构造函数。
7. 无参的构造函数和全缺省值的构造函数都认为是缺省构造函数，并且缺省的构造函数只能有一个。
2.拷贝构造函数
创建对象时使用同类对象来进行初始化，这时所用的构造函数称为拷贝构造函数（Copy Constructor），拷贝构造函数是特殊的构造函
数。
特征：
1. 拷贝构造函数其实是一个构造函数的重载。
2. 拷贝构造函数的参数必须使用引用传参，使用传值方式会引发无穷递归调用。（思考为什么？）
先从一个小例子开始：（自己测试一下自己看看这个程序的输出是什么？）

#include<iostream>  
using namespace std;  

class CExample  
{  
private:  
    int m_nTest;  

public:  
    CExample(int x) : m_nTest(x)      //带参数构造函数  
    {   
        cout << "constructor with argument"<<endl;  
    }  

    // 拷贝构造函数，参数中的const不是严格必须的，但引用符号是必须的  
    CExample(const CExample & ex)     //拷贝构造函数  
    {  
        m_nTest = ex.m_nTest;  
        cout << "copy constructor"<<endl;  
    }  

    CExample& operator = (const CExample &ex)//赋值函数(赋值运算符重载)  
    {     
        cout << "assignment operator"<<endl;  
        m_nTest = ex.m_nTest;  
        return *this;  
    }  

    void myTestFunc(CExample ex)  
    {  
    }  
};  

int main(void)  
{  
    CExample aaa(2);  
    CExample bbb(3);  
    bbb = aaa;  
    CExample ccc = aaa;  
    bbb.myTestFunc(aaa);  

    return 0;     
}

这个例子的输出结果是：
[cpp] view plain copy
constructor with argument // CExample aaa(2);
constructor with argument // CExample bbb(3);
assignment operator // bbb = aaa;
copy constructor // CExample ccc = aaa;
copy constructor // bbb.myTestFunc(aaa);
如果你能一眼看出就是这个结果的话，恭喜你，可以站起来扭扭屁股，不用再往下看了。

如果你的结果和输出结果有误差，那拜托你谦虚的看完。

第一个输出： constructor with argument // CExample aaa(2);

如果你不理解的话，找个人把你拖出去痛打一顿，然后嘴里还喊着“我是二师兄，我是二师兄…….”

第二个输出：constructor with argument // CExample bbb(3);

分析同第一个

第三个输出： assignment operator // bbb = aaa;

第四个输出： copy constructor // CExample ccc = aaa;

这两个得放到一块说。肯定会有人问为什么两个不一致。原因是， bbb对象已经实例化了，不需要构造，此时只是将aaa赋值给bbb，只会调用赋值函数，就这么简单，还不懂的话，撞墙去！但是ccc还没有实例化，因此调用的是拷贝构造函数，构造出ccc，而不是赋值函数，还不懂的话，我撞墙去！！

第五个输出： copy constructor // bbb.myTestFunc(aaa);

实际上是aaa作为参数传递给bbb.myTestFunc(CExample ex)，即CExample ex = aaa；和第四个一致的，所以还是拷贝构造函数，而不是赋值函数，如果仍然不懂，我的头刚才已经流血了，不要再让我撞了，你就自己使劲的再装一次吧。

通过这个例子，我们来分析一下为什么拷贝构造函数的参数只能使用引用类型。

看第四个输出： copy constructor // CExample ccc = aaa;

构造ccc，实质上是ccc.CExample(aaa); 我们假如拷贝构造函数参数不是引用类型的话，那么将使得 ccc.CExample(aaa)变成aaa传值ccc.CExample(CExample ex)，即CExample ex = aaa，因为 ex 没有被初始化，所以 CExample ex = aaa 继续调用拷贝构造函数，接下来的是构造ex，也就是 ex.CExample(aaa)，必然又会有aaa传给CExample(CExample ex), 即 CExample ex = aaa;那么又会触发拷贝构造函数，就这下永远的递归下去。

所以绕了那么大的弯子，就是想说明拷贝构造函数的参数使用引用类型不是为了减少一次内存拷贝，而是避免拷贝构造函数无限制的递归下去。
3. 若未显示定义，系统会默认缺省的拷贝构造函数。缺省的拷贝构造函数会，依次拷贝类成员进行初始化。
3.析构函数
当一个对象的生命周期结束时，C++编译系统会自动调用一个成员函数，这个特殊的成员函数即析构函数（destructor）
构造函数是特殊的成员函数，其特征如下：
1. 析构函数在类名加上字符~。
2. 析构函数无参数无返回值。
3. 一个类有且只有一个析构函数。若未显示定义，系统会自动生成缺省的析构函数。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
5. 注意析构函数体内并不是删除对象，而是做一些清理工作。
4.赋值运算符重载
拷贝构造函数是创建的对象，使用一个已有对象来初始化这个准备创建的对象。
赋值运算符的重载是对一个已存在的对象进行拷贝赋值。

运算符重载

为了增强程序的可读性，C++支持运算符重载。
运算符重载特征:
1. operator+合法的运算符构成函数名（重载<运算符的函数名：operator<）。
2. 重载运算符以后，不能改变运算符的优先级/结合性/操作数个数。
5个C++不能重载的运算符: .* /:: /sizeof /?: /.

隐含的this指针

每个成员函数都有一个指针形参，它的名字是固定的，称为this指针，this指针是隐式的。(构造函数比较特殊，没有这个隐含this形参)
编译器会对成员函数进行处理，在对象调用成员函数时，对象地址作实参传递给成员函数的第一个形参this指针。
this指针是成员函数隐含指针形参，是编译器自己处理的，我们不能在成员函数的形参中添加this指针的参数定义，也不能在调用时显示传递对象的地址给this指针。

Quinn0918

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
类和对象->四个默认成员函数->运算符重载

类和对象类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例（Instance），拥有类的成员变量和成员函数。与结构体一样，类只是一种复杂数据类型的声明，不占用内存空间。而对象是类这种数据类型的一个变量，或者说是通过类这种数据类型创建出来的一份实实在在的数据，所以占用内存空间。类的定义类是用户自定义的类型，如果程
复制链接

扫一扫