C++之模板类_容器_迭代器_算法_GCC_make

最新推荐文章于 2024-10-05 19:39:51 发布
最新推荐文章于 2024-10-05 19:39:51 发布
阅读量852 收藏 3
点赞数 1
分类专栏： c++ 文章标签： 类模板 STL make gcc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ReyYuan/article/details/80035596
版权

站在编译器和C的角度剖析c++原理, 用代码说话

类模板基础

首先什么是模板: 模板就是把要处理的函数或类的类型参数化，表现为参数的多态性. 模板用来表现逻辑结构相同，但具体数据元素类型不同的对象的通用行为.函数模板我们在上一篇中已经说过了，所以自行回看一下. 我们这里讨论类模板：
类模板用于实现类所需数据的类型参数化.
我们先定义一个模板类:

template<typename T>
class A
{
public:
    A(int a)
    {
        this->a = a;
    }
    ~A()
    {
    }
    T getA()
    {
        return a;
    }
    void setA(T a)
    {
        this->a = a;
    }
protected:
private:
    T a;
};

这里需要强调一点的是类属参数在类中至少要出现一次. 这样的话，

void printA(A<int> *p)
 {
     cout<<"打印a："<<p->getA()<<endl;
 }
 void printA2(A<char> *p)
 {
     cout<<"打印a："<<p->getA()<<endl;
 }
 void main()
 {
     A<char> a1;
     A<int> b1(19);
     b1.setA(10);
     cout<<"打印a："<<b1.getA()<<endl;
     return 0;
 }

我们再考虑一种情况就是如果存在继承模板类的情况呢?

class C : public A<int>
{
public:
    C(int c, int a) :A<int>(a)
    {
        this->c = c;
    }
protected:
private:
    int c;
};
void printC(C *myc)
{
    cout<<myc->getA()<<endl;
}
int main()
{
    C  myc(1, 2);
    printC(&myc);
    return 0;
}

这里注意继承的时候也要public A<int>写明属性类型. 因为编译器就是根据这个类型来重新构造类的. 经过测试发现一个问题就是在继承中，如果父类没有带参的构造方法的话，在构造子类的时候是不会去父类中的.
类模板派生普通类，在定义派生类时要对基类的抽象类参数实例化. 从普通类派生模板类，意味着派生类添加了抽象类数据成员.

当类模板遇上static

template<typename T>
class A
{
public:
    static int m_a;
protected:
private:
    T a1;

};
template<typename T>
int A<T>::m_a=0;
int main()
{
    A<int> a1;
    A<int> a2;
    A<int> a3;
    A<char> b1;
    A<char> b2;
    A<char> b3;
    a1.m_a ++;
    b3.m_a = 199;
    cout<<a3.m_a<<endl;//1
    cout<<b2.m_a<<endl;//199
    return 0;
}

首先我们知道静态成员要在类外面初始化进行激活. 注意使用形式: 首先是template<typename T>也得指明，然后是涉及到类，就得跟上A<T>, 最后在写上类型或者返回值就行.
经过程序的执行，我们会发现只要是一种数据类型是共用一个静态区成员变量的，但是不同的数据类型间是独立的. 由此更能看出编译器根据类型进行重新创建类.

当模板类遇上友元函数

在模板类中能够声明各种友元关系:
1. 一个函数或函数模板可以是类或者类模板的成员
2. 一个类或类模板可以是类或类模板的友元类

template<class T>
class Complex
{
public:
    Complex(T  Real = 0,T Image=0 );
    Complex(T a);
    friend  Complex operator+(Complex &c1, Complex &c2 );//返回匿名对象
    void print();
protected:
private:
    T  Real,Image;
};
template<class T>
Complex<T>::Complex(T  Real, T Image)
{
    this->Real = Real;
    this->Image = Image;
}
template<class T>
Complex<T>::Complex(T a)
{
    this->Real = a; this->Image = 0;
}
template<class T>
void Complex<T>::print()
{
    cout<<this->Real<<" + "<<this->Image<<endl;
}
template<class T>
complex<T> operator+(Complex<T> &c1, Complex<T> &c2 )
{
    Complex<T> tmp(c1.Real+c2.Real, c1.Image + c2.Image);
    return tmp;
}

