vector用法pair

合集下载

vector java用法

vector java用法Vector是Java中的一个动态数组类，可以存储任意类型的对象。

Vector的大小可以根据需要自动增长或缩小。

在多线程环境中，Vector是线程安全的，可以被多个线程同时访问和修改。

本文将介绍Vector的使用方法和常见应用场景。

一、Vector的基本使用方法1. 创建Vector对象可以使用无参构造函数创建一个空的Vector对象，也可以使用带初始容量参数的构造函数创建指定大小的Vector对象。

```javaVector<String> vector1 = new Vector<>();Vector<String> vector2 = new Vector<>(10);```2. 添加元素可以使用add()方法向Vector中添加元素，也可以使用addAll()方法添加多个元素。

如果添加的元素已经存在于Vector中，则不会重复添加。

```javavector1.add('Java');vector1.add('Python');vector1.add('C++');List<String> list = new ArrayList<>();list.add('JavaScript');list.add('PHP');vector1.addAll(list);```3. 获取元素可以使用get()方法获取Vector中指定位置的元素，也可以使用elementAt()方法获取指定位置的元素。

如果指定位置不存在元素，则会抛出ArrayIndexOutOfBoundsException异常。

```javaString first = vector1.get(0);String second = vector1.elementAt(1);```4. 修改元素可以使用set()方法修改Vector中指定位置的元素。

c++map按value排序--将map的pair对保存到vector中，然后写比较仿函数。。。

c++map按value排序--将map的pair对保存到vector中，然后写⽐较仿函数。

map是⽤来存放<key, value>键值对的数据结构，可以很⽅便快速的根据key查到相应的value。

假如存储学⽣和其成绩（假定不存在重名，当然可以对重名加以区分），我们⽤map来进⾏存储就是个不错的选择。

我们这样定义，map<string, int>，其中学⽣姓名⽤string类型，作为Key；该学⽣的成绩⽤int类型，作为value。

这样⼀来，我们可以根据学⽣姓名快速的查找到他的成绩。

但是，我们除了希望能够查询某个学⽣的成绩，或许还想看看整体的情况。

我们想把所有同学和他相应的成绩都输出来，并且按照我们想要的顺序进⾏输出：⽐如按照学⽣姓名的顺序进⾏输出，或者按照学⽣成绩的⾼低进⾏输出。

换句话说，我们希望能够对map进⾏按Key 排序或按Value排序，然后按序输出其键值对的内容。

⼀、C++ STL中Map的按Key排序其实，为了实现快速查找，map内部本⾝就是按序存储的（⽐如红⿊树）。

在我们插⼊<key, value>键值对时，就会按照key的⼤⼩顺序进⾏存储。

这也是作为key的类型必须能够进⾏<运算⽐较的原因。

现在我们⽤string类型作为key，因此，我们的存储就是按学⽣姓名的字典排序储存的。

【参考代码】1. #include<map>2. #include<string>3. #include<iostream>4. using namespace std;5.6. typedef pair<string, int> PAIR;7.8. ostream& operator<<(ostream& out, const PAIR& p) {9. return out << p.first << "\t" << p.second;10. }11.12. int main() {13. map<string, int> name_score_map;14. name_score_map["LiMin"] = 90;15. name_score_map["ZiLinMi"] = 79;16. name_score_map["BoB"] = 92;17. name_score_map.insert(make_pair("Bing",99));18. name_score_map.insert(make_pair("Albert",86));19. for (map<string, int>::iterator iter = name_score_map.begin();20. iter != name_score_map.end();21. ++iter) {22. cout << *iter << endl;23. }24. return 0;25. }【运⾏结果】⼤家都知道map是stl⾥⾯的⼀个模板类，现在我们来看下map的定义：1. template < class Key, class T, class Compare = less<Key>,2. class Allocator = allocator<pair<const Key,T> > > class map;它有四个参数，其中我们⽐较熟悉的有两个: Key 和 Value。

