vector的介绍及使用

最新推荐文章于 2024-09-15 11:40:06 发布
最新推荐文章于 2024-09-15 11:40:06 发布
阅读量678 收藏 25
点赞数 20
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2202_75331338/article/details/139039227
版权

目录

1.1 vector的介绍

1.2 vector的使用

1.2.1 vector的定义

1.2.2vector的构造

1.2.3 vector类中的容量操作

size( ) 和 capacity( )

resize( )

max_size( )

operator[]()与at()函数

vector类中的迭代器遍历

正向遍历begin()和end()迭代器——非const

逆向遍历rbegin()和rend()迭代器——非const

逆向遍历rbegin()和rend()迭代器——const

assign()函数

push_back()函数

pop_back()函数

insert()函数

swap()函数

find()函数

1.1 vector的介绍

1.vector是表示可变大小数组的序列容器。

2.就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。

3.本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组，就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小

4.vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的

5.因此，vector占用了更多的空间，为了获得管理存储空间的能力。并以一种有效的方式动态增长

6.与其他动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好。

使用STL的三个境界：能用，明理，能扩展，那么下面学习vector，我们也是按照这个方法去学习

1.2 vector的使用

vector学习时一定要学会查看文档：vector - C++ Reference ，vector在实际中非常的重要，在实际中我们熟悉常见的接口就可以，下面列出了哪些接口需要重点掌握的

1.2.1 vector的定义

template < class T, class Alloc = allocator<T> > class vector; // generic template

vector类为类模板，所以在使用时需要带上类型表示一个具体的类，例如数据类型为int类型的vector使用时需要写为vector<int>

使用vector类需要包含头文件

#include<vector>

1.2.2vector的构造

#include <iostream>
using namespace std;
#include <vector>


int main(){
    //类模版带上类型
    //无参构造函数
    vector<int> v;
    //vector<int> v(8);//可以指定开几个空间，默认初始化为0
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    
    for (size_t i = 0; i < v.size(); i++) {
        //可以通过下表访问
        cout << v[i] << " ";
    }
    cout << endl;
}

自动分配空间

#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    //使用其他对象的迭代器区间进行构造
    vector<int> v(10, 1);
    vector<int> v1(v.begin(), v.end());
 
    for (size_t i = 0; i < v1.size(); i++)
    {
        cout << v1[i] << " ";
    }
    cout << endl;
    string s1 = "hello world";
    vector<char> v2(s1.begin(), s1.end());
    for (size_t i = 0; i < v2.size(); i++)
    {
        cout << v2[i] << " ";
    }
 
    return 0;
}
输出结果：
1 1 1 1 1 1 1 1 1 1
h e l l o   w o r l d

1.2.3 vector类中的容量操作

size( ) 和 capacity( )

int main()
{
    cout << "指定大小为10时：\n";
    vector<int> v(10, 1);
 
    cout << v.size() << endl;
    cout << v.capacity() << endl;
 
    vector<int> v1;
    v1.push_back(1);
    v1.push_back(1);
    v1.push_back(1);
    v1.push_back(1);
    cout << "插入四个数据时：\n";
    cout << v1.size() << endl;
    cout << v1.capacity() << endl;
    cout << "插入五个数据时：\n";
    v1.push_back(1);
    cout << v1.size() << endl;
    cout << v1.capacity() << endl;
 
    return 0;
}
输出结果：
指定大小为10时：
10
10
插入四个数据时：
4
4
插入五个数据时：
5
8

capacity的代码在g++ vs 和 clang下分别允许会发现，vs下capacity是按1.5倍增长，clang和g++是按2倍增长。这个问题经常会考察，不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本STL，g++是SGI版本STL

resize( )

resize在开空间的同时还会进行初始化，影响size

使用resize()函数可以改变调用对象的size和capacity大小，如果指定的大小小于size时相当于删除数据，当指定大小大于size时则作用为扩容＋初始化（对于int默认初始化为0）

int main()
{
    vector<int> v(10, 1);
 
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;
    //1 1 1 1 1 1 1 1 1 1 
 
    v.resize(20);
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;
    //1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 
    
    v.resize(5);
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;
    //1 1 1 1 1 
    
    //指定大小小于当前的size时，再指定初始化内容时不会修改原始内容
    v.resize(3, 3);
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    //1 1 1
    return 0;
}

reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。

使用reserve()函数可以更改调用对象的capacity的大小，注意，如果指定大小小于当前的capacity时，则不会做任何处理