相比我们对友元类友元函数还没陌生吧，如果有些模糊了返回去看看之前的文章吧. 这里简单提一下，友元函数是在类外面定义的函数然后为了使用类中的参数所以要与类构成好朋友的关系.
当我们执行以上函数的时候:

int main0002()
{
    Complex<float> c1(1.0, 2.0);
    Complex<float> c2(3.0, 4.0);
    c1.print();
    Complex<float> c3 = c1 + c2;
    c3.print();
    return 0;
}

是会报错的：

无法解析的外部符号 "
 class Complex<float> __cdecl operator+(class Complex<float> &,class Complex<float> &)
 " (??H@YA?AV?$Complex@M@@AAV0@0@Z)，该符号在函数 _main 中被引用

出现这种错误的原因是当编译器通过类型去构建出一个新的类的时候，没法解析operator+这个符号. 所以这种情况下，我们只能将友元函数的实现放在模板类中了:

    friend Complex operator-(Complex &c1, Complex &c2 )
    {
        Complex tmp(c1.Real-c2.Real, c1.Image - c2.Image);
        return tmp;
    }

所以一般情况下都是要用到模板类的时候，都是把.h和.c存放在一起去实现的， 只是对友元函数特殊，出现错误就是编译器两次编译按照友元模板的时候出错了.

STL简介

Standard Templete Library是c++的一种标准库，是c++用template机制来表达.
STL使用泛型技术来设计完成的实例，就像MFC是用面向对象技术来设计完成的实例.
STL抽象出这些基本属性成功的将算法和这些数据结构分离，在没有效率损失的情况下，得到了极大的弹性.
那么STL的组成是什么呢?
1. 容器(container)
2. 算法(Algorithm)
3. 迭代器(Iterator)
4. 仿函数(Function Object)
5. 适配器(Adaptor)
6. 空间适配器(allocator)

容器

容器的分类:
1. 序列式容器(sequences containers)
每个元素都有固定的位置，取决于插入时间和地点，与元素值无关.
vector, deque, list
2. 关联式容器(Associated containers)
元素位置取决于特定的排序准则，和插入顺序无关
set, multiset, map, multimap

Vector

vector是一个模板类，在使用模板类的时候要指明具体的类型. 

void main01()
{
    vector<int> v1(5);  //相当于 int v1[5];
    //vector<char> v1(5);  //相当于 char v1[5];
    for (int i=0; i<5; i++)
    {
        v1[i] = i+1;//重载了[]操作符的
    }
    for (int i=0; i<5; i++)
    {
        cout<<v1[i];
    }
    return 0;
}

我们能发现vector重载了一些运算符，那么我们看看源码中的定义:

 reference       operator[](size_type n);
 const_reference operator[](size_type n) const;

这里值列举单独的一个，可自行查看.
我们来让vector作为函数参数传递:

void printfV(vector<int> &c)
{
    int size = c.size();
    for (int i=0; i<size; i++)
    {
        printf("%d ", c[i]);
    }
}
int main(void)
{
    vector<int> c2(20);
    c2 = c1;//重载了等号操作符
    printfV(v2);
    return 0;
}

这里有人会问vector相当于数组，但是在函数传递的时候不是会退化成指针吗，这样的话不是需要进行数组长度的传递吗？其实不然，因为vector是模板类，是个类，在类中已经是封装了属性方法等的. 将类直接做函数参数传递是可以的.

    vector<int>v3(20);
    v3.push_back(100);
    v3.push_back(101);
    printfV(v3);

