devbox
酷酷是懒虫
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

2024年近万字的超详细C++类和对象，快进来看看吧，阿里+头条+腾讯等大厂C C++笔试题目分享

作者：酷酷是懒虫 | 2024-07-26 13:58:39

赞

踩

2024年近万字的超详细C++类和对象，快进来看看吧，阿里+头条+腾讯等大厂C C++笔试题目分享

img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

1.1构造函数

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证 每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

1.1.1 特性:

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任 务并不是开空间创建对象，而是初始化对象。

其特征如下：

  1. 函数名与类名相同。

  2. 无返回值。

  3. 对象实例化时编译器自动调用对应的构造函数。

  4. 构造函数可以重载。

class Date
 {
  public:
      // 1.无参构造函数
      Date()
     {}
  
      // 2.带参构造函数
      Date(int year, int month, int day)
     {
          _year = year;
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦
用户显式定义编译器将不再生成。
          _month = month;
          _day = day;
     }
  private:
      int _year;
      int _month;
      int _day;
 };
  
  void TestDate()
 {
      Date d1; // 调用无参构造函数
      Date d2(2015, 1, 1); // 调用带参的构造函数
  
      // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则编译器无法分析清楚函数声明还是调用
      // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
      // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
      Date d3();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则编译器无法分析清楚是函数声明还是函数调用
      // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
      // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
      Date d3();

  1. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

  2. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

7.编译器生成的默认构造函数并没有什么用？

C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char…，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。

1.1.2 初始化列表

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。也就是虽然构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量 的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始 化一次，而构造函数体内可以多次赋值。

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟 一个放在括号中的初始值或表达式。

注意：

  1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

  2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量

const成员变量

自定义类型成员(且该类没有默认构造函数时)

  1. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量， 一定会先使用初始化列表初始化。

  2. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后 次序无关

1.1.3 explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无缺省值其余均有缺省值 的构造函数，还具有类型转换的作用。

用explicit修饰构造函数，将会禁止构造函数的隐式转换。

举例：
 // 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
 // explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
class Date {
public:
	//explicit Date(int year)
	//	:_year(year)
	//{}
	
	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具
	//有类型转换作用
	//  explicit修饰构造函数，禁止类型转换
	 explicit Date(int year, int month = 1, int day = 1)
	 : _year(year)
	 , _month(month)
	 , _day(day)
	 {}
	 
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};

void Test()
{
	Date d1(2022);
	Date d2(2023);
	Date d3(d2);
	// 用一个整形变量给日期类型对象赋值
	// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
	d1 = 2023;
	// 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
}

int main()
{
	Test();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

1.2析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由 编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

1.2.1 特性 :
析构函数是特殊的成员函数，

1.2.2其特征如下：

  1. 析构函数名是在类名前加上字符 ~。

  2. 无参数无返回值类型。

  3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载

  4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

5.

内置类型成员：销毁时不需要资源清理，最后系统直接将其内存回收即可；

自定义类型而：若一个类的对象内部也有对象，要将其内部包含的类的对象销毁，所以要调用这个类对应的析构函数。

  1. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如 Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

1.3 拷贝构造函数

1.3.1概念：

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

1.3.2特征： 拷贝构造函数也是特殊的成员函数
1.3.3特性如下：

  1. 拷贝构造函数是构造函数的一个重载形式。

  2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错， 因为会引发无穷递归调用。

  3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按 字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

#include<stdlib.h>
#include<iostream>

class Date
{
private:
    // 基本类型(内置类型)
    int _year = 2023;
    int _month = 4;
    int _day = 4;
    // 自定义类型
    Time _t;
};
class Time
{
public:
    Time()
    {
        _hour = 1;
        _minute = 1;
        _second = 1;
        //    注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
        //    义类型是调用其拷贝构造函数完成拷贝的。
    }
    Time(const Time& t)
    {
        _hour = t._hour+1;
        _minute = t._minute+1;
        _second = t._second+1;
        std::cout << "Time::Time(const Time&)" << std::endl;
    }
private:
    int _hour;
    int _minute;
    int _second;
};

int main()
{
    Date d1;//构造函数

    // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
    // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
        Date d2(d1);
    return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

其实此处Time生成的默认拷贝构造函数也是能使用的

class Time
{
public:
    Time()
    {
        _hour = 1;
        _minute = 1;
        _second = 1;
    }
    //Time(const Time& t)
    //{
    //    _hour = t._hour+1;
    //    _minute = t._minute+1;
    //    _second = t._second+1;
    //    std::cout << "Time::Time(const Time&)" << std::endl;
    //}
private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
private:
    // 基本类型(内置类型)
    int _year = 2023;
    int _month = 4;
    int _day = 4;
    // 自定义类型
    Time _t;
};
int main()
{
    Date d1;//构造函数

    // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
    // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
        Date d2(d1);
    return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

4.类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请 时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

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

1.使用已存在对象创建新对象

2.函数参数类型为类类型对象

3.函数返回值类型为类类型对象

1.4赋值运算符重载

1.4.1运算符重载的概念

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其 返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。 函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator 操作符(参数列表)

运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数。

bool operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year
   && d1._month == d2._month
        && d1._day == d2._day;
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

但是这是全局的operator==，如何保证其封装性呢？

class Date
{ 
public:
 Date(int year = 1900, int month = 1, int day = 1)
   {
        _year = year;
        _month = month;
        _day = day;
   }
    
    // bool operator==(Date* this, const Date& d2)
    // 这里需要注意的是，左操作数是this，指向调用函数的对象
    bool operator==(const Date& d2)
 {
        return _year == d2._year;
            && _month == d2._month
            && _day == d2._day;
 }
private:
 int _year;
 int _month;
 int _day;
};


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

注意：

1.不能通过连接其他符号来创建新的操作符：比如operator@。

2.重载操作符必须有一个类类型参数 用于内置类型的运算符，其含义不能改变。

例如：内置的整型+，不能改变其含义作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐 藏的this  .*  ::  sizeof  ?:  . 注意以上5个运算符不能重载。

1.4.2 赋值运算符重载：
1. 赋值运算符重载格式

参数类型：const T&，传递引用可以提高传参效率

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

检测是否自己给自己赋值：*this！=d1；

返回*this ：要复合连续赋值的含义

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现 一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值 运算符重载只能是类的成员函数。

3. 用户没有显式实现时

编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。

注意：

1.内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

2.如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

1.4.3前置++和后置++重载
  1. 前置++：返回+1之后的结果
     注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率

 Date& operator++()
 {
 _day += 1;
 return *this;
 }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

2.后置++

前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载

C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
自动传递
 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存
一份，然后给this+1
而temp是临时对象，因此只能以值的方式返回，不能返回引用


 Date operator++(int)
 {
 Date temp(*this);
 _day += 1;
 return temp;
 }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

1.5 const成员

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

1.6 取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需 要重载，比如想让别人获取到指定的内容！

 Date* operator&()
 {
 return this ;
 }
 const Date* operator&()const
 {
 return this ;
 }


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

2.初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟 一个放在括号中的初始值或表达式。

Date(int year, int month, int day)

     : _year(2023)
     , _month(4)
     , _day(4)
 {}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

注意：

  1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

  2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量   const成员变量    自定义类型成员(且该类没有默认构造函数时)

3.尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量， 一定会先使用初始化列表初始化。

  1. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后 次序无关

2.1 explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值 的构造函数，还具有类型转换的作用。

以下是C++11规定的多参数构造函数的隐式类型转换的举例

单参构造函数同理

using namespace std;

class A {
public:
	A(int a, int b,int c)
		: _year ( a),
	      _month (b),
	      _day (c)
	{

	}
	A(const A& a)
	{
		cout << "const A& " << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	A a = {1,2,3};
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  1. 单参/多参 构造函数，没有使用explicit修饰，具有类型转换作用

explicit修饰构造函数，禁止类型转换

3. static成员

3.1 概念：

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用 static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化 面试题：实现一个类，计算程序中创建出了多少个类对象。

3.2 特性

  1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

  2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

  3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问

  4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

  5. 静态成员也是类的成员，受public、protected、private 访问限定符的限定

问题：

  1. 静态成员函数可以调用非静态成员函数吗？不可以

  2. 非静态成员函数可以调用类的静态成员函数吗？可以

例题：求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

使用静态成员变量


using namespace std;


class Sum
	{


![img](https://img-blog.csdnimg.cn/img_convert/d392d03a42ad5e8212ea30e2a2885b0c.png)
![img](https://img-blog.csdnimg.cn/img_convert/eb1bd17eee8f11c2a7d0dda2a64a1faa.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

加static关键字，类中只是声明


3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问


4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员


5. 静态成员也是类的成员，受public、protected、private 访问限定符的限定



##### 问题：


1. 静态成员函数可以调用非静态成员函数吗？不可以


2. 非静态成员函数可以调用类的静态成员函数吗？可以



例题：求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。


使用静态成员变量




  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

using namespace std;

class Sum
{

[外链图片转存中…(img-UcExA6zj-1715677808891)]
[外链图片转存中…(img-kHLYMfMh-1715677808891)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/酷酷是懒虫/article/detail/885682
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号