#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    vector<int> v(10, 1);
    cout << "原始大小：\n";
    cout << v.capacity() << endl;
    cout << v.size() << endl;
 
    cout << "扩容到20：\n";
    v.reserve(20);
    cout << v.capacity() << endl;
    cout << v.size() << endl;
 
    cout << "扩容到5：\n";
    v.reserve(5);
    cout << v.capacity() << endl;
    cout << v.size() << endl;
 
    return 0;
}
输出结果：
原始大小：
10
10
扩容到20：
20
10
扩容到5：
20
10

在xcode下，是以2倍扩容

void TestVectorExpand()
{
    size_t sz;
    vector<int> v;
    sz = v.capacity();
    cout << sz << endl;
    cout << "making v grow:\n";
    for (int i = 0; i < 100; ++i)
    {
        v.push_back(i);
        if (sz != v.capacity())
        {
            sz = v.capacity();
            cout << "capacity changed: " << sz << '\n';
        }
    }
}
 
int main()
{
    TestVectorExpand();
    return 0;
}

max_size( )

使用max_size( )函数可以获取调用对象空间可以存储的数据类型的最大个数

 

void test2(){
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    
    //迭代器遍历
    //指明迭代器类型
    vector<int>::iterator it1 = v.begin();
    while (it1 != v.end()) {
        cout << *it1 <<" ";
        it1++;
    }
    cout << endl;//1 2 3 4
    
    //下标遍历
    for (size_t i = 0; i < v.size(); i++) {
        cout << v[i] << " ";
    }
    cout << endl;//1 2 3 4
    
    //范围for
    for(auto &e : v){
        cout << e <<" ";
    }
    cout << endl;//1 2 3 4
}

int main(){
    test2();
}

operator[]()与at()函数

operator[]()函数与at()函数都是下标遍历，区别是operator[]()函数越界访问时断言报错，而at()函数抛出异常

vector类中的迭代器遍历

正向遍历begin()和end()迭代器——非const
#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    vector<int> v(10, 1);
    //正向迭代器——非const
    vector<int>::iterator it = v.begin();
    while (it != v.end())
    {
        *it = 2;//可修改
        cout << *it << " ";
        it++;
    }
 
    return 0;
}
输出结果：
2 2 2 2 2 2 2 2 2 2
逆向遍历rbegin()和rend()迭代器——非const
#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    //逆向迭代器——非const
    vector<int>::reverse_iterator rit = v.rbegin();
    while (rit != v.rend())
    {
        (*rit)++;//可修改
        cout << *rit << " ";
        rit++;
    }
 
    return 0;
}
输出结果：
5 4 3 2
逆向遍历rbegin()和rend()迭代器——const
#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
 
    vector<int>::const_reverse_iterator crit = v.rbegin();
    while (crit != v.rend())
    {
        //(*crit)++;不可修改
        cout << *crit << " ";
        crit++;
    }
 
    return 0;
}
输出结果：
4 3 2 1

assign()函数

使用assign()函数可以为调用对象分配指定内容，如果调用对象中原来有内容，将会替换为指定内容，并改变size为指定内容大小

//使用一个对象的迭代器区间为调用对象分配内容
#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    //vector<int> v(5, 1);
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
 
    for (auto num : v)
    {
        cout << num << " ";
    }
    cout << endl;
 
    vector<int> v1(10, 2);
 
    //v.assign(v1.begin(), v1.end());
    v.assign(v1.begin(), v1.end());
    for (auto num : v)
    {
        cout << num << " ";
    }
    return 0;
}
输出结果：
1 2 3 4
2 2 2 2 2 2 2 2 2 2
//指定n个内容为调用对象分配
#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    //vector<int> v(5, 1);
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
 
    for (auto num : v)
    {
        cout << num << " ";
    }
    cout << endl;
 
    //vector<int> v1;
    //v1.push_back(5);
    //v1.push_back(6);
    //v1.push_back(7);
    //v1.push_back(8);
 
    //v.assign(v1.begin(), v1.end());
    v.assign(10, 5);
    for (auto num : v)
    {
        cout << num << " ";
    }
    return 0;
}
输出结果：
1 2 3 4
5 5 5 5 5 5 5 5 5 5

push_back()函数

尾插一个数据

pop_back()函数

删除最后一个数据

insert()函数

指定位置插入指定内容