vector会将20个单元大小全部进行初始化，当我们push_back的时候，会有18个0打出来.
到这里是基本数据类型的用法，我们传个类用用:

struct Teacher
{
    char name[10];
    int age;
};
void main()
{
    Teacher t1, t2, t3;
    t1.age = 11;
    t2.age = 22;
    t3.age = 33;
    vector<Teacher> v1(5); 
    v1[0] = t1;
    v1[1] = t2;
    v1[2] = t3;
   printf("age:%d \n", v1[0].age);
    return 0;
}

我们再来看一下传入类指针:

int main()
{
    Teacher t1, t2, t3;
    t1.age = 11;
    t2.age = 22;
    t3.age = 33;
    vector<Teacher *> v1(5);
    v1[0] = &t1;
    v1[1] = &t2;
    v1[2] = &t3;
    for (int i=0; i<v1.size(); i++)
    {
        Teacher *tmp = v1[i];
        if (tmp != NULL)
        {
            printf("age:%d", tmp->age);
        }
    }
    return 0;
}

是不是感觉很方便，什么类型都能传入，这就是用模板类实现泛型的强大之处.

Iterator

const int arraysize = 10;
int ai[arraysize] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int *begin = ai;
int *end = ai + arraysize;
for(int *pi = begin; pi != end; pi++)
{
    count << *pi << " ";
}

上面一段的代码就是利用指针来进行数组的遍历，这也就是我们引出的迭代器的本质. 但是当我们使用链表的时候存储空间并不是连续的，所以我们不能通过简单的指针的累加进行查找, 那么就会想到能不能通过一个类似于指针的类对非数组的类进行遍历呢? 我们就能以同样的方式遍历所有的数据结构(容器).
迭代器是一个”可遍历STL容器内全部或部分元素”的对象. 在迭代器中重载了一些操作符:
Operator *:
传回当前位置上的元素值, 如果该元素拥有成员, 你可以透过迭代器，直接以operator->取用
Operator++:
将迭代器前进至下一个元素. 大多数迭代器还可以使用operator--退回到前一个元素.
Operater==和Operator !=:
判断两个迭代器是否指向同一位置.
Operator=:
为迭代器的赋值(将其指元素的位置指派过去)
有了这个基础知识我们就能介绍list

List

首先我们在c语言中都接触过链表，这也就是是c++为我们封装了些方法让我们去很方便的操作链表. 因为链表不像数组一样那种连续的存储空间，所以当遍历的时候就需要我们用到迭代器.
我们先来简单的用一下list：

void main()
{
    list<int> l;
    for (int i=0; i<5; i++)
    {
        l.push_back(i+1);
    }
    cout<<l.size()<<endl;
    list<int>::iterator current = l.begin();//迭代器就相当于是个指针在不断指向

    while (current != l.end())
    {
        cout<<*current<<endl;
        current ++;
    }
    //获取链表的开头，赋值给迭代器
    current = l.begin(); //0
    current ++; //1
    current ++; //2
    current ++; //3
    l.insert(current, 100);
    printf("\n插入位置测试，请你判断是从0位置开始，还是从1位置开始\n");
    for (list<int>::iterator p = l.begin(); p!= l.end(); p++)
    {
        cout<<*p<<" ";
    }
    return 0;
}

我们能够看到容器中迭代器的使用方式，每个容器模板类中都有自己的iterator方法的. 从这里也能够看出链表就是指针. 然后l.end()是指向了链表的最后一个元素的后一位. 在list中在第三号位置插入就是在第三号前面加入.
我们用类来作为链表类型:

struct Teacher
{
    char name[64];
    int age;
};
void main()
{
    list<Teacher> l;
    Teacher t1, t2, t3;
    t1.age = 11;
    t2.age = 12;
    t3.age = 13;
    l.push_back(t1);
    l.push_back(t2);
    l.push_back(t3);
    for (list<Teacher>::iterator p = l.begin(); p!=l.end();p++)
    {
        printf("tmp:%d ", p->age);
    }
    return 0;
}

