C++ 类和对象(2)

最新推荐文章于 2024-06-06 18:23:45 发布
最新推荐文章于 2024-06-06 18:23:45 发布
阅读量380 收藏 9
点赞数 5
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FBI_BAIGOU/article/details/137919592
版权

theme: z-blue

本次内容大纲
在这里插入图片描述

类的6个默认成员函数

如果一个类中什么成员都没有 称之为空类

class Empty
{
};

空类并不是什么都没有 编译器会自动生成6个默认成员函数
默认成员函数： 用户自己没有写 编译器会自动生成 若用户自己写了 则不会自动生成

初始化和清理

构造函数

构造函数概念

构造函数是一种特殊的成员函数 名字和类的名字一样 创建类类型时由编译器自动调用 用来完成对象资源的初始化工作 在整个生命周期内只调用一次
比如下面这个Date类

class Date
{
public: 
	Date()
	{
		_year = 0;
		_month = 0;
		_day = 0;
	}
	void Print()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();//打印结果为0-0-0
	return 0;
}

Date就是成员函数就是一个构造函数 创建一个Date对象实例化时 编译器会自动调用这个构造函数对成员变量进行初始化

构造函数特征

在这里插入图片描述

1.函数名与类名相同
2. 无返回值
无返回值不是void 是不用指定函数类型
3.对象实例化时编译器自动调用对应的构造函数
4.构造函数可以重载

class Date
{
public: 
   Date()
   {
   	_year = 0;
   	_month = 0;
   	_day = 0;
   }
   Date(int year, int month, int day)
   {
   	_year = year;
   	_month = month;
   	_day = day;
   }

   void Print()
   {
   	cout << _year << '-' << _month << '-' << _day << endl;
   }

private:
   int _year;
   int _month;
   int _day;
};
int main()
{
   Date d1;//调用无参构造函数
   d1.Print();
   Date d2(2023, 10, 21);//调用有参构造函数
   d2.Print();
   return 0;
}

构造函数也支持缺省值 上面的代码可以改写成这样

class Date
{
public: 
	Date(int year = 0, int month = 0, int day = 0)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
	Date d2(2023, 10, 21);
	d2.Print();
	return 0;
}

5.如果类中用户没有定义构造函数 则编译器会自动生成一个无参的默认构造函数 一但用户定义 编译器便不在生成

//编译器自动生成构造函数
class Date
{
public: 
	void Print()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;//调用编译器生成的构造函数初始化
	d1.Print();//打印结果为随机值
	return 0;
}

初始化结果为随机值？？？ 这里的构造函数貌似没什么用
编译器自动生成构造函数的规则：
在这里插入图片描述

对内置类型(int/char/指针类型等)不做处理
对自定义类型(class/struct/union等)会自动调用默认构造函数

c++11中针对内置类型成员不初始化的缺陷 打了新补丁 即内置成员变量在类中声明可以给默认值
仅仅只是声明 并没有定义 没有开空间

class Date
{
public: 
	void Print()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}
private:
	int _year = 0;
	int _month =0;
	int _day =0;
};
int main()
{
	Date d1;//调用编译器生成的构造函数初始化
	d1.Print();//打印结果为0-0-0
	return 0;
}

6.无参构造函数和全缺省构造函数和编译器默认生成的构造函数都称为默认构造函数
默认构造函数有且只能有一个
在这里插入图片描述

错误示例 : 无参和全缺省同时出现

class Date
{
public: 
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	Date(int year = 0, int month = 0, int day = 0)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
	return 0;
}

结合构造函数的特征 ：一般情况下都需要自己写构造函数 成员时自定义类型 或者声明给了缺省值 可以考虑让编译器生成默认构造函数

析构函数

析构函数概念

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

析构函数特征

在这里插入图片描述

1、析构函数的函数名 == ~类名

class Date
{
public:
	Date()//构造函数
	{

	}
	~Date()//析构函数
	{

	}
};

2、析构函数和构造函数一样无返回值 还有一点是无参函数
3、一个类只能有一个析构函数 如果未定义 编译器会自动生成默认的析构函数
默认析构函数规则和构造函数一样
4、析构函数不能重载
结合2 3特性
5、对象生命周期结束时 c++编译器自动调用析构函数

class Date
{
public: 
	~Date()
	{
		cout << "111" << endl;
	}
private:
	int _year;
	int _month;
	int _day;

};
int main()
{
	Date d1;//会打印111 编译器自动调用析构函数
	return 0;
}