使用迭代器插入数据时尽量考虑迭代器失效问题，可能指定位置是野指针

//在指定的的迭代器位置后插入内容val
#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;
    v.insert(v.begin() + 3, 5);
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    return 0;
}
输出结果：
1 2 3 4
1 2 3 5 4
 
//在指定的迭代器位置后开始插入n个val
#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;
    v.insert(v.begin() + 3, 5, 10);
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    return 0;
}
输出结果：
1 2 3 4
1 2 3 10 10 10 10 10 4
 
//在指定的迭代器位置后开始插入一个其他对象对应的迭代器区间中的内容
#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;
    vector<double> v1;
    v1.push_back(5.2);
    v1.push_back(6.3);
    v1.push_back(7.4);
    v1.push_back(8.5);
 
    //根据调用对象的类型决定强制转换的类型
    v.insert(v.begin() + 3, v1.begin(), v1.end());//将double强制转换成int类型存入int类型的vector对象
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;
    v1.insert(v1.begin() + 3, v.begin(), v.end());//将int强制转换成double类型存入double类型的vector对象
    for (size_t i = 0; i < v1.size(); i++)
    {
        cout << v1[i] << " ";
    }
 
    return 0;
}
输出结果：
1 2 3 4
1 2 3 5 6 7 8 4
5.2 6.3 7.4 1 2 3 5 6 7 8 4 8.5

使用迭代器删除数据时注意迭代器失效问题，在VS和g++下结果不同，可能指定位置导致结果未定义

//删除指定位置的一个数据
#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;//1 2 3 4
 
    vector<int>::iterator it = v.begin() + 1;
    v.erase(it);
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;//1 3 4
    //不可以再删除迭代器一开始指向的位置，存在迭代器失效问题
    //v.erase(it);
    //如果还需要删除下标为1的位置需要再将迭代器更新
    it = v.begin() + 1;
    v.erase(it);
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";//1 4
    }
 
    return 0;
}
 
//删除迭代器区间中的内容
#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;//1 2 3 4
    v.erase(v.begin() + 2, v.end());
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;//1 2
 
    return 0;
}

swap()函数

使用swap()函数可以交换调用对象和指定对象中的数据

#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    vector<int>    v1(5, 1);
 
    cout << "交换前：\n";
    cout << "v的size：" << v.size() << endl;//4
    cout << "v的capacity：" << v.capacity() << endl;//4
    for (auto num : v)
    {
        cout << num << " ";
    }
    cout << endl;//1 2 3 4
    
    cout << "v1的size：" << v1.size() << endl;//5
    cout << "v1的capacity：" << v1.capacity() << endl;//5
    for (auto num : v1)
    {
        cout << num << " ";
    }
    //1 1 1 1 1
 
    v.swap(v1);
 
    cout << "\n交换后：\n";
    cout << "v的size：" << v.size() << endl;//5
    cout << "v的capacity：" << v.capacity() << endl;
    for (auto num : v)
    {
        cout << num << " ";
    }//11111
    cout << endl;
    cout << "v1的size：" << v1.size() << endl;//4
    cout << "v1的capacity：" << v1.capacity() << endl;//4
    for (auto num : v1)
    {
        cout << num << " ";
    }//1234
    return 0;
}

find()函数

使用find()函数可以在指定迭代器区间查找指定内容

find()函数不是vector库中的函数，使用时包含头文件<algorithm>

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
 
int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
 
    vector<int>::iterator it = find(v.begin(), v.end(), 3);
    cout << *it << endl;//3
    return 0;
}

 