相当于是链表中的值是Teacher结构体. 然后迭代器相当于是指针，随意就相当于是指向了每个结构体的指针. 

int main()
{
    list<Teacher *> l;

    Teacher t1, t2, t3;
    t1.age = 11;
    t2.age = 12;
    t3.age = 13;
    l.push_back(&t1);
    l.push_back(&t2);
    l.push_back(&t3);
    for (list<Teacher *>::iterator p = l.begin(); p!=l.end();p++)
    {
        Teacher * tmp  = *p;
        printf("tmp:%d ", tmp->age);
    }
    return 0;
}

相当于是将Teacher结构体的指针放入到了list的值域中了. 这样的话迭代器再取地址，就相当于指向指针的指针了，也就是二级指针了.

Stack

栈是先进后出的结构. 

void printStack(stack<int> &s)
{
    //遍历栈的所有元素，必须要一个一个的弹出元素
    while(!s.empty())
    {
        //获取栈顶元素
        int tmp = s.top();
        //弹出栈元素
        s.pop();
        printf("tmp:%d ", tmp);
    }
}
void main()
{
    //定义了容器类，具体类型int
    stack<int> s;//也是模板类
    for (int i=0; i<5; i++)
    {
        s.push(i+1);
    }
    //遍历栈的所有元素，必须要一个一个的弹出元素
    while(!s.empty())
    {
        //获取栈顶元素
        int tmp = s.top();

        //弹出栈元素
        s.pop();
        printf("tmp:%d ", tmp);
    }
    printf("\n");
    printStack(s);
    return 0;
}

同样的我们用类作为类型:


struct Teacher
{
    char name[100];
    int age;
};

void main()
{
    stack<Teacher> s;
    Teacher t1, t2, t3;
    t1.age = 31;
    t2.age = 32;
    t3.age = 33;
    s.push(t1);
    s.push(t2);
    s.push(t3);
    while(!s.empty())
    {
        Teacher tmp = s.top();
        s.pop();
        printf("tmp:%d ", tmp.age);
    }
    printf("\n");
    return 0;
}

我们再使用类指针作为参数类型:

int main()
{
    stack<Teacher *> s;
    Teacher t1, t2, t3;
    t1.age = 31;
    t2.age = 32;
    t3.age = 33;
    s.push(&t1);
    s.push(&t2);
    s.push(&t3);
    while(!s.empty())
    {
        Teacher *tmp = s.top();
        s.pop();
        printf("tmp:%d ", tmp->age);
    }
    printf("\n");
    return 0;
}

在这里我们将容器用图画出来更形象的比喻一下:
这里写图片描述

大小端与内存中到底是怎么样存储数组的

在UNP那本书中碰到一个大小端的问题，这里又涉及到栈的问题，所以很想知道栈到底是怎么样分配内存地址的. 我们通常画栈都是开口朝上的，但是其实并不是的.
这里写图片描述
首先我们能够看出的是栈底是高地址. 并且数组并不是a[0]先入栈的，它的过程是当一旦写int[3]马上为其分配3个四字节的内存空间在压入栈中，但是当a[0]赋值的时候，会从数组底部开始赋值的. 所以栈中是根据数据类型整体操作的. 内部分配又是另一种方式了. 这个图在搞懂大端小端很有用.

Queue

队列顾名思义就是现进先出的数据结构. 