结合析构函数的特征 一般如果类中没有资源申请时 析构函数可以不写 直接使用编译器默认生成的即可；
如果有资源申请时 一定要写 否则会造成内存泄漏

拷贝赋值

拷贝构造函数

拷贝构造函数概念

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

class Date
{
public:
	Date(int year = 1, int month = 1 , int day = 1)//构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)//拷贝构造函数  d是d1的别名 ，this指向d2
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout << _year<< "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023,10,27);
	d1.Print();
	Date d2(d1);//用d1去初始化d2
	d2.Print();
	return 0;
}

拷贝构造函数特征

在这里插入图片描述

1、是构造函数的一个重载形式
拷贝构造函数名也和类名相同 参数一般和构造函数不同
2、参数只能有一个且必须是类类型对象的引用

Date(const Date& d)
{
    _year = d._year;
    _month = d._month;
    _day = d._day;
}

上面的Date类拷贝构造函数写成这样的话会引发无穷递归 聪明的编译器会直接报错

3、若未定义 则编译器会默认生成拷贝构造函数

class Date
{
public:
	Date(int year = 1, int month = 1 , int day = 1)//构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	void Print()
	{
		cout << _year<< "-" << _month << "-" << _day << endl;

	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
	Date d2(d1);//用d1去初始化d2
	d2.Print();
	return 0;
}

默认生成拷贝构造函数的规则：
在这里插入图片描述

下面举个例子

class Time
{
public:
	Time(int _hour = 1, int _minute = 1, int _second = 1)//构造函数
	{}
	Time(const Time& t)//拷贝构造函数
	{
		cout << "Time(const Time& t)" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	//内置类型
	int _year;
	int _month;
	int _day;
	//自定义类型
	Time _t;
};
int main()
{
	Date d1;
	Date d2(d1);//用d1拷贝构造d2 此处会调用Date类的拷贝构造函数
	            //但是Date的拷贝构造函数是编译器默认生成的 自定义变量_t就会去调用Time类的拷贝构造
	            //所以这里会打印 Time(const Time& t)
	return 0;
}

4、编译器自动生成的不能完成深拷贝
错误示范

class Stack
{
public:
	Stack(int capacity = 10)//构造函数
	{
		_arr = (int*)malloc(sizeof(int) * capacity);
		if (_arr == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		_size = 0;
		_capacity = capacity;
	}
	~Stack()//析构函数
	{
		free(_arr);
		_arr = nullptr;
		_size = _capacity = 0;
	}
	void Push(int x)
	{
		_arr[_size] = x;
		_size++;

	}
private:
	int* _arr;
	int _size;
	int _capacity;
};
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);

	Stack s2(s1);//
	return 0;
}

上面栈这个例子s1对象调用构造函数初始化 然后存放了2个数据1和2
s2对象使用s1的拷贝构造，Stack类中没有自己实现这个函数 所以编译器会默认生成一个拷贝构造函数 默认的拷贝构造函数是按照值拷贝的 将s1中内容原封不动拷贝到s2中 因此s2和s1指向了同一块内存空间
在这里插入图片描述
当程序退出时 s1和s2 要销毁 s2销毁时回去调用析构函数 以及释放了0x0000017f49e6d510这块空间 ，s1再销毁 也会去销毁这块空间 ，一块空间同时多次释放 会引起程序奔溃
实际的栈中 s2和s1应该是不同空间的两个对象这个代码显然是不能完成的
结合拷贝构造函数的特征 如果类中没有设计到资源申请时，拷贝构造函数写不写都可以，编译器默认生成可以完成了；如果有涉及到资源申请时 则拷贝构造函数时一定要自己实现的，否则就是浅拷贝
上面例子的拷贝构造函数的正确实现方式

Stack(const Stack& stt)//	拷贝构造函数
	{
		// 深拷贝
		_arr = (int*)malloc(sizeof(int) * stt._capacity);
		if (_arr == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memcpy(_arr, stt._arr, sizeof(int) * stt._size);
		_size = stt._size;
		_capacity = stt._capacity;
	}

赋值运算重载

运算符重载

内置类型运算符一般有算术运算符 关系运算符 比较运算符 赋值运算符等等
如何实现自定义类型的运算 比如判断两个日期是否相等
可以用一个函数进行判断 例如

bool IsSame(Date& x,Date& y)
	{
		if (x._year == y._year && x._month == y._month && x._day == y._day)
			return true;
		else
			return false;
	}

这样写最大的缺点是可读性太差 C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数
可以重定义或重载大部分 C++ 内置的运算符。这样，就能使用自定义类型的运算符

运算符重载特征

在这里插入图片描述

1、运算符重载函数格式
函数原型：返回值类型 operator操作符(参数列表)
2、重载运算符必须有一个类类型参数

bool operator==(int, int );//错误示范
bool operator==(int, Date );//正确

3、对内置类型运算符含义不能改变
4、作为类成员函数重载时 函数有一个默认的形参this
错误示范

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)//构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	bool operator==(const Date& x, const Date& y)//运算符重载函数
	{
		return x._year == d._year
			&& x._month == d._month
			&& x._day == d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(2023,10,28);
	return 0;
}

作为类成员函数时 这样的写法是错误的 因为还有一个this ==的操作数只有两个 参数有三个了 编译器会报错
正确实现运算重载函数

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

可以看成下面这种写法

bool operator==(const Date& y)
{
	return this->_year == y._year
		&& this->_month == y._month
		&& this->_day == y._day;
}

5、编译器不会默认生成 需要自己实现
运算符包含关系运算符 算数运算符 逻辑运算符 赋值运算符 等等 只有赋值运算符函数编译器才会默认生成
6、.* :: sizoef ?: . 不支持重载

赋值运算符重载

赋值元素符和其他运算符不同 他会更新变量的值
内置类型的赋值运算符一般有 = += -= /= *= …等等

赋值运算符特征

在这里插入图片描述

1、赋值运算符重载的格式