vector在java中的用法

vector在java中的用法一、定义和初始化vector在Java中，vector是一个动态数组，可以存储任意类型的对象。

vector可以根据需要自动增长和缩小，因此非常适合存储可变数量的数据。

1. 使用无参构造函数初始化vector：Vector<Object> vector = new Vector<>();2. 使用带初始容量的构造函数初始化vector：Vector<Object> vector = new Vector<>(10);3. 使用带初始容量和增长因子的构造函数初始化vector：Vector<Object> vector = new Vector<>(10, 2);二、向vector中添加元素vector提供了多种方法用于向vector中添加元素，下面是常用的几种方法：1. 使用add()方法向vector尾部添加元素：vector.add("apple");vector.add("banana");2. 使用add(index, element)方法向指定位置插入元素：vector.add(0, "orange");三、从vector中获取元素vector提供了多种方法用于从vector中获取元素，下面是常用的几种方法：1. 使用get(index)方法获取指定位置的元素：Object element = vector.get(0);2. 使用elementAt(index)方法获取指定位置的元素：Object element = vector.elementAt(0);四、修改vector中的元素vector提供了多种方法用于修改vector中的元素，下面是常用的几种方法：1. 使用set(index, element)方法修改指定位置的元素：vector.set(0, "grape");2. 使用remove(element)方法删除指定元素：vector.remove("banana");五、遍历vector中的元素vector提供了多种方法用于遍历vector中的元素，下面是常用的几种方法：1. 使用for循环遍历vector中的元素：for (int i = 0; i < vector.size(); i++) {Object element = vector.get(i);System.out.println(element);}2. 使用foreach循环遍历vector中的元素：for (Object element : vector) {System.out.println(element);}六、其他常用方法和用法除了上述介绍的方法和用法外，vector还提供了其他常用的方法，下面是几个例子：1. 使用size()方法获取vector的大小：int size = vector.size();2. 使用isEmpty()方法判断vector是否为空：boolean isEmpty = vector.isEmpty();3. 使用contains(element)方法判断vector是否包含指定元素：boolean contains = vector.contains("apple");4. 使用indexOf(element)方法获取指定元素在vector中的位置：int index = vector.indexOf("orange");总结：本文介绍了vector在Java中的定义、初始化以及常用的方法和用法。

vector排序函数保持原顺序

vector排序函数保持原顺序当我们需要对一个vector进行排序，但又希望保持原始顺序时，可以使用一种特殊的排序方法。

通常情况下，我们会使用STL中的sort函数对vector进行排序，但这会改变vector中元素的相对位置。

为了保持原始顺序，我们可以使用一种自定义的排序方法，即创建一个新的带有原始顺序索引的pair，并使用自定义的比较函数来对pair进行排序。

首先，我们可以创建一个pair，其中pair的第一个元素是vector中的元素，第二个元素是该元素在原始vector中的索引。

然后，我们可以使用自定义的比较函数来比较pair的第一个元素，从而对pair进行排序。

在排序完成后，我们可以从排好序的pair中提取原始vector中的元素，从而得到一个保持原始顺序的排好序的vector。

下面是一个示例代码，演示了如何使用这种方法来对vector进行排序并保持原始顺序：C++。

#include <iostream>。

#include <vector>。

#include <algorithm>。

// 自定义比较函数，用于对pair进行排序。

bool customCompare(const std::pair<int, int>& a, const std::pair<int, int>& b) {。

return a.first < b.first;}。