c无序
关注
专栏目录
标定工具介绍
WenDao_Engineer的博客
07-04 5597
在前面标定相关的系列文章文对标定的基本介绍、标定的实现过程以及标定所涉及的相关协议都进行了介绍，从今天开始我们介绍一下标定实现过程中的标定工具相关知识。
vector的使用01
m0_52024881的博客
10-07 3309
目录官方标准库查看1.vector的定义3.、元素的输入及访问运算符重载分析==运算符重载< 重载运算符 官方标准库查看 传送门 https://docs.microsoft.com/zh-cn/cpp/standard-library/cpp-standard-library-reference?view=vs-2019 1.vector的定义 vector<int> a ; //声明一个int型向量a vector<int> a(10) ; /
Vector产品手册中文版2019.pdf
07-23
Vector产品手册中文版2019.pdf CONTENT | 目录 Vector 简介 PREEvision 总线开发与测试工具 ECU测试 数据记录仪 ECU标定 测量技术工具链 AD/ADAS系统开发与验证 ECU诊断 ECU嵌入式软件 AUTOSAR解决方案 以太网解决方案
C++——vector介绍及使用详解
dream_i_success的博客
04-10 525
vector是我们C++中会经常使用的一个容器类型，可以将其理解成一个可变换大小的数组。因此，vector也是采用连续存储空间对数据进行存储，可以使用下标对其进行访问，但是与数组有区别的在于，其大小可以动态改变的。
C++入门 vector介绍及使用
fen_0108的博客
06-15 1311
vector的文档介绍vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素，也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小。为了增加存储空间，其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为。
[C++]vector的介绍及使用
qq_66767938的博客
10-19 2229
C++vector的使用
C++vector介绍及详细使用示例（源代码）
05-23
// 使用范围基于的 for 循环遍历 vector（C++11 及更高版本） std::cout 使用范围基于的 for 循环遍历 vector 的元素: "; for (int num : myVector) { std::cout ; // 输出每个元素 } std::cout ; // 换行 /...
Vector Cast使用手册
04-21
本文将详细介绍Vector Cast的使用方法，包括如何创建和执行测试用例，以及如何利用其自动生成测试用例的功能。 一、单元测试 单元测试是对软件中最小可测试单元进行检查和验证的过程。在Vector Cast中，你可以为每...
Vector Diva 使用介绍
11-08
"Vector Diva 使用介绍"这篇文章主要探讨了在汽车电子、嵌入式开发和CANoe自动化测试领域中的一个关键工具——Vector Diva。该工具主要用于软件测试，特别是与诊断相关的自动化测试。 1. Vector Diva 是什么？ ...
Vector Davinci官方帮助配置使用手册（AutoSAR）.pdf
08-19
在本手册中，会详细介绍如何使用Vector Davinci软件来配置和使用AutoSAR项目。 手册首先介绍了关于文档的基本信息，包括版本历史、如何快速找到信息、文档中所使用的约定、认证信息、保修信息、支持信息、商标信息...
VectorCAST介绍
04-22
- 自动化测试解决方案：支持代码覆盖率分析、内存使用分析、单元测试、集成测试和系统测试等。 - 支持标准：软件符合ASPICE、ISO 26262等标准，这表明了它的专业性和严格性。 - 产品特点：具备跨平台的特性，兼容...
C++中vector使用详细说明 (转)
weixin_30521161的博客
07-29 4462
转自：http://blog.chinaunix.net/uid-26000296-id-3785610.html http://www.cnblogs.com/mr-wid/archive/2013/01/22/2871105.html 一、向量的介绍 向量vector是一种对象实体, 能够容纳许多其他类型相同的元素, 因此又被称为容器。 与string相同, vector 同属于...
C++中vector使用手册
qq_38960965的博客
11-22 444
文章目录vector使用手册vector的介绍vector 的初始化vector对象的几个重要操作顺序访问vector的几种方式几种重要的算法 vector使用手册 vector的介绍 vector 是C++ STL的一个重要成员，使用它时需要包含头文-vector vector 的初始化 可以有五种方式 定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型），但没...
C++ 简析容器Vector
GuoBen_的博客
04-01 1488
向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。 一、基本概念向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能...
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 353
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1133
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
C++与QML的数据交互
qq_50679120的博客
09-11 545
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
vector工具使用介绍
09-01
Vector是一种在Android中使用的矢量图形工具。它使用SVG语法的path标签来实现矢量图形的绘制。相比于传统的栅格图像，Vector具有内存占用小、不失真等优势。在Android 5.0之后的版本中，Google推出了Vector来支持矢量图形的使用。 使用Vector的主要目的是能够方便地添加动画效果。通过使用Vector，我们可以实现各种动态的效果。比如，可以使用直线运动动画来展示对象在直线路径上的移动。这可以通过定义一个路径，并通过动画来改变对象在路径上的位置来实现。具体的实现方法包括定义路径的起点和终点，以及在动画中逐步改变对象的位置。 除了直线运动动画，还可以通过Vector实现其他各种动态效果，如旋转动画、缩放动画、透明度动画等。通过使用Vector，我们可以轻松地实现这些动画效果，并为应用程序增添更多的交互性和吸引力。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [Android动画——Vector解析](https://blog.csdn.net/hasayaqimomo/article/details/103565209)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值