void main()
{
    queue<int> q;
    for (int i=0; i<5; i++)
    {
        q.push(i+1);
    }
    while (!q.empty())
    {
        //获取队列的第一个元素
        int tmp = q.front();
        printf("tmp:%d ", tmp);
        q.pop();
    }
    return 0;
}
struct Teacher
{
    char name[64];
    int age ;
};
void printQ(queue<Teacher *>  &myq)
{
    while (!myq.empty())
    {
        Teacher *tmp = myq.front();
        if (tmp != NULL)
        {
            printf("tmp:age : %d ", tmp->age);
        }
        myq.pop();
    }
}
int main()
{
    queue<Teacher *> q;
    Teacher t1, t2, t3;
    t1.age = 32;
    t2.age = 33;
    t3.age = 34;
    q.push(&t1);
    q.push(&t2);
    q.push(&t3);
    printQ(q);
    return 0;
}

与stack的思路是一样的.

Algorithm

泛型算法通则:
1. 所有算法的前两个参数都是一对iterators:[first, last)， 用来指出容器内的一个范围内的元素.
2. 每个算法的声明中，都表现出它所需要的最低层的iterator类型.
但我们在使用STL中的算法的时候需要引入#include "algorithm". 

void myPrintFunc(int &v)
{
    cout << v;
}
int mycompare(const int &a, const int &b)
{
    return a < b;
}
int main()
{
    vector<int> v(10);
    for (int i = 0; i < v.size(); i++) {
        v[i] = rand() % 10;
    }
    for (int i = 0; i < v.size(); i++) {
        printf("%d ", v[i]);
    }
    for_each(v.begin(), v.end(), myPrintFunc);
    sort(v.begin(), v.end(), mycompare);
    return 0;
}

STL对数组进行排序的时候，stl实现了排序算法，但是排序的标准可以由用户自己来定义.

GCC

gcc（GNU C Compiler）编译器的作者是Richard Stallman，也是GNU项目的奠基者,那么什么是gcc?
gcc是GNU Compiler Collection的缩写。最初是作为C语言的编译器（GNU C Compiler），现在已经支持多种语言了，如C、C++、Java、Pascal、Ada、COBOL语言等。gcc支持多种硬件平台，甚至对Don Knuth 设计的 MMIX 这类不常见的计算机都提供了完善的支持.
GCC的主要特征:
1. gcc是一个可移植的编译器，支持多种硬件平台
2. gcc不仅仅是个本地编译器，它还能跨平台交叉编译
3. gcc有多种语言前端，用于解析不同的语言。
4. gcc是按模块化设计的，可以加入新语言和新CPU架构的支持
5. gcc是自由软件
GCC的编译过程:
预处理（Pre-Processing）
编译（Compiling）
汇编（Assembling）
链接（Linking）
这里写图片描述
Gcc *.c -o 1exe (总的编译步骤)
Gcc -E 1.c -o 1.i
Gcc -S 1.i -o 1.s
Gcc -c 1.s -o 1.o
Gcc 1.o -o 1exe
动态库和静态库
1. 一个与共享库链接的可执行文件仅仅包含它用到的函数入口地址的一个表，而不是外部函数所在目标文件的整个机器码
2. 在可执行文件开始运行以前，外部函数的机器码由操作系统从磁盘上的该共享库中复制到内存中，这个过程称为动态链接（dynamic linking）
3. 共享库可以在多个程序间共享，所以动态链接使得可执行文件更小，节省了磁盘空间。操作系统采用虚拟内存机制允许物理内存中的一份共享库被要用到该库的所有进程共用，节省了内存和磁盘空间。

Make

利用 make 工具可以自动完成编译工作。这些工作包括：如果仅修改了某几个源文件，则只重新编译这几个源文件；如果某个头文件被修改了，则重新编译所有包含该头文件的源文件。利用这种自动编译可大大简化开发工作，避免不必要的重新编译。
make 工具通过一个称为 Makefile 的文件来完成并自动维护编译工作。Makefile文件描述了整个工程的编译、连接等规则。
Makefile的基本准则
TARGET … : DEPENDENCIES …
COMMAND
…
目标（TARGET）程序产生的文件，如可执行文件和目标文件；目标也可以是要执行的动作，如clean，也称为伪目标。
依赖（DEPENDENCIES）是用来产生目标的输入文件列表，一个目标通常依赖于多个文件。
命令（COMMAND）是make执行的动作（命令是shell命令或是可在shell下执行的程序）。注意：每个命令行的起始字符必须为TAB字符！
如果DEPENDENCIES中有一个或多个文件更新的话，COMMAND就要执行，这就是Makefile最核心的内容。
Make工具的最核心思想：如果DEPENDENCIES有所更新，需要重新生成TARGET；进而执行COMMAND命令