int main() {。

std::vector<int> originalVec = {4, 2, 7, 1, 9};std::vector<std::pair<int, int>> indexedVec;// 创建带有原始顺序索引的pair.for (int i = 0; i < originalVec.size(); i++) {。

vector 数组的用法

vector 数组的用法Vector 数组是一种常用的数据结构，它允许我们在一个连续的内存块中存储多个元素。

在 C++ 中，vector 是一个动态数组，可以根据需要自动增长或缩小。

下面是一些关于vector 数组的基本用法：1. 创建 vector 数组```cpp#include <vector>std::vector<int> myVector; // 创建一个空的 int 类型的 vector 数组```2. 添加元素到 vector 数组```cppmyVector.push_back(10); // 在 vector 数组的末尾添加一个元素myVector.push_back(20); // 再添加一个元素```3. 访问 vector 数组中的元素```cppint firstElement = myVector[0]; // 访问第一个元素int lastElement = myVector.back(); // 访问最后一个元素```4. 修改 vector 数组中的元素```cppmyVector[1] = 30; // 修改第二个元素为 30```5. 删除 vector 数组中的元素```cppmyVector.pop_back(); // 删除最后一个元素```6. 使用迭代器遍历 vector 数组```cppfor (std::vector<int>::iterator it = myVector.begin(); it != myVector.end(); ++it) {std::cout << *it << std::endl; // 输出每个元素的值}```7. 使用范围 based for 循环遍历 vector 数组```cppfor (int element : myVector) {std::cout << element << std::endl; // 输出每个元素的值}```这些是 vector 数组的一些基本用法，你可以根据需要使用不同的函数和方法来操作vector 数组。

vector c用法

vector c用法Vector C是一种编程语言中常用的数据结构，用于存储和操作一系列具有相同数据类型的元素。

在本文中，我们将介绍Vector C的用法，包括创建、插入、删除、访问和遍历等操作。

一、创建Vector在使用Vector C之前，需要先声明和初始化一个Vector对象。

下面是创建和初始化Vector的基本语法：```#include <stdio.h>#include <vector.h>int main() {// 声明并初始化Vectorvector<int> vec;// 添加元素到Vectorvec.push_back(1);vec.push_back(2);vec.push_back(3);return 0;}上述代码中，我们首先包含了<stdio.h>和<vector.h>头文件，然后声明了一个名为vec的Vector对象。

接下来，使用`push_back`函数向Vector中添加元素。

二、插入元素要在Vector C中插入元素，可以使用`insert`函数。

下面是插入元素的示例代码：```#include <stdio.h>#include <vector.h>int main() {vector<int> vec;vec.push_back(1);vec.push_back(2);vec.push_back(3);// 在第二个位置插入元素vec.insert(vec.begin() + 1, 4);return 0;}上述代码中，我们使用`insert`函数在Vector的第二个位置插入了一个元素4。

注意，`insert`函数的第一个参数是插入位置的迭代器。

三、删除元素要从Vector C中删除元素，可以使用`erase`函数。

下面是删除元素的示例代码：```#include <stdio.h>#include <vector.h>int main() {vector<int> vec;vec.push_back(1);vec.push_back(2);vec.push_back(3);// 删除第一个元素vec.erase(vec.begin());return 0;}```上述代码中，我们使用`erase`函数删除了Vector的第一个元素。

vector的用法

vector的用法
Vector是一个动态数组，可以存放任意类型的数据。

vector容器支持随机访问，支持快速地在尾部添加或删除元素，但是在中间插入和删除元素会很慢。

1. 创建vector： vector<int> v; // 创建一个int类型的vector，里面没有任何元素
vector<string> v(10); // 创建一个string类型的vector，里面有10个元素 vector<int> v(10,5); // 创建一个int类型的vector，里面有10个元素，每个元素的值都是5 vector<int> v(v2); // 使用另一个同类型的vector来初始化新的vector
2. 访问vector中的元素： v[i] // 访问vector中第i个元素 v.at(i) // 访问vector中第i 个元素
3. 添加元素： v.push_back(val); // 在vector的末尾添加一个元素 v.insert(v.begin()+i, val); // 在vector的第i个位置插入一个元素
4. 删除元素： v.pop_back(); // 删除vector 的最后一个元素 v.erase(v.begin()+i); // 删除vector的第i个元素
5. 其他常用方法： v.size(); // 返回vector 中元素的个数 v.empty(); // 判断vector是否为空。

vector, 函数传递

"Vector" 是指代数中的一个概念，通常指具有大小和方向的量，例如物理学中的力、速度等。

在计算机科学中，"Vector" 也是一个常见的概念，通常表示一组具有相关性的值。

关于函数传递中的vector，我们可以有多种方式实现。

一些常用的方式如下：1. 传递vector 作为函数参数：我们可以将一个vector 作为函数的参数进行传递，例如：```cppvoid myFunction(vector<int>& myVector) {// do something with myVector}```在上述示例中，我们定义了一个名为`myFunction` 的函数，它的参数是一个`vector<int>` 类型的引用。

在函数体内，我们可以使用这个引用来读取和修改vector 的内容。

2. 从函数中返回vector：我们也可以从函数中返回一个vector，例如：```cppvector<int> myFunction() {vector<int> myVector = {1, 2, 3, 4, 5};return myVector;}```在上述示例中，我们定义了一个名为`myFunction` 的函数，它返回一个`vector<int>` 类型的对象。

在函数体内，我们创建了一个新的vector，并将其赋值给`myVector`。

然后，我们返回了这个vector。

3. 使用函数指针或函数对象：我们还可以使用函数指针或函数对象来操作vector。

例如，我们可以将一个函数对象作为参数传递给`std::for_each()`，来对vector 中的每个元素进行操作：```cppvector<int> myVector = {1, 2, 3, 4, 5};auto myFunction = [](int& n) { n *= 2; };std::for_each(myVector.begin(), myVector.end(), myFunction);```在上述示例中，我们定义了一个`vector<int>` 对象`myVector`，并创建了一个名为`myFunction` 的lambda 函数。

最全Vector用法总结

最全Vector用法总结C++内置的数组支持容器的机制，但是它不支持容器抽象的语义。

要解决此问题我们自己实现这样的类。

在标准C++中，用容器向量（vector）实现。

容器向量也是一个类模板。

标准库vector类型使用需要的头文件：#include <vector>。

vector 是一个类模板。

不是一种数据类型，vector<int>是一种数据类型。

V ector的存储空间是连续的,list不是连续存储的。

一、定义和初始化vector< typeName > v1; //默认v1为空，故下面的赋值是错误的v1[0]=5;vector<typeName>v2(v1); 或v2=v1;或vector<typeName> v2(v1.begin(), v1.end());//v2是v1的一个副本，若v1.size（）>v2.size()则赋值后v2.size()被扩充为v1.size()。

vector< typeName > v3(n,i);//v3包含n个值为i的typeName类型元素vector< typeName > v4(n); //v4含有n个值为0的元素int a[4]={0,1,2,3,3}; vector<int> v5(a,a+5);//v5的size为5，v5被初始化为a的5个值。

后一个指针要指向将被拷贝的末元素的下一位置。

vector<int> v6(v5);//v6是v5的拷贝vector< 类型> 标识符（最大容量，初始所有值）；二、值初始化1> 如果没有指定元素初始化式，标准库自行提供一个初始化值进行值初始化。

2> 如果保存的式含有构造函数的类类型的元素，标准库使用该类型的构造函数初始化。

3> 如果保存的式没有构造函数的类类型的元素，标准库产生一个带初始值的对象，使用这个对象进行值初始化。

C++（十二）—vector中pair的排序方法

C++（⼗⼆）—vector中pair的排序⽅法1、利⽤⾃定义的排序函数通过传递⼀个函数 cmp给sort函数，注意： cmp中return a<b; 决定为从⼩到⼤的排序 return a>b; 决定为从⼤到⼩的排序#include<iostream>#include<algorithm>#include<stdio.h>#include <vector>#include<string>using namespace std;bool cmp(const pair<int, char> a, const pair<int, char> b) {return a.first<b.first;//⾃定义的⽐较函数}int main(){vector<pair<int, char>> p;p.push_back(make_pair(10, 'a'));p.push_back(make_pair(9, 'c'));p.push_back(make_pair(10, 't'));p.push_back(make_pair(17, 'y'));p.push_back(make_pair(10, 'b'));sort(p.begin(), p.end(), cmp);//按照第⼀个元素排序for (auto i = 0; i<p.size(); i++)cout << p[i].first << "" << p[i].second << endl;system("pause");return0;}2、⾃定义字符串的排序函数（1）排序的⽐较⽅式，长度相同则字母排序，否则长度排序在函数中定义时不⽤将⽐较函数定义为静态成员函数。

C++之STLstd：：pair基本用法

C++之STLstd：：pair基本⽤法std::pair 是⼀个结构体模板，其可于⼀个单元内存储两个相异对象。

是 std::tuple 的拥有两个元素的特殊情况。

⼀般来说，pair 可以封装任意类型的对象，可以⽣成各种不同的 std::pair<T1, T2> 对象，可以是数组对象或者包含 std::pair<T1,T2> 的vector 容器。

pair 还可以封装两个序列容器或两个序列容器的指针。

1. 定义#include <utility>template<class T1, class T2> struct pair;模板参数 T1 和 T2 是 pair 所存储的元素的类型。

包含有两个成员变量 first 和 second，⽽且都是 public 修饰的，通过 "." 访问。

其中 first 类型为T1， second 类型为T2。

1.1 成员函数(constructor) constructs new pair (public member function)operator= assigns the contents (public member function)swap swaps the contents (public member function)1.2 ⾮成员函数make_pair creates a pair object of type, defined by the argument types (function template)operator== lexicographically compares the values in the pair (function template)operator!=operator<operator<=operator>operator>=std::swap(std::pair) specializes the std::swap algorithm (function template)std::get(std::pair) accesses an element of a pair(function template)2. 初始化初始化⼀个 pair 可以使⽤构造函数，也可以使⽤ std::make_pair。

C++pair的基本用法及sort排序总结（整理）

C++pair的基本⽤法及sort排序总结（整理）1，pair的应⽤pair是将2个数据组合成⼀组数据，当需要这样的需求时就可以使⽤pair，如stl中的map就是将key和value放在⼀起来保存。

另⼀个应⽤是，当⼀个函数需要返回2个数据的时候，可以选择pair。

pair的实现是⼀个结构体，主要的两个成员变量是first second 因为是使⽤struct不是class，所以可以直接使⽤pair的成员变量。

其标准库类型--pair类型定义在#include <utility>头⽂件中，定义如下：类模板：template<class T1,class T2> struct pair参数：T1是第⼀个值的数据类型，T2是第⼆个值的数据类型。

功能：pair将⼀对值(T1和T2)组合成⼀个值，这⼀对值可以具有不同的数据类型（T1和T2），两个值可以分别⽤pair的两个公有函数first和second访问。

定义(构造函数)：pair<T1, T2> p1;//创建⼀个空的pair对象（使⽤默认构造），它的两个元素分别是T1和T2类型，采⽤值初始化。

pair<T1, T2> p1(v1, v2);//创建⼀个pair对象，它的两个元素分别是T1和T2类型，其中first成员初始化为v1，second成员初始化为v2。

make_pair(v1, v2);// 以v1和v2的值创建⼀个新的pair对象，其元素类型分别是v1和v2的类型。

p1 < p2;// 两个pair对象间的⼩于运算，其定义遵循字典次序：// 如 p1.first < p2.first 或者 !(p2.first < p1.first) && (p1.second < p2.second) 则返回true。

p1 == p2；// 如果两个对象的first和second依次相等，则这两个对象相等；该运算使⽤元素的==操作符。

c++stl pair用法

c++stl pair用法C++ STL (Standard Template Library) 中的 pair 是一种容器类模板，用于存储两个不同类型的元素。

pair 的用法如下：1. 声明和初始化 pair 对象：```cppstd::pair<int, double> myPair; // 声明一个键类型为 int，值类型为 double 的 pair 对象std::pair<int, std::string> myPair(1, "Hello"); // 声明并初始化一个键类型为 int，值类型为 std::string 的 pair 对象std::pair<int, double> myPair = {1, 3.14}; // 使用花括号初始化一个键类型为 int，值类型为 double 的 pair 对象```2. 访问 pair 的成员:```cppstd::pair<int, double> myPair(1, 3.14);int key = myPair.first; // 访问键double value = myPair.second; // 访问值myPair.first = 2; // 修改键myPair.second = 2.71; // 修改值```3. 比较 pair 对象：```cppstd::pair<int, double> pair1(1, 3.14);std::pair<int, double> pair2(2, 2.71);bool result = (pair1 == pair2); // 比较两个 pair 对象是否相等bool result = (pair1 != pair2); // 比较两个 pair 对象是否不相等```4. 在容器中使用 pair：```cppstd::vector<std::pair<int, std::string>> myVector; // 声明一个存储键类型为 int，值类型为 std::string 的 pair 对象的 vector 容器myVector.push_back(std::make_pair(1, "Hello")); // 向容器中添加一个键为 1，值为 "Hello" 的 pair 对象myVector.emplace_back(2, "World"); // 使用 emplace_back() 函数向容器中添加一个键为 2，值为 "World" 的 pair 对象for (const auto& p : myVector) {std::cout << p.first << ": " << p.second << std::endl; // 遍历容器中的 pair 对象}```这些是 pair 类模板的一些基本用法。

pair在c++中的用法

pair在c++中的用法
在C++中，Pair是一种将两个值绑定在一起的数据结构，可以将
他们作为一个单元来处理。

Pair是std命名空间中的一个类，它有两
个成员——first和second。

使用Pair可以非常容易地组合两个数据
元素，并使用单个变量传递它们。

Pair可以用于多种情况，比如需要同时返回两个值的函数，通过Pair可以将两个值绑定在一起返回。

此外，Pair还可以用于实现排序
映射，即将键值对一一对应，这也是STL中Map容器的基本组成部分。

Pair的初始化十分简单，只需要使用大括号{}来初始化即可，大括号中的第一个元素初始化为first，第二个元素初始化为second。

下面是一个简单的Pair初始化示例：
```
pair<string, int> student ( "Tom", 90 );
```
这个实例中，我们定义了一个名为student的Pair对象，它包
含一个string类型的第一个元素和一个int类型的第二个元素。

同时，我们也将这个Pair对象的两个元素初始化为"Tom"和90.
Pair对象还可以通过继承来进行自定义。

有时我们需要绑定三个或更多个相关的元素。

在这种情况下，我们可以通过继承自std :: tuple类，并添加Pair成员来自定义一个组合数据元素。

总之，Pair是一个十分方便的数据结构，可以非常方便地将两个数据元素绑定在一起，也可以通过继承实现更复杂的组合数据元素。

对于需要同时处理多个数据元素的程序员来说，Pair是一个不可或缺
的STL工具。

迪杰斯特拉算法_优化版

迪杰斯特拉算法_优化版迪杰斯特拉优化版本：vector + 优先队列△迪杰斯特拉算法的核⼼：每次找距离s点最短的元素 + 松弛操作①要⽤优先队列取出最短距离降低时间复杂度，⽤veotor减少空间②定义⼀个pair类型，作为优先队列的元素。

typedef pair<int , int > P ，first是距离，second是边的终点③pair类型作为优先队列的元素时，默认排序是先排序first，后再排序second。

（升序）因此，距离是first，边的终点是second，不可调换#include <stdio.h>#include <queue>#include <string.h>#define MAX 100using namespace std;typedef pair<int,int> P; //first:dis[i] second:下标i,边的终点vector<P> map[MAX]; //不能先下标后权值，因为pair先排序first后排序secondint vis[MAX];int dis[MAX];priority_queue<P, vector<P>, greater<P> > q;const int INF = 0x3f3f3f3f;void Dijkstra(int s, int n){memset(dis,INF,sizeof(dis));memset(vis,0,sizeof(vis));dis[s]=0;q.push(P(0,s)); //将起始点push⼊队列while(!q.empty()){P p =q.top(); //每次取最⼩元素q.pop(); //出队int u=p.second;if(vis[u]) continue;vis[u]=1;for(int i=0;i<map[u].size();i++){ //i并不是边的终点，只是顺序存储的东西int v=map[u][i].second; //获取边的终点vint w=map[u][i].first; //获取u到v的距离if(!vis[v]){if(dis[v]>dis[u]+w){dis[v]=dis[u]+w;q.push(P(dis[v],v)); //松弛操作过的元素⼊队}}}}}int main(){int n,m,s;int u,v,w;while(scanf("%d %d %d",&n,&m,&s)!=EOF){ //顶点数n, 边数m, 起始点sfor(int i=1;i<=n;i++)map[i].clear(); //清空vector 注意 vector 不能⽤⼆维数组初始化for(int i=0;i<m;i++){scanf("%d %d %d",&u,&v,&w);map[u].push_back({w,v}); //⽆向图map[v].push_back({w,u}); //有向图只push⼀次}Dijkstra(s,n);for(int i=1;i<=n;i++)printf("%d ",dis[i]);}return0;}。

c++中pair用法

c++中pair用法摘要：一、C++中pair 的概念和定义二、C++中pair 的常用构造函数三、C++中pair 的常用成员函数四、C++中pair 在STL 中的应用正文：一、C++中pair 的概念和定义在C++中，pair 是一个非常有用的数据结构，它是一个元组，可以用来存储两个值。

pair 是C++标准库中<utility>头文件中的一个模板类，定义如下：```cpptemplate <class T1, class T2>struct pair {T1 first; // 第一个值T2 second; // 第二个值};```二、C++中pair 的常用构造函数pair 类提供了多种构造函数，以满足不同的需求。

以下是一些常用的构造函数：1.默认构造函数：```cpppair<T1, T2>() {}```2.带初始值的构造函数：```cpppair<T1, T2> (const T1& a, const T2& b) : first(a), second(b) {}```3.拷贝构造函数：```cpppair<T1, T2> (const pair<T1, T2>& p) : first(p.first),second(p.second) {}```4.带初始值列表的构造函数：```cpptemplate <class U, class V>pair<T1, T2> (const pair<U, V>& p) : first(p.first), second(p.second) {}```三、C++中pair 的常用成员函数pair 类提供了以下常用成员函数：1.访问第一个值：```cppT1 first() const;```2.访问第二个值：```cppT2 second() const;```3.修改第一个值：```cppT1& first();```4.修改第二个值：```cppT2& second();```四、C++中pair 在STL 中的应用在STL 中，pair 被广泛应用于函数参数和返回值，以及映射（map）和多重映射（multimap）等数据结构。

C++pair方法与vector方法案例详解

C++pair⽅法与vector⽅法案例详解⼀，pair⽅法类模板：template <class T1, class T2> struct pair参数：T1是第⼀个值的数据类型，T2是第⼆个值的数据类型。

功能：pair将⼀对值组合成⼀个值，这⼀对值可以具有不同的数据类型（T1和T2），两个值可以分别⽤pair的两个公有函数first和second访问。

具体⽤法：访问两个元素（通过first和second）：pair<int, double> p1; //使⽤默认构造函数p1.first = 1;p1.second = 2.5;cout << p1.first << ' ' << p1.second << endl;输出结果：1 2.5赋值operator =：1）利⽤make_pair：pair<int, double> p1;p1 = make_pair(1, 1.2);2）变量间赋值：pair<int, double> p1(1, 1.2);pair<int, double> p2 = p1;⼆，vector⽅法vector⽅向需要头函数#include<vector>向量（Vector）是⼀个封装了动态⼤⼩数组的顺序容器（Sequence Container）。

跟任意其它类型容器⼀样，它能够存放各种类型的对象。

可以简单的认为，向量是⼀个能够存放任意类型的动态数组。

1.构造函数vector():创建⼀个空vectorvector(int nSize):创建⼀个vector,元素个数为nSizevector(int nSize,const t& t):创建⼀个vector，元素个数为nSize,且值均为tvector(const vector&):复制构造函数vector(begin,end):复制[begin,end)区间内另⼀个数组的元素到vector中2.增加函数void push_back(const T& x):向量尾部增加⼀个元素Xiterator insert(iterator it,const T& x):向量中迭代器指向元素前增加⼀个元素xiterator insert(iterator it,int n,const T& x):向量中迭代器指向元素前增加n个相同的元素xiterator insert(iterator it,const_iterator first,const_iterator last):向量中迭代器指向元素前插⼊另⼀个相同类型向量的[first,last)间的数据3.删除函数iterator erase(iterator it):删除向量中迭代器指向元素iterator erase(iterator first,iterator last):删除向量中[first,last)中元素void pop_back():删除向量中最后⼀个元素void clear():清空向量中所有元素4.遍历函数reference at(int pos):返回pos位置元素的引⽤reference front():返回⾸元素的引⽤reference back():返回尾元素的引⽤iterator begin():返回向量头指针，指向第⼀个元素iterator end():返回向量尾指针，指向向量最后⼀个元素的下⼀个位置reverse_iterator rbegin():反向迭代器，指向最后⼀个元素reverse_iterator rend():反向迭代器，指向第⼀个元素之前的位置5.判断函数bool empty() const:判断向量是否为空，若为空，则向量中⽆元素6.⼤⼩函数int size() const:返回向量中元素的个数int capacity() const:返回当前向量张红所能容纳的最⼤元素值int max_size() const:返回最⼤可允许的vector元素数量值7.其他函数void swap(vector&):交换两个同类型向量的数据void assign(int n,const T& x):设置向量中第n个元素的值为xvoid assign(const_iterator first,const_iterator last):向量中[first,last)中元素设置成当前向量元素到此这篇关于C++ pair⽅法与vector⽅法案例详解的⽂章就介绍到这了,更多相关C++ pair⽅法与vector⽅法内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

c++中pair用法

c++中pair用法在C++中，std::pair是一个类模板，用于将两个不同类型的值关联在一起。

它提供了一种简单的方式来存储和访问这两个值，并且可以在不需要自定义数据结构的情况下使用。

pair类的定义位于<utility>头文件中，因此，在使用std::pair之前，需要包含此头文件。

使用std::pair非常简单，可以通过以下方式创建一个pair对象：```std::pair<int, std::string> pair1; // 创建一个整型和字符串类型的pair对象```上述语句创建了一个名为pair1的std::pair对象，其中第一个值类型为int，第二个值类型为std::string。

我们可以使用pair对象的两个成员变量first和second来访问这两个值：```pair1.first = 10; // 设置第一个值为10pair1.second = "Hello"; // 设置第二个值为"Hello"```可以使用以下方式来访问pair对象中的值：```std::cout << pair1.first << " " << pair1.second << std::endl; // 输出：10 Hello```我们也可以在创建pair对象的同时初始化它的值：```std::pair<int, std::string> pair2(20, "World");```此语句创建了一个名为pair2的std::pair对象，并将第一个值初始化为20，第二个值初始化为"World"。

除了使用成员变量来访问pair对象中的值之外，还可以使用std::get函数来获取pair对象中的值。

std::get函数接受一个std::pair对象和一个索引，返回对应索引的值，索引0表示第一个值，索引1表示第二个值。