  • 参数类型 ：const 类名& 传引用可以提高传参效率
  • 返回值类型： 类名& 返回引用可以提高返回的效率 有返回值目的是为了支持连续赋值
  • 返回*this 要符合连续赋值的含义
  • 检查是否自己给自己赋值
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)//构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date& operator=(const Date& d)//赋值运算符重载函数
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(1,1,1);
	Date d2(2,2,2);
	d1 = d2;//将d2赋值给d1
	d1.Print();//打印2-2-2
	d2.Print();//打印2-2-2
}

2、赋值运算符只能重载成类的成员函数 不能重载成全局函数
错误示范

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)//构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
Date& operator=(const Date& d)//赋值运算符重载函数
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
	return *this;
}

赋值运算符如果不写 编译器会默认生成一个 我们再在类外面自己实现一个全局的 就会和默认的发生冲突 所以赋值运算符重载只能是类的成员函数
3、用户未定义 编译器默认生成一个
编译器默认生成的对内置类型完成值拷贝 对自定义类型会去调用他自己的赋值运算符重载函数

class Time
{
public:
	Time(int hour = 1,int minute = 1,int second = 1)
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}
	Time& operator=(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
		cout << "Time& operator=(const Time& t)" << endl;
		return *this;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	int _year = 1;
	int _month =1 ;
	int _day =1;
	Time _t;//自定义类型t
};
int main()
{
	Date d1;
	Date d2;
	d1 = d2;
	return 0;
}

d2赋值给d1 Date成员中内置类型会去调用默认生成的赋值运算符重载函数 自定义类型t会去调用自己的赋值运算符重载函数 所以程序会打印出Time& operator=(const Time& t)
默认生成的赋值运算符函数可以完成字节序的值拷贝 有些场景还需要自己实现的 和拷贝构造函数一样

取地址重载

取地址操作符重载

class Date
{
public:
	Date* operator&()//取地址操作符重载函数
	{
		cout << "Date* operator&()" << endl;
		return this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	cout << &d1 << endl;
	return 0;
}

上面例子会打印Date* operator&() 以及d1的地址
如果上面的取地址操作符重载函数写成这样

Date* operator&()
{
	return NULL;
}

返回的就是0地址 这样写一般也没有应用场景 取地址操作符重载一般用编译器自己默认实现的即可

const取地址操作符重载

在介绍const取地址操作符重载函数之前先介绍一下const成员函数

const成员函数

我们将用const修饰的成员函数称之为const成员函数
const修饰类的成员函数实际上是修饰该成员函数隐含的this指针，表明在该成员函数中不对类的任何成员进行修改
下面这个例子

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << "Print()" << endl;
	}
	void Print() const//const成员函数
	{
		cout << "Print() const" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023,11,02);
	d1.Print();//打印Print()

	const Date d2(2023,11,02);
	d2.Print();//打印Print() const
	
	return 0;
}

非const对象d1 会去调用非const成员函数
const对象d2调用const成员函数
改写成下面这种写法

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print() const//const成员函数
	{
		cout << "Print() const" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023,11,02);
	d1.Print();//打印Print()const

	const Date d2(2023,11,02);
	d2.Print();//打印Print() const
	
	return 0;
}