main:main.o add.o sub.o
    gcc main.o add.o sub.o -o main
main.o:main.c add.h sub.h
    gcc -c main.c -o main.o
add.o:add.c add.h
    gcc -c add.c -o add.o
sub.o:sub.c sub.h
    gcc -c sub.c -o sub.o
clean:
    rm -f main main.o add.o sub.o

也可以用通配符:

$@ 规则的目标文件名
$< 规则的第一个依赖文件名
$^ 规则的所有依赖文件列表

联系方式: reyren179@gmail.com

【STL详解】STL标准模板库入门 | STL版本 | STL六大组件 | STL优点 | 常用STL容器vector、list和map | STL算法函数 | STL使用异常原因分析与总结
dvlinker的技术专栏
10-08 1万+
本文详细介绍STL标准模板库相关的内容，包括STL版本、STL六大组件、STL优点、常用的STL容器vector、list与map、提升效率的STL算法函数的使用、STL使用异常常见原因分析与总结等，以供大家参考。
C++轮子（4） · STL算法和迭代器
chenyuping333的博客
01-18 456
STL的六大组件中最主要的是容器和算法这两个，一个泛化数据的存储，一个泛化数据的操作。前面两篇文章我们简单的介绍了STL中的容器，这篇文章将会介绍STL算法以及粘合容器和算法的迭代器。STL是基于模板实现，容器基于模板类，而算法基于模板函数。在具体介绍算法和迭代器之前，我们先简单的回顾一下模板函数的语法。
C++标准模板库（STL）和容器
weixin_30588675的博客
11-01 448
1、什么是标准模板库（STL）？ (1)C++标准模板库与C++标准库的关系 C++标准模板库其实属于C++标准库的一部分，C++标准模板库主要是定义了标准模板的定义与声明，而这些模板主要都是 类模板，我们可以调用这些模板来定义一个具体的类；与之前的自己手动创建一个函数模版或者是类模板不一样，我们使用了 STL就不用自己来创建模板了，这些模板都定义在标准模板库中，我们只需要学会怎么使用这些...
《c++ 模板容器》
suilei2002的专栏
04-22 457
1、所谓泛型编程就是独立于任何特定类型的方式编写代码，使用泛型程序时我们需要提供具体程序实例所操作的类型或值。模板是泛型的编程基础，使用模板时可以无须了解模板的定义。 2、在泛型编程中，我们所编写的类和函数能够多态的用于跨越编译时不相关的类型，一个类或者函数可以用来操作多种类型的对象 3、在C++中模板是泛型的编程基础，模板是创建类或函数的蓝图或公式
C++——模板进阶、继承
最新发布
2301_79998744的博客
10-05 1369
模板进阶、继承的讲解
模板类容器STL
weixin_44518077的博客
03-28 826
一、泛型编程 1、泛型编程：模板使得算法独立于存储的数据类型，而迭代器使算法独立于使用的容器类型！ 2、STL给每个容器类都定义了相应的迭代器类型！！（可能是指针，也可能是类对象） 》》注意链表和数组的指针更新公式是不同的！但上面经过定义各个容器的迭代器这一广义指针，使得如*和++都能适用 二、序列序列 1、vector：动态数组，随着元素的添加和删除而增大减小 2、list：双向链表 3、forward_list：单链表 4、deque：双端队列， 5、queue：该模板类是一个适配器类，让底层类（默认为
C++的标准模板库&容器
galaxyrt的博客
06-03 558
STL（Standard Template Library ,标准模板库）是一套功能强大的C++类模板，它提供了通用的类模板和模板函数，可以实现多种常用算法和数据结构，如：向量，链表，
C++容器迭代器
weixin_39861267的博客
05-08 546
迭代器的失效问题
C++ __gnu_pbds（平板电视）超详细教程（C++内置的平衡树，字典树，hash）
繁凡さん的博客
11-10 7003
__gnu_pbds自带了封装好了的平衡树、字典树、hash等强有力的数据结构，常数还比自己写的小，效率更高hhh 一、平衡树 #define PII pair<int, int> #define mp_(x, y) make_pair(x, y) tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> tr; /// rb_tree_tag 和 splay_tree_
qapplytemplate_p.rar_Linux/Unix编程_Unix_Linux_
08-11
7. **标准库和C++ STL**：C++标准库提供了各种容器（如vector、list、map）、算法和迭代器，方便高效编程。同时，STL还包含异常处理、智能指针等现代C++特性。 8. **编译与调试**：使用`gcc`或`g++`编译器进行编译...
gcc make gdb参考手册及C++ Reference
08-13
基础部分涵盖了类、对象、函数、模板等核心概念，而STL部分则讲解了容器（如vector、list、set）、迭代器、算法和内存管理等内容，对于C++开发者来说极具价值。 5. **C++_STL_Reference.pdf**: 这可能是C++ STL的另...
[C++]七 STL编程-模板、容器
qq_58806884的博客
03-22 274
STL编程-模板、容器
C++_进阶之函数模板_类模板
weixin_30895603的博客
04-15 2337
C++_进阶之函数模板_类模板 第一部分 前言 　　c++提供了函数模板(function template.)所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体制定，用一个虚拟的类型来代表。这个通用函数就成为函数模板。凡是函数体相同的函数都可以用这个模板代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现不同函...
C++标准模板库中的迭代器
Peter_Red_Boy的博客
04-25 1659
一般vector对象的操作可以使用下标来进行操作，但是最好使用迭代器进行操作， 所有的容器都可以使用迭代器进行操作，但不是所有的容器都像vector一样可以进行下标的操作！！！ 运行结果如下： 需要注意的是！！，常迭代器不能对数据进行修改 ...
C++标准容器模板库
tanker1024的专栏
02-09 2308
 C++ Standard Template LibraryThe C++ STL (Standard Template Library) is a generic collection of class templates and algorithms that allow programmers to easily implement standard data
