对象的创建，初始化，销毁与拷贝

已于 2023-05-10 21:38:42 修改
阅读量255 收藏 1
点赞数 4
分类专栏： C++新时代 文章标签： c++ 算法 数据结构
于 2023-04-24 20:11:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/niepandou/article/details/130344890
版权

对象

一些小细节

在c++中，struct的功能已经进行扩展，基本和class的功能一致
唯一的区别就在于struct默认为public，class默认为private

对象的创建

默认创建

如果不需要任何附加条件，仅仅是创建一个对象的话，直接写是OK的
对象创建时，如果是带括号的无参创建，实际意义是函数声明（很奇怪，在函数内部还能声明函数）

#include <iostream>

using std::cout;
using std::endl;
using std::string;

class Computer
{
public:
	void setbrand(const string& brand)
	{
		_brand = brand;
	}
	void setprice(const int& price)
	{
		_price = price;
	}
	
private:
	string _brand;
	int _price;
};

int main()
{
	Computer p1;	
	return 0;
}

函数成员声明再定义

函数成员可以像外部函数一样声明后再在类外部进行定义
但此时会有一个缺点，我们想要通过函数成员对数据成员进行修改时，数据成员不允许访问，所以一般的，如果想要在类外部定义函数成员，就需要像namespace的引用方法一样去定义

#include <iostream>

using std::cout;
using std::endl;
using std::string;

class Computer
{
public:
	void setbrand(const string& brand);
	void setprice(const int& price);
private:
	string _brand;
	int _price;
};

//类外部定义函数成员，通过作用域来引用，此时可以访问数据成员
void Computer::setbrand(const string& brand)
{
	_brand = brand;
}
void Computer::setprice(const int& price)
{
	_price = price;
}

int main()
{
	Computer p1;
	return 0;
}

对象初始化

构造函数

构造函数就是用来初始化数据成员的
形式：没有返回值，非void，函数名与类名必须相同

默认构造函数

由系统提供的一个构造函数，因此即使对象的创建过程没有构造函数也是允许的

构造函数定义

#include <iostream>

using std::cout;
using std::endl;
using std::string;

class Computer
{
public:

	//构造函数一般写法
	Computer(const string& brand, const int& price)//建议取地址进行引用，可以节省内存占用
	{
		_brand = brand;
		_price = price;

		cout << "Have done structure!" << endl;
	}
private:
	string _brand;
	int _price;
};

void test0()
{
	Computer p1("HUAWEI", 4999);//因为有了显示构造函数，对象的创建也会发生改变
}
int main()
{
	test0();

	return 0;
}

上述方法只是一般构造函数写法，赋值并非是真正对数据成员初始化

构造函数初始化对象

对于类中数据成员的初始化，需要初始化列表进行完成
形式：在构造函数的头与构造函数的体之间，用 ’ : ’ 进行分隔

Computer(const string& brand, const int& price)
		:_brand(brand)//如果brand为字符数组，可以在函数体内部通过strcpy或者memset对brand初始化
		, _price(price)//如果数据成员有多个，为了代码规范，就另起一行并以逗号分隔
	{
		cout << "Have done structure!" << endl;
	}

初始化数据成员的顺序与初始化列表无关，如果有两个数据成员ix和iy，当已经把ix初始化了后，用ix去初始化iy，iy的值仍为随机值

对象的销毁

析构函数

用于对象的销毁，系统会默认提供
形式：同构造函数一样，没有返回值
没有参数，函数名与类名相同，但前面带个 ‘~’，且析构函数只能有一个

一般形式

#include <iostream>

using std::cout;
using std::endl;
using std::string;

class Computer
{
public:
	Computer(const string& brand, const int& price)
		:_brand(brand)
		, _price(price)
	{
		cout << "Have done structure!" << endl;
	}
	~Computer()
	{
		cout << "Have done Delete" << endl;
	}
private:
	string _brand;
	int _price;
};