非const对象d1 和const对象d2 都会区调用const成员函数
改写下面这种写法

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << "Print()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023,11,02);
	d1.Print();//打印Print()const

	const Date d2(2023,11,02);
	d2.Print();//error
	
	return 0;
}

非const对象d1 会去调用非const成员函数
但是用const对象d2调用非const成员函数 会报错
原因是因为成员函数隐含的this指针的类型是Date* const this 而d2是const Date类型 类型不匹配
总结上面的例子
const对象只能调用const成员函数
非cosnt对象既能调用cong成员函数也可以调用非const成员函数
如果某些成员函数需要修改成员变量 那么则不能使用const修饰
能用const修饰的成员函数 一般都应该定义成cosnt
下面再来看const取地址操作符重载

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date* operator&() 
	{
		cout << "Date* operator&() " << endl;
		return this;
	}
	
	const Date* operator&() const 
	{
		cout << "const Date* operator&() const  " << endl;
		return this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	cout << &d1 << endl;//打印Date* operator&() 然后在打印d1的地址

	const Date d2;
	cout << &d2 << endl;//打印const Date* operator&() const 然后打印d2的地址
	return 0;
}

编译器会去调用和自己匹配的成员函数
一般这两个成员函数直接使用编译器默认生成的即可 不用自己实现

C++下等马
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++ 类和对象总结
01-20
话不多说，我们直接进入主题： 对象：客观世界里的一切事物都可以看作是一个对象，每一个对象应当具有属性（静态特征，比如一个班级，一个专业，一个教室）和行为（动态特征，例如：学习，开会，体育比赛等）两个要素。 对象是由一组属性和一组行为构成的。 类（class）：就是对象的类型，代表了某一批对象的共同特性和特征。类是对象的抽象，而对象是类的具体实例。 2.1 类的引入 在C语言中我们定义一个结构体是这样定义的： struct Student { int _age; char* _Gender; char* _Name; }; int main() { struct S; r
C++类和对象.ppt
11-13
C++类和对象.ppt
C++类和对象
wh22141334的博客
07-18 3858
c++中的类和对象
C++的类和对象
Cosmicsea的博客
05-21 5092
C++面向对象的三大特性：封装、继承、多态 C++认为万事万物皆可为对象，对象有其属性和行为 具有相同性质的对象，可以抽象为类 封装 类在设计时，可以把属性和行为放在不同的权限下，加以控制 public：公共权限，类内可访问、类外可访问， protected：保护权限，类内可访问、类外不可访问，儿子可以访问父亲的保护内容 private：私有权限，类内可访问、类外不可访问，儿子不可以访问父亲的私有内容 struct和class的区别在于 struct的默认权限是public cla
C++类和对象（一）
ll1175555的博客
07-13 1万+
目录面向过程和面向对象初步认识类的定义类的作用域类的实例化类的访问限定符及封装类的对象大小计算类成员函数this指针 面向过程和面向对象初步认识 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 比如一个外卖系统 面向过程：下单、接单、送餐三个过程 面向对象：客户、商家、骑手，关注的是三个类对象之间的关系 类的定义 class Name { //类体:由成员函数和成员变量组成
C++类和对象详细总结
m0_56910081的博客
04-11 1万+
类与对象概念 什么是对象 对象是一个实体，我们眼睛看到的所有实体都可以看成一个实体对象 什么是类 类是用来对实体（对象）进行描述的。（对象有什么属性，有什么功能）类是一种自定义类型 什么是方法： 方法是实现类功能的一个具体实现，该类有什么样的功能？类的所有功能都要通过调用方法来实现。 自定义类型（类的关键字：class） C中我们学过struct（结构体）自定义类型。c++为了兼容c语言，在这里我们也可以使用struct来定义类。和c不同的是，c++中的struct可以在内部放置函数，除此以
C++类和对象数组
热门推荐
夏牧子的博客
05-14 4万+
C++类和对象数组 【1】对象数组 1：对象数组的定义：类名 数组名[元素个数] Eg: student asa[10];//有10个元素的学生类对象数组 2：对象数组的访问形式：数组名[下标].成员名； Eg: asa[j].print(); 3:对象数组的初始化：对象数组的初始化通常也是由构造函数来完成的。 Eg: #include”student.h” int main {...
C++类对象进行排序
taoxing
08-29 4822
写在前面 C++类对象按照某一个属性进行排序很早以前就学习过，但是时间久了开始有点遗忘了，现在就把最常用的一共方法进行以下总结。 一. 二.
C++类和对象详解
weixin_43730061的博客
03-25 6541
类与对象上篇： 主要内容： 1.类和对象的区别。 2.类的定义。 3.类的访问限定符和封装 4.类的作用域 5.类的实例化（用类类型创建对象） 6.计算类对象的大小 7.this指针 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 1.类和对象的区别： 类是抽象的，不占用内...
C++ 类和对象基础篇
08-25
类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例（Instance），拥有类的成员变量和成员函数
C++类和对象，思维导图
04-24
C++类和对象，会跟着文章更新而更新
龙迅LT8712X TYPE-C或者DP转HDMI加VGA输出，内置MCU，只是IIS以及4K60HZ分辨率
最新发布
Ren19154948136的博客
06-06 291
LT8712X是一种高性能的Type-C/DP1.2到HDMI2.0和VGA转换器，设计用于将USB Type-C源或DP1.2源连接到HDMI2.0和VGA接收器。LT8712X集成了一个DP1.2兼容的接收器，一个HDMI2.0兼容的发射机和一个高速三角机窝视频DAC。此外，还包括两个CC控制器，用于CC通信，以实现DP Alt模式和电源传输功能，一个用于上游c型端口，另一个用于下游端口。1.62/2.7/5.4Gbps每数据通道支持SSC。没有HDCP解密1/2/4可配置数据通道。
CF Round 368 (Div. 2) C. Pythagorean Triples【数学 构造】
2301_80089588的博客
05-30 444
数学 构造
STL中stack和queue模拟实现+容器适配器
2202_75331338的博客
06-06 576
deque（双端队列）：是一种双开口的“连续”空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素，与list比较，空间利用率比较高。deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组双端队列底层是一段假象的连续的空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在看deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示；
C++相关概念和易错语法（15）（sort、vector模拟实现）
SGlow0708的博客
06-03 848
因此它的本质是vector支持一种构造，auto il = {1,2,3,4,5}将任意个数的数据（常量数组）给initializer_list，这个对象里有两个指针，分别指向开始和结束的下一个位置，它也支持迭代器，范围for。当开辟空间后，_start首位置，_finish存储位置的下一个位置，_end_of_storage都更新了，pos迭代器也要去更新，_start首位置，_finish存储位置的下一个位置，_end_of_storage开辟空间的最后一个下标下一个。其余接口都算简单，就不再介绍了。
C是结构化编程语言吗：深度剖析与多维度解读
liyrbtqe_66w的博客
06-02 379
结构化编程强调将程序划分为一系列独立的、可重用的函数或模块，每个模块都执行特定的任务。与面向对象编程范式相比，C语言更注重过程和函数的组织，而不是对象和类的概念。在编程语言的浩瀚海洋中，C语言以其独特的魅力占据着重要的地位。然而，要全面评价C语言是否属于结构化编程语言，还需要考虑其在实际应用中的表现。在这些领域中，C语言的结构化特性得到了充分的体现。通过结构化编程的方式，开发人员可以将这些功能划分为独立的模块，提高系统的稳定性和可维护性。它支持结构化编程的基本理念，具有清晰明了的语法和强大的实际应用能力。
【C++ 初阶】内联函数 inline 与 宏定义的区别！
Hou_lang_LJ的博客
05-30 926
🐧① 内联函数的概念； 🐧② 宏的优缺点；🐧③ 内联函数和宏定义的区别；
【C、C++编译工具】CLion工具介绍与安装
白舟的博客
06-03 240
最近突发奇想想学学最开始接触的语言C，之前大学的时候用的更多的工具还是VC++，工作后慢慢接触了CLion，跟pycharm其实差不多，都是集成开发环境（IDE）解释：IDE和编译器有什么区别？解释：什么是 IDE？
C++ stack类与queue类
wxk2227814847的博客
06-03 615
通过对C++标准模板库中的stack和queue的介绍与使用，我们深入了解了这两种重要的容器适配器。stack和queue在许多计算机科学领域和实际应用中都有广泛的使用场景。我们不仅学习了它们的基本操作和应用，还通过模拟实现进一步理解了其内部机制。掌握这些数据结构和容器适配器，将显著提升我们在算法设计和程序开发中的效率和能力。希望这篇博客能帮助读者更好地理解和应用stack和queue，为大家在编程道路上提供有力的支持。
c++类和对象
05-29
C++中，类是一种用户自定义的数据类型，它封装了数据和操作数据的函数。对象是类的一个实例，可以使用类中定义的函数来访问和修改对象的数据。...希望这个简单的示例可以帮助你更好地理解C++中的类和对象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

C++下等马

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值