网站导航
> 文章列表 > 【C++】类和对象

【C++】类和对象

网友: 文章列表 2024-03-22 01:47:45

【C++】类和对象

C++类和对象

  • 1.类的引入
  • 2.类的定义
  • 3.类的访问限定符及封装
    • 3.1.访问限定符说明：
  • 4.类的实例化
  • 5.类对象模型
  • 6.this指针
    • 6.1.this指针的特性：
  • 7.类的6个默认成员函数
  • 8.构造函数
    • 8.1.构造函数特性：
  • 9.析构函数
  • 10.拷贝构造函数
    • 10.1.拷贝构造函数的特性：
    • 10.2.拷贝构造函数典型调用场景：
  • 11.运算符重载
    • 11.1.运算符重载注意点：
    • 11.2.赋值运算符重载
    • 11.3.前置++和后置++重载
  • 12.const成员
  • 13.取地址及const取地址操作符重载
  • 14.初始化列表
    • 14.1.初始化列表注意点：
  • 15.explicit关键字
  • 16.static成员
    • 16.1.static成员的特性：
  • 17.友元
    • 17.1.友元函数
    • 17.2.友元函数注意点：
    • 17.3.友元类
  • 18.内部类
    • 18.1.内部类特性：

1.类的引入

C语言结构体中只能定义变量，C++兼容C语言的struct语法，但同时C++将struct升级成了类。
所以在C++中，结构体内不仅可以定义变量，还可以定义函数。
但像结构体这样的定义，在C++中更喜欢用class来代替。

2.类的定义

class ClassName
{// 类体：有成员函数和成员变量组成
}; // 注意分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面的分号不能省略。
类体中的内容称为类的成员：类中的变量称为类的属性或成员变量；类中的函数称为类的方法或成员函数。

2.1.类的成员函数有两种定义方式：

  1. 声明和定义都放在类体中。但要注意的是：成员函数如果在类体中定义，编译器可能会(在符合一定条件的情况下)将其当做内联函数处理。
  2. 成员函数的声明放在.h文件中，定义放在.cpp文件中。但要注意的是：每一个类都定义了一个新的作用域，类的所有成员都在类的定义域中，所以在定义时成员函数的函数名前需要加上类名::来指定属于哪个类域。
    一般情况下，还是更推荐第二种方式来定义成员函数，这样声明和定义分离使代码可读性会更好。除非定义的函数体很小，想将其作为内联处理，直接在类里面定义即可。

3.类的访问限定符及封装

封装：封装本质上是一种管理，让用户可以更方便地使用类。
C++实现封装的方式：用类将对象的属性和方法结合到一块，通过访问权限(访问限定符)的设置将类的成员选择性地提供给外部的用户使用。
【C++】类和对象

3.1.访问限定符说明：

  1. public修饰的成员在类外可以直接被访问
  2. protected和private修饰的成员在类外不能直接被访问
  3. 访问权限的作用域从该访问限定符出现的位置开始，直到下一个访问限定符出现的位置结束，或者是到类结束的地方}结束。
  4. class的默认访问权限是private，struct的默认访问权限是public

4.类的实例化

用类类型创建对象的过程，就称为类的实例化。

  1. 类是对对象的描述，是一个模型一样的东西。它限定了对象有哪些成员，但定义一个类并没有为其分配实际的内存空间。
  2. 一个类可以实例化出多个对象，这些实例化出的对象才占用实际的物理空间，对成员变量进行存储。
    【C++】类和对象
    在现实中，用类实例化出对象就像是使用建筑设计图来建造出房子一样。

5.类对象模型

类对象中只保存有成员变量，成员函数存放在公共的代码段区域。
【C++】类和对象
程序会在编译链接时就会根据函数名去到公共代码区找到函数的地址，并call函数地址。

class A
{
public:void TestA(){cout << "void TestA()" << endl;}
};int main()
{A* ptr = nullptr;ptr->TestA();// 空指针不解引用return 0;
}