void test0()
{
	Computer p1("HUAWEI", 4999);
	p1.~Computer();

}
int main()
{
	test0();

	return 0;
}

输出结果

Have done structure!
Have done Delete
Have done Delete

可以看到输出了两次销毁，因此可以断定对象的销毁一定调用了析构函数，但调用析构函数并不一定代表对象的销毁

不同类型对象销毁的次序

一般来说，对象的销毁时间与其生命周期有关
全局对象生命周期最长，在程序结束时才能销毁
静态对象在main函数结束时进行销毁
局部对象以及语句块中的变量在函数或代码块结束时进行销毁
堆对象在delete或者free时进行销毁，如果不写就会造成内存泄漏

#include <iostream>

using std::cout;
using std::endl;
using std::string;

class Computer
{
public:
	Computer(const string& brand, const int& price)
		:_brand(brand)
		, _price(price)
	{
		//cout << "Have done structure!" << endl;
	}
	~Computer()
	{
		cout<<_brand<<' '<< "Have done Delete" << endl;
	}
private:
	string _brand;
	int _price;
};

Computer p4("All", 4);

void test0()
{
	Computer p1("temp", 1);//局部变量
	static Computer p3("static", 3);
}
int main()
{
	test0();

	Computer p2("main", 2);
	Computer* p5 = new Computer("new", 5);

	delete p5;

	return 0;
}

输出结果

temp Have done Delete
new Have done Delete
main Have done Delete
static Have done Delete
All Have done Delete

析构函数的注意事项

在Computer类中, 我们用string定义了_brand数据成员
如果非要采用字符数组的形式进行定义，会出现不确定数组大小是否合适的问题
改用指针的形式，通过new或者malloc分配空间可以解决该类问题

#include <iostream>
#include <cstring>

using std::cout;
using std::endl;
using std::string;

class Computer
{
public:
	Computer(const char* brand, const int& price)
		:_brand(new char[strlen(brand)+1]())//通过new分配空间，后面加的小括号可以初始化_brand
		, _price(price)
	{
		strcpy(_brand, brand);//初始化brand
		//cout << "Have done structure!" << endl;
	}
	~Computer()
	{
		cout<<_brand<<' '<< "Have done Delete" << endl;
	}
private:
	char* _brand;
	int _price;
};

此时又会出现新的问题，我们无法确定对象在销毁时，new分配的空间是否会被delete掉，通过内存检测工具发现是没有销毁掉的，因此我们需要对析构函数进行改进,而这一情况的讲解我会放在拷贝函数之后

对象的拷贝

如果未显示定义，系统会默认提供一个拷贝函数
类中定义的固定形式

//Point类名

class Point
{
public:
	Point(const Point& p)
	: _ix(p._ix)
	,_iy(p._iy)
	{
		;
	}
private:
	int _ix;
	int _iy;
}

对象拷贝时的两种情况

#include <iostream>
#include <cstring>

using std::cout;
using std::endl;
using std::string;

class Computer
{
public:
	Computer(const char* brand, const int& price)
		:_brand(new char[strlen(brand)+1]())//通过new分配空间，后面加的小括号可以初始化_brand
		, _price(price)
	{
		strcpy(_brand, brand);//初始化brand
		//cout << "Have done structure!" << endl;
	}
	~Computer()
	{
		cout<<_brand<<' '<< "Have done Delete" << endl;
	}

	void print()
	{
		cout << _brand << ' ';
		cout << _price << endl;
	}
private:
	char* _brand;
	int _price;
};

void point(Computer p)
{
	p.print();
}

Computer retu()
{
	Computer pt("xx", 11);
	return pt;
}
void test1()
{
	Computer p1("1", 1);
	
	//对象未被创建时
	Computer p2 = p1;
	Computer p3(p1);
	//对象已被创建时
	//一般形式
	Computer p4("2", 2);
	p4 = p1;
	//实参传给形参
	point(p1);
	//返回值为对象
}
int main()
{
	test1();

	return 0;
}