C++模板库--容器
C_Silence_K的博客
02-07 509
标准模板库     容器：各种各样的数据结构，存储数据：数组，联邦，栈，队列，树...     迭代器：提供了一种同一的方式去遍历容器中的数据     算法：处理数据，排序，查找，遍历...容器算法迭代器关系   （1）#include &lt;iostream&gt; #include &lt;vector&gt; #include &lt;algorithm&gt; 容器：数据结构的封装，用来...
标准模板库和容器类
gjw的博客
03-14 506
标题
[杂乱笔记]C++标准模板库(STL)的几个常见容器用法（set、vector、queue、stack、map、pair、priority_queue、string）
IT博客-wusheng_z
02-24 1192
一、vector的常见用法详解 vector翻译为向量，一般叫变长数组，也就是长度根据需要而自动改变的数组。 经常用到vector的情况： ①对于只用普通数组超内存的情况，用vector就让问题解决便捷很多了。 ②对于结点数太多的图，无法运用邻接矩阵，又害怕使用指针实现邻接表的方式储存图的读者，vector就非常友好，写法非常简洁。1、vector的定义：vector<typename&g...
C++元编程——模板容器类
Dr_Jack的博客
10-27 618
元编程中有时候会需要容器已容纳暂时的数据。以下实现了一种支持插入、连接的类模板。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值