【C++】类和对象
【C++】类和对象
因为是在编译链接阶段就已经将函数名替换成了函数调用的地址，空指针并不会解引用，最终程序也能正常运行。
一个类的大小，实际是该类中的成员变量大小之和，但要注意内存对齐。
空类比较特殊，编译器会给空类一个字节来唯一标识这个类的对象。
关于内存对齐的知识，可以参考阿顺的这篇博文C语言结构体【内存对齐】与【实现位段】。

6.this指针

C++编译器给每个非静态的成员函数增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过不需要用户传递，编译器自动完成。
【C++】类和对象
在实际的程序中，实参和形参位置不能显示传递和接收this指针，但是可以直接在成员函数内部使用this指针。上图只是为了通过日期类来更清楚地说明this指针的使用，其中的代码并不是正确的。
this指针作为形参，一般来说是会压在栈上的。但有些编译器会进行优化，通过寄存器来存储传递this指针，这样就能提高this指针访问变量的效率。
【C++】类和对象

6.1.this指针的特性：

  1. this指针类型：类类型* const。
  2. 只能在成员函数内部使用。
  3. this指针本质上是成员函数的形参。当对象调用成员函数时，会自动将对象地址作为实参传递给this形参。
  4. this指针是成员函数第一个隐含的指针形参。

7.类的6个默认成员函数

如果一个类中什么成员都没有，就简称为空类。
但空类中并不是真的什么都没有。任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
【C++】类和对象
默认成员函数：用户不显式实现，编译器会自动生成的成员函数。

8.构造函数

构造函数是一个特殊的成员函数，虽然构造函数名称叫作构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
构造函数在创建类类型的对象时编译器会自动调用，以保证对象中的数据都有一个合适的初始值。构造函数在对象整个生命周期内只会调用一次。

8.1.构造函数特性：

  1. 函数名与类名相同。
  2. 无返回值。
  3. 对象实例化时，编译器会自动调用对应的构造函数。
  4. 构造函数可以重载。
  5. 如果类中没有显示定义构造函数，C++编译器会自动生成一个无参的默认构造函数。一旦用户显式定义了，编译器就不再生成。
  6. 默认生成的构造函数对内置类型不做处理，对自定义类型会去调用它的构造函数。
  7. C++11中针对内置类型不初始化的缺陷又打了一个补丁：内置类型成员变量在类中声明时可以给缺省值。
  8. 默认构造函数一共有三个：无参的构造函数，全缺省的构造函数，编译器默认生成的构造函数。

一般情况下，都会选择自己写一个全缺省的默认构造函数，这样会很好用。特殊情况下才会选择编译器默认生成。

9.析构函数

析构函数不是完成对象本身的销毁工作，而是在对象销毁时被调用来完成对象中资源的清理工作。
析构函数特性：

  1. 析构函数名是在类名前加上字符~。
  2. 无参数无返回值。
  3. 一个类只能有一个析构函数，析构函数不能重载。若未显式定义，系统会自动生成默认的析构函数。
  4. 对象生命周期结束时，C++编译系统会自动调用析构函数。
  5. 默认生成的析构函数，对内置内型不做处理，对自定义类型会去调用它的析构函数。
  6. 如果类中没有申请资源，析构函数可以不显式写，直接使用编译器默认生成的析构函数就够了；有申请资源时，就一定要显式写，否则会造成资源泄露。

创建哪个类的对象就调用该类的构造函数，销毁哪个类的对象就调用该类的析构函数。
下面来看一道关于构造和析构顺序的题目。

class A
{
public:A(int a = 0){_a = a;cout << "A(int a = 0) -> " << _a << endl;}~A(){cout << "~A() -> " << _a << endl;}
private:int _a;
};

A a5;void f()
{static A a3(3);A a1(1);A a2(2);static A a4(4);
}int main()
{	f();f();return 0;
}

【C++】类和对象
普通变量定义在函数内部，调用函数会在栈区创建栈帧，完成对象的创建构造；静态变量会直接在静态区完成创建构造。
函数调用完成，栈帧销毁，会引发对象的析构。因为栈区符合栈后进先出的特点，所以在栈区后创建构造的对象先析构。但栈帧被销毁并不会影响到静态的变量，因为静态区的变量是在静态区完成创建构造的，静态的变量直到程序运行结束后才会被析构。

10.拷贝构造函数

拷贝构造函数只有一个形参，这个形参是对本类类型的对象的引用(一般常用const修饰)。在用已存在的类类型对象创建新对象时由编译器自动调用。

10.1.拷贝构造函数的特性：

  1. 拷贝构造函数是对构造函数的一个重载形式。
  2. 拷贝构造函数的参数只有一个，且必须是类类型对象的引用。在使用传值方式传递参数是编译器会直接报错，因为这样会引发无穷的递归调用。
    【C++】类和对象
  3. 若未显式定义，编译器会生成默认的拷贝构造函数。默然生成的拷贝构造函数是按照内存存储的字节序来完成对象的创建工作，这种拷贝叫做浅拷贝(值拷贝)。
  4. 在编译器生成的默认拷贝构造函数中，内置类型是按照字节序方式直接拷贝的，自定义类型是调用它的拷贝构造函数来完成拷贝的。
  5. 类中如果没有涉及资源申请时，拷贝构造函数写不写都可以；一旦涉及到资源申请，就一定要写拷贝构造函数，否则就是浅拷贝。
    【C++】类和对象

10.2.拷贝构造函数典型调用场景：

  • 使用已存在的对象创建新的对象
  • 函数参数类型为类类型的对象
  • 函数返回值类型为类类型的对象

为了提高程序效率，一般对象在传参时，尽量使用引用类型传参；返回时根据实际场景，能用引用返回尽量使用引用返回。

11.运算符重载

C++语言中，对于内置类型可以直接使用运算符进行运算，因为编译器知道如何对内置类型进行运算。但是如果想要编译器也能知道如何对自定义类型进行运算，增强代码的可读性，就要引入运算符重载了。
运算符重载是具有特殊函数名的函数。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

11.1.运算符重载注意点：

  • 不能通过连接其它符号来创建新的操作符。比如：operator@
  • 重载操作符函数必须有一个类类型的参数。
  • 用于内置类型的运算符，其含义不能改变。
  • 作为类成员函数重载时，其形参个数看起来比操作数的个数少1，那是因为成员函数的第一个参数为隐藏的this。
  • .* :: sizeof ? : .，这5个运算符不能重载。

11.2.赋值运算符重载

  1. 赋值运算符重载格式：
  • 参数类型：const TypeName&，引用传参提高效率。
  • 返回值类型：TypeName&，引用返回可以提高返回效率，同时有返回值也是为了支持连续赋值。
  • 检测是否自己给自己赋值。
  • 返回*this：符合连续赋值的含义。
  1. 赋值运算符只能重载成类的成员函数，不能重载成全局函数。

我们可以重载赋值运算符。不论形参的类型是什么，赋值运算符都必须定义为成员函数。 —— 《C++ prime》

原因：赋值运算符如果不显式实现，编译器会在类中生成一个默认的。此时用户如果在类外自己实现一个全局的赋值运算符重载，就和编译器在类中默认生成的赋值运算符重载冲突了。所以赋值运算符重载只能是类的成员函数。
3. 用户没有显示实现时，编译器会默认生成一个赋值运算符重载，并以值的方式逐字节拷贝。注意：内置类型的成员变量是直接赋值的，而自定义类型的成员变量需要调用其对应的赋值运算符重载完成赋值。
4. 如果类中未涉及到资源的申请管理，赋值运算符写不写都可以；一旦涉及到资源的申请管理，就一定要自己显式写。
【C++】类和对象

11.3.前置++和后置++重载

前置++：返回+1之后的结果。
因为this指向的对象在函数结束后不会销毁，所以可以使用引用返回提高效率。
后置++：
前置++和后置++都是一元运算符，为了让前置++和后置++能正确形成重载，C++规定：后置++重载时多增加一个int类型的参数，但在调用函数时该参数不用传递，编译器会自动传递。
后置++是先使用，后+1。因此需要temp保存临时对象，函数只能以值的方式进行返回。

class Date
{
public:// 前置++Date& operator++(){*this += 1;return *this;}// 后置++Date operator++(int){Date temp = *this;*this += 1;return temp;}
private:int _year;int _month;int _day;
};

12.const成员

将const修饰的成员函数称之为cosnt成员函数。cosnt修饰类成员函数，实际修饰的是成员函数隐含的this指针，以表明在该成员函数中不能对对象的任何成员进行修改。

13.取地址及const取地址操作符重载

// 取地址
TypeName* operator&()
{return this;
}//const取地址
const TypeName* operator&()cosnt
{return this;
}

这两个运算符一般不需要重载，使用编译器默认生成的就够了。
除非特殊需要，比如想让别人获取到指定的内容。

TypeName* operator&()
{return nullptr;
}const TypeName* operator&()cosnt
{return nullptr;
}

14.初始化列表

在创建对象时，编译器通过调用构造函数，会给对象中的各个成员变量一个合适的初始值。
可这里要说的是，虽然构造函数在调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化。
构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以进行多次赋值。
所以这就引出了初始化列表的概念。
初始化列表：以一个冒号:开始，接着是一个以逗号,分隔的数据成员列表，每个成员变量后面跟一个放在括号中的初始值或表达式。

14.1.初始化列表注意点：

  1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
  2. 类中包含以下成员，必须放在初始化列表位置进行初始化
    • 引用成员变量
    • const成员变量
    • 自定义类型成员(且该类没有默认构造函数)
  3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
  4. 成员变量在初始化列表中的初始化顺序与其在类中的声明次序就有关，与其在初始化列表中的先后次序无关。

15.explicit关键字

构造函数不仅可以构造和初始化对象。在对于只有一个参数，或者有多个参数但除第一个参数外其余参数都有默认值的构造函数，他还有类型转换的作用。

class Date
{
public:/*explicit*/ Date(int year): _year(year){cout << "Date(int year)" << endl;}Date(const Date& d){cout << "Date(const Date& d)" << endl;}
private:int _year;
};int main()
{Date d = 2023;return 0;
}

上面代码如果将explicit放开，会出现下面的报错。
【C++】类和对象
2023作为整形，赋值给Date类型，需要发生类型转换。构造函数会先用2023构造一个Date类型的临时变量，然后拷贝构造给对象d。但当经过编译器的优化后，会将构造和拷贝构造两步工作优化成直接构造，如下面运行结果所示。
【C++】类和对象

16.static成员

声明为static的类成员称为类的静态成员。用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。

16.1.static成员的特性：

  1. 静态成员为所有的类对象所共享，不属于某个具体的对象，存放在静态区。
  2. 静态成员变量必须在类外进行定义，定义时不添加static关键字，类中已经声明。
  3. 类的静态成员可以使用类名::静态成员或者对象.静态成员来访问。
  4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
  5. 静态成员也是类的成员，受public、protected、private访问限定符的限制。

17.友元

17.1.友元函数

友元函数和普通函数一样，定义在类的外部，不属于任何类。但需要用friend关键字在类的内部进行声明，这样友元函数就可以直接访问类的私有成员了。

17.2.友元函数注意点：

  • 友元函数可以访问类的私有成员和受保护成员，但不是类的成员函数。
  • 友元函数不能用const修饰。
  • 友元函数可以在类中的任何地方声明，它不受访问限定符的限制。
  • 一个函数可以是多个类的友元函数。
  • 友元函数的调用与普通函数的调用原理相同。

17.3.友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

  • 友元关系是单向的，不具有交换性。
  • 友元关系不能传递。
    如果A是B的友元，B是C的友元，也不能说A是C的友元。
  • 友元关系不能继承。

18.内部类

如果一个类定义在了另一个类的内部，则这个内部的类就叫做内部类。内部类是一个独立的类，他不属于外部类。外部类对内部类没有任何优越的访问权限。
注意：内部类天生就是外部类的友元类。

18.1.内部类特性：

  1. 内部类在外部类的public、protected、private地方定义都是可以的。
  2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象或类名。
  3. sizeof(外部类)和内部类没有任何关系。
网络标签：

相关问题