通过直接赋值的方式进行拷贝是浅拷贝，可以通过对赋值运算符重构使之成为深拷贝，同时注意函数传参如果采用实参传形参而不是引用的形式，那么传参的拷贝是浅拷贝

Computer& operator = (const Computer& p)
	{
		Computer tmp("", 1);
		tmp._brand = new char[strlen(p._brand) + 1]();
		tmp._price = p._price;
		strcpy(tmp._brand, p._brand);

		cout<<tmp._brand<<' '<<"Have done copy"<<endl;

		return  tmp;
	}

构造拷贝函数时的两个注意点

1.为什么要使用&

如果不去使用&符号，函数形式会变成Computer(const Computer p)
可以发现如果这么做，参数部分就是创建对象的形式，他会像一个栈递归一样无限创建下去，直到内存爆满
又因为进行了指针访问，可以认为形参对象就在类的内部，可以访问数据成员
使用指针也可以代替&

2.为什么需要const修饰

首先需要了解左值和右值的概念
右值：没有写入内存的数据，不能进行取地址访问
左值：以及写入内存的数据，可以进行取地址访问
值得注意的是，函数如果有返回值，那么他的返回值就是临时变量，这里的临时变量就是右值，无法取地址访问
而通过const修饰，可以绑定右值

	int a1 = 1;
	int& a2 = a1;
	int& a3 = 1;
	const int& a4 = 1;

可以发现带有a3无法编译通过，去掉a3后，a1a2a4是可以编译通过的，因为1是右值，无法进行取地址访问，而通过const修饰绑定右值后就可以强行访问了
同理，函数返回值也是如此

class Computer
{
public:
	Computer(const char* brand, const int& price)
		:_brand(new char[strlen(brand)+1]())//通过new分配空间，后面加的小括号可以初始化_brand
		, _price(price)
	{
		strcpy(_brand, brand);//初始化brand
		//cout << "Have done structure!" << endl;
	}
	~Computer()
	{
		cout<<_brand<<' '<< "Have done Delete" << endl;
	}
	Computer(const Computer& p)
		:_brand(p._brand)//此时采用地址赋值的形式，会在后文解释改进方法
		,_price(p._price)
	{
		cout<<_brand<<' '<<"Have done copy"<<endl;
	}
	void print()
	{
		cout << _brand << ' ';
		cout << _price << endl;
	}
private:
	char* _brand;
	int _price;
};

Computer retu()
{
	Computer pt("xx", 11);
	return pt;
}
void test2()
{
	Computer a1("1",1);
	Computer a2 = retu();
}

如果在拷贝函数定义过程中去掉了const修饰，a2是无法通过的，通过const绑定右值后即可进行

关于拷贝函数和析构函数的创建时机

前文在析构函数中提到，如果采用字符数组的形式以new分配空间， 在对象销毁时会发生内存泄漏
此时我们选择对析构函数进行改进

	void release()
	{
		delete[] _brand;
		_brand = nullptr;//c++11中更安全的置空方法
	}
	~Computer()
	{
		release();
		cout<< "Have done Delete" << endl;
	}

此时我们可以避免内存发生泄漏
我们通过sizeof查看类的大小时往往不是我们想要的结果，比如_brand为11个字节时，再加上int时，该类的大小实际却为16，这是因为一种对齐数的存在，在64位系统下类和结构体的大小必须为8的倍数，32位系统下必须为4的倍数

在拷贝函数中我们注意到，当时我们只是采用地址直接赋值的方式对新的对象复制
往往会发生以下情况

void test3()
{
	Computer p1("HUAWEI", 4999);
	Computer p2 = p1;
	p1.~Computer();
	p2.print();
}

此时我们发现在程序运行过程中发生崩溃，这是因为字符数组我们仅仅复制了地址过去，p1在销毁后，p2中brand的地址仍是p1的brand，brand的值为NULL，进行了非法访问
改进方法，在拷贝函数中，不再是复制地址，而是另开辟一个新的空间存放brand，通过strcpy将brand复制过去

Computer(const Computer& p)
		:_brand(new char[strlen(p._brand) + 1]())
		,_price(p._price)
	{
		strcpy(_brand, p._brand);

		cout<<_brand<<' '<<"Have done copy"<<endl;
	}

全过程代码

#include <iostream>
#include <cstring>

using std::cout;
using std::endl;
using std::string;

class Computer
{
public:
	Computer(const char* brand, const int& price)
		:_brand(new char[strlen(brand)+1]())//通过new分配空间，后面加的小括号可以初始化_brand
		, _price(price)
	{
		strcpy(_brand, brand);//初始化brand
		//cout << "Have done structure!" << endl;
	}
	void release()
	{
		delete[] _brand;
		_brand = nullptr;//c++11中更安全的置空方法
	}
	~Computer()
	{
		if(_brand) release();
		cout<< "Have done Delete" << endl;
	}
	Computer(const Computer& p)
		:_brand(new char[strlen(p._brand) + 1]())
		, _price(p._price)
	{
		cout << _brand << ' ' << "Have done copy" << endl;
	}
	//对赋值运算符重构
	Computer& operator = (const Computer& p)
	{
		Computer tmp("", 1);
		tmp._brand = new char[strlen(p._brand) + 1]();
		tmp._price = p._price;
		strcpy(tmp._brand, p._brand);

		cout<<tmp._brand<<' '<<"Have done copy"<<endl;

		return  tmp;
	}
	void print()
	{
		cout << _brand << ' ';
		cout << _price << endl;
	}
private:
	char* _brand;
	int _price;
};

Computer p44("All", 4);

void test0()
{
	Computer p1("temp", 1);//局部变量
	static Computer p3("static", 3);
}

void point(Computer p)
{
	p.print();
}

Computer retu()
{
	Computer pt("xx", 11);
	return pt;
}
void test1()
{
	Computer p1("1", 1);
	
	//对象未被创建时
	Computer p2 = p1;
	Computer p3(p1);
	//对象已被创建时(注意对象已存在时直接赋值为浅拷贝)
	//一般形式
	Computer p4(p1);
	p4 = p1;
	//实参传给形参
	point(p1);
	//返回值为对象
	p4 = retu();
}

void test2()
{
	Computer a1("1",1);
	Computer a2 = retu();
}
void test3()
{
	Computer p1("HUAWEI", 4999);
	Computer p2(p1);
	p1.~Computer();
	p2.print();
}
int main()
{
	test0();

	Computer p2("main", 2);
	Computer* p5 = new Computer("new", 5);
	delete p5;

	test1();

	test2();

	test3();

	return 0;
}

对象的现代写法
深拷贝采用swap的优化方式，而浅拷贝不允许，解释：在函数实参传形参过程中，采用了浅拷贝，当前对象未被创建过，swap后临时变量地址未知，delete时会出现问题

#include <iostream>
#include <cstring>
#include <algorithm>

using std::cout;
using std::endl;
using std::string;

class Computer
{
public:
	Computer(const char* brand, const int& price)
		:_brand(new char[strlen(brand) + 1]())//通过new分配空间，后面加的小括号可以初始化_brand
		, _price(price)
	{
		strcpy(_brand, brand);//初始化brand
		cout << "Have done structure!" << endl;
	}
	void release()
	{
		//cout << &_brand << endl;
		delete[] _brand;
		_brand = nullptr;//c++11中更安全的置空方法
	}
	~Computer()
	{
		if (_brand) release();
		cout << "Have do ne Delete" << endl;
	}

	void swap(Computer& p)
	{
		std::swap(this->_brand, p._brand);
		std::swap(this->_price, p._price);
	}

	Computer(const Computer& p)
		:_brand(new char[strlen(p._brand) + 1]())
		,_price(p._price)
	{
		strcpy(_brand, p._brand);
	}
	Computer& operator = (const Computer& p)
	{
		if (this == &p) return *this;

		Computer tmp(p._brand, p._price);

		swap(tmp);

		return *this;//返回类自己
	}

	void print()
	{
		cout << _brand << ' ';
		cout << _price << endl;
	}
private:
	char* _brand;
	int _price;
};

Computer p44("All", 4);

void test0()
{
	Computer p1("temp", 1);//局部变量
	static Computer p3("static", 3);
}

void print(Computer a)
{
	a.print();
}

Computer retu()
{
	Computer pt("xx", 11);
	return pt;
}
void test1()
{
	Computer p1("1", 1);

	//对象未被创建时
	Computer p2 = p1;
	Computer p3(p1);
	//对象已被创建时(注意对象已存在时直接赋值为浅拷贝，使用重构改为深拷贝)
	//一般形式
	Computer p4(p1);
	p4 = p1;
	//实参传给形参,浅拷贝
	print(p1);
	//返回值为对象
	p4 = retu();
}

void test2()
{
	Computer a1("1", 1);
	Computer a2 = retu();
}
void test3()
{
	Computer p1("HUAWEI", 4999);
	Computer p2(p1);
	p1.~Computer();
	p2.print();
}
int main()
{
	//test0();

	Computer p2("main", 2);
	Computer* p5 = new Computer("new", 5);
	delete p5;

	test1();

	//test2();

	//test3();

	return 0;
}
涅槃豆
关注
专栏目录
JavaScript
qq_39582356的博客
08-21 157
概述 JavaScript：，属于 HTML 和 Web 的编程语言，基于对象和四件驱动的脚本语言。主要应用在客户端 特点： 交互性（信息动态交互） 安全性（不允许直接访问本地硬盘） 跨平台性（可以解释js的浏览器都可以执行） 与Java不同： JS基于对象，Java面向对象 JS只需解释即可以执行，Java需要先编译 JS弱类型，Java强类型 总结： HTML 定义网页的内容 CSS...
C++对象的创建与销毁
脱碳甲醛
02-02 1926
构造函数 构造函数能在创建对象时被调用，用于初始化成员。 构造函数的名字与类的名字相同，没有返回值（不是void，是没有） 构造函数可以重载，通过设置不同参数列表和默认值，可以用不同方式初始化。 在没有定义任何构造函数时，编译器会自动生成默认构造函数，但是一旦定义了构造函数，系统就不会再生成默认构造函数。 成员初始化列表 类中引用成员、const数据成员、类类型数据成员不能用赋值的方式初始化...
对象的创建、访问与销毁
u010473656的专栏
07-18 996
一、对象的创建 对象创建过程的流程图如下： Java对象创建的4种方式： [1] 通过 New 指令，调用 Constructor 创建； [2] 通过 Object 的 clone 方法创建； [3] 通过类的反射创建； [4] 通过序列化方式创建； 下面分别实例讲述 【1】new语句创建 ​MyObject mo = new MyObject() ;　 【2】clone方法创建...
c++对象的初始化，复制和销毁
邵光亮的博客
06-22 1161
对象的初始化： 对象在创建时获得了一个特定的值，我们说这个对象被初始化。初始化不是赋值，初始化的含义是创建变量赋 予其一个初始值，而赋值的含义是把当前值擦除，而以一个新值来替代。 默认初始化： 如果定义变量时没有指定初值，则变量被默认初始化，此时变量被赋予了“默认值” 1、如果是内置类型的变量且未被显示初始化，它的值由位置决定。定义在任何函数体之外的变量被...
C++类和对象：对象的初始化和清理
weixin_44751255的博客
10-06 883
本文是笔者在C++学习过程中，对类和对象的总结记录，如有不对以及不足的地方，欢迎大家指正！
C++：类和对象：对象的初始化和清理
C++ JAVA的专栏
12-16 1232
C++：类和对象：对象的初始化和清理
C++类和对象拷贝、初始化、构造析构顺序和静态成员总结
weixin_73497355的博客
06-05 792
对深拷贝、浅拷贝以及初始化列表构造和析构顺序、静态成员的总结
类对象的创建和销毁
qq_40250321的博客
11-03 1256
析构函数 1. 特征 ① 函数名 = ~ + 类名；② 无参，无返回类型，故不可重载，函数唯一。 2. 被调用时机 无论何时一个对象被销毁，就会自动调用其析构函数。 变量在离开其作用域时被销毁。 当一个对象被销毁时，其成员被销毁。 容器（无论是标准库容器还是数组）被销毁时，其元素被销毁。 对于动态分配的对象，当对指向他的指针应用delete时被销毁。 对于临时对象，当创建它的完整表达式结束时被销毁。 3. 注意 由于析构函数自动运行，程序可以按需分配资源而无需担心何时释...
对象初始化与清除
愿戎马一生，归来仍少年
03-26 1137
C++继承自C，并在易用性和安全性上不断扩展。C中将内置数据类型组合成struct结构体来扩展数据类型，而C++中，struct扩展成类的概念，类是由类设计者定制的抽象数据类型。它将C语言库中分散的构件（包括内置数据类型和函数），全都封装进类这个结构中，并对各个构件设置访问控制的分界。封装和访问控制在提高数据的安全性和库的易用性方面取得重大进展。 C struct与C++ class比较 在s
C++中对象的含义，以及对象的创建与销毁，对象的引用与拷贝，对象的指针，this指针
人工智蟑的博客
12-06 869
介绍了对象的含义，构造函数，拷贝构造函数，析构函数的使用，引用，拷贝，指针，this指针
C++ 中类的拷贝、赋值、销毁的实例详解
08-29
合成拷贝构造函数的操作是将其参数的各个成员拷贝到正在创建的对象中去，每个成员的类型决定了它是如何被拷贝的，对于类类型的成员，会使用其拷贝构造函数，内置类型的成员则是直接拷贝。 例如，我们定义了一个类 `...
类和对象（构造函数，初始化表达式，对象的销毁，拷贝构造函数，this指针，特殊成员的初始化）
yanglw98的博客
06-06 907
类的定义 类的定义分为两个部分：数据（相当于属性）和对数据的操作（相当于行为）。 类的形式 class 类名 { public: //公有数据成员和成员函数 protected: //保护数据成员和成员函数 private: //私有数据成员和成员函数 }; // 千万不要忘了这个分号 class内部可以拥有的是数据成员(属性)和成员函数(行为)，他们可以分别用三个不同的关键字进行修饰，public、protected、private. 其中public进行修饰的成员表示的是该类可以
C++对象的构造和析构函数（初始化、清理、深浅拷贝、初始化列表）
u014583317的博客
09-21 703
1.构造函数 为什么需要构造函数？  注意：类的数据成员是不能在声明类时初始化的。  而创建一个对象时，常常需要作某些初始化的工作，例如对数据成员赋初值。  为了解决这个问题，C++编译器提供了构造函数(constructor)来处理对象的初始化。构造函数是一种特殊的成员函数，与其他成员函数不同，不需要用户来调用它，而是在建立对象时自动执行。 1.构造函数定义  1）C++中的类可以定义与类名相同的特殊成员函数，这种与类名相同的成员函数叫做构造函数；  2）构造函数在定义时可以有参数；  3）没有任何返回类
C++ STL中sort函数
weixin_43349440的博客
09-15 269
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1108
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
C++与QML的数据交互
qq_50679120的博客
09-11 527
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
CF C. Nikita and LCM
qq_74190237的博客
09-13 272
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++_map_set详解
最新发布
2302_77644537的博客
09-16 646
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 563
继续学习头文件的数学函数。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

涅槃豆

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

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

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

打赏作者

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

抵扣说明：

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

余额充值