C++语法知识点合集：8.vector

于 2024-09-04 17:01:24 发布
阅读量433 收藏 15
点赞数 8
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79453595/article/details/141875048
版权

文章目录

一、 vector的使用

1.vector的建造

创建 std::vector 的不同方式

// constructing vectors
#include <iostream>
#include <vector>

int main()
{
    // constructors used in the same order as described above:
    // 空的 int 类型向量
    std::vector<int> first;
    // 创建了一个名为 second 的向量，包含4个元素，每个元素的值都是100。
    std::vector<int> second(4, 100);
    // 迭代器范围构造函数
    // 创建了一个名为 third 的向量，它通过遍历 second 的元素构造而成，因此 third 的内容与 second 相同。
    std::vector<int> third(second.begin(), second.end());
    // 拷贝构造函数
    // 创建了一个名为 fourth 的向量，它是 third 向量的副本，因此 fourth 的内容与 third 相同。
    std::vector<int> fourth(third);

    // 通过数组的首地址 myints 和末地址 myints + sizeof(myints) / sizeof(int) 构造了一个名为 fifth 的向量。
    int myints[] = {16, 2, 77, 29};
    std::vector<int> fifth(myints, myints + sizeof(myints) / sizeof(int));

    std::cout << "The contents of fifth are:";
    for (std::vector<int>::iterator it = fifth.begin(); it != fifth.end(); ++it)
        std::cout << ' ' << *it; //*it 解引用迭代器，获取当前元素的值
    // endl 是一个操纵符，它的作用是向输出流插入一个换行符，并刷新缓冲区。
    std::cout << '\n';

    return 0;
}

2.vector iterator 的使用

在这里插入图片描述

// vector::begin/end
#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> myvector;
  for (int i=1; i<=5; i++) myvector.push_back(i);

  std::cout << "myvector contains:";
  for (std::vector<int>::iterator it = myvector.begin() ; it != myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector(5); // 创建一个包含5个默认值的int类型向量，每个元素初始值为0

    int i = 0; // 定义并初始化一个整型变量i为0

    std::vector<int>::reverse_iterator rit = myvector.rbegin();
    // 定义一个反向迭代器rit，初始化为指向myvector的反向起始位置（即最后一个元素）

    for (; rit != myvector.rend(); ++rit) // 使用反向迭代器遍历myvector，从最后一个元素到第一个元素
        *rit = ++i;                       // 将当前迭代器指向的元素赋值为i递增后的值（即1到5）

    std::cout << "myvector contains:";

    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        // 使用正向迭代器遍历myvector，从第一个元素到最后一个元素
        std::cout << ' ' << *it; // 输出当前元素的值，前面加一个空格

    std::cout << '\n';

    return 0;
}

3.vector 空间增长问题

  1. size 获取数据个数
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myints; // 创建一个空的int类型向量

    std::cout << "0. size: " << myints.size() << '\n';
    // 输出当前向量的大小，应该是0，因为向量刚刚创建，还没有添加任何元素

    for (int i = 0; i < 10; i++)
        myints.push_back(i);
    // 使用for循环向向量中添加10个元素，这些元素的值分别为0到9

    std::cout << "1. size: " << myints.size() << '\n';
    myints.insert(myints.end(), 10, 100);
    // 在向量的末尾插入10个值为100的元素

    std::cout << "2. size: " << myints.size() << '\n';
    // 输出当前向量的大小，应该是20，因为刚刚插入了10个新元素

    myints.pop_back();
    // 删除向量的最后一个元素

    std::cout << "3. size: " << myints.size() << '\n';
    // 输出当前向量的大小，应该是19，因为刚刚删除了1个元素

    return 0; // 返回0，表示程序成功结束
}
  1. capacity
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector; // 创建一个空的int类型向量

    // 在向量中设置一些内容：
    for (int i = 0; i < 100; i++)
        myvector.push_back(i);
    // 使用for循环向向量中添加100个元素，这些元素的值为0到99

    std::cout << "size: " << (int)myvector.size() << '\n';
    // 输出当前向量的大小，表示向量中元素的个数，应该是100

    std::cout << "capacity: " << (int)myvector.capacity() << '\n';
    // 输出当前向量的容量，表示向量在不重新分配内存的情况下可以容纳的元素数量

    std::cout << "max_size: " << (int)myvector.max_size() << '\n';
    // 输出当前向量的最大可能大小，表示向量在理论上能够容纳的最大元素数量

    return 0; // 返回0，表示程序成功结束
}

capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。

  1. empty
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> myvector;

    int sum(0);
    for (int i = 1; i <= 10; i++)
        myvector.push_back(i);
    while (!myvector.empty())
    // 使用while循环，持续执行直到向量为空
    {
        sum += myvector.back();
        // 将向量末尾的元素值加到sum中

        myvector.pop_back();
        // 删除向量末尾的元素
    }

    std::cout << "total: " << sum << '\n';
    return 0;
}
  1. resize
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector;
    for (int i = 1; i < 10; i++)
        myvector.push_back(i);
    // 使用for循环向向量中添加1到9的整数，这些元素依次添加到向量的末尾

    myvector.resize(5);
    // 将向量的大小调整为5，超过5的元素将被删除。保留前5个元素：1, 2, 3, 4, 5

    myvector.resize(8, 100);
    // 将向量的大小调整为8，新增加的元素初始化为100。因此，向量现在包含：1, 2, 3, 4, 5, 100, 100, 100

    myvector.resize(12);
    // 将向量的大小调整为12，新增的元素用默认值0进行填充。向量现在包含：1, 2, 3, 4, 5, 100, 100, 100, 0, 0, 0, 0

    std::cout << "myvector contains:";

    for (int i = 0; i < myvector.size(); i++)
        // 使用for循环遍历向量的所有元素
        std::cout << ' ' << myvector[i];
    std::cout << '\n';
    return 0;
}

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

  1. reserve

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

#include <iostream>
#include <vector>

int main()
{
    std::vector<int>::size_type sz; // 定义一个变量sz，用于存储向量的容量大小
    std::vector<int> foo;           // 创建一个空的int类型向量foo
    sz = foo.capacity();            // 获取foo当前的容量并存储到sz中
    std::cout << "making foo grow:\n";

    for (int i = 0; i < 100; ++i)
    {
        foo.push_back(i); // 将整数i依次添加到foo中
        if (sz != foo.capacity())
        {
            sz = foo.capacity(); // 如果foo的容量发生变化，则更新sz
            std::cout << "capacity changed: " << sz << '\n';
        }
    }

    std::vector<int> bar; // 创建一个空的int类型向量bar
    sz = bar.capacity();
    bar.reserve(100); // 预先将bar的容量设置为100
    std::cout << "making bar grow:\n";

    for (int i = 0; i < 100; ++i)
    {
        bar.push_back(i); // 将整数i依次添加到bar中
        if (sz != bar.capacity())
        {
            sz = bar.capacity(); // 如果bar的容量发生变化，则更新sz
            std::cout << "capacity changed: " << sz << '\n';
        }
    }
    return 0;
}

output:

making foo grow:
capacity changed: 1
capacity changed: 2
capacity changed: 4
capacity changed: 8
capacity changed: 16
capacity changed: 32
capacity changed: 64
capacity changed: 128
making bar grow:
capacity changed: 100
原因：
在这里插入图片描述
在这里插入图片描述

4.vector 增删查改

  1. push_back
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector; // 定义一个整数类型的 vector 容器 myvector，用于存储整数
    int myint;

    std::cout << "Please enter some integers (enter 0 to end):\n";
    do
    {
        std::cin >> myint;         // 从标准输入读取一个整数并存储在 myint 中
        myvector.push_back(myint); // 将读取的整数添加到 myvector 容器的末尾
    } while (myint);
    // 循环直到用户输入 0，0 作为结束标志，不再添加到 myvector 中

    std::cout << "myvector stores " << int(myvector.size()) << " numbers.\n";

    return 0;
}
  1. pop_back
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector; // 定义一个存储整数的vector对象myvector
    int sum(0);

    myvector.push_back(100); // 向myvector的末尾添加整数100
    myvector.push_back(200);
    myvector.push_back(300);

    while (!myvector.empty()) // 当myvector不为空时，进入循环
    {
        sum += myvector.back(); // 取出myvector末尾的元素并加到sum中
        myvector.pop_back();    // 删除myvector末尾的元素
    }

    std::cout << "The elements of myvector add up to " << sum << '\n'; // 输出myvector中所有元素的和

    return 0;
}
  1. find

查找。（注意这个是算法模块实现，不是vector的成员接口）
返回值指向范围中比较等于 val 的第一个元素的迭代器。如果没有元素匹配，函数返回最后一个

#include <iostream>
#include <algorithm> // std::find
#include <vector>

int main()
{
    int myints[] = {10, 20, 30, 40}; // 定义一个整数数组 myints，包含 4 个元素
    int *p;                          // 定义一个指针 p，用于存储找到的元素的地址
    // 在数组 myints 中查找值为 30 的元素，返回指向该元素的指针
    p = std::find(myints, myints + 4, 30);
    // 如果找到的指针 p 不是数组末尾的地址，则说明找到了元素
    if (p != myints + 4)
        std::cout << "Element found in myints: " << *p << '\n'; // 输出找到的元素值
    else
        std::cout << "Element not found in myints\n";
    // 用 myints 数组的元素初始化一个 vector 对象 myvector
    std::vector<int> myvector(myints, myints + 4);
    std::vector<int>::iterator it;

    it = find(myvector.begin(), myvector.end(), 30);
    // 如果找到的迭代器 it 不是 vector 的末尾，则说明找到了元素
    if (it != myvector.end())
        std::cout << "Element found in myvector: " << *it << '\n';
    else
        std::cout << "Element not found in myvector\n";

    return 0;
}
  1. insert 在position之前插入val
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector(3, 100); // 定义一个包含3个元素的vector对象myvector，每个元素值为100
    std::vector<int>::iterator it;
    it = myvector.begin();
    it = myvector.insert(it, 200); // 在myvector的第一个位置插入值为200的元素，it更新为指向新插入的元素

    myvector.insert(it, 2, 300); // 在it位置之前插入两个值为300的元素

    // "it"指向的元素位置已经无效，重新获取一个指向vector开头的迭代器
    it = myvector.begin();
    // 定义一个包含2个元素的vector对象anothervector，每个元素值为400
    std::vector<int> anothervector(2, 400);
    myvector.insert(it + 2, anothervector.begin(), anothervector.end()); // 在myvector中第3个位置插入anothervector的所有元素

    int myarray[] = {501, 502, 503};                         // 定义一个包含3个元素的数组myarray
    myvector.insert(myvector.begin(), myarray, myarray + 3); // 将myarray的所有元素插入到myvector的开头

    std::cout << "myvector contains:";
    for (it = myvector.begin(); it < myvector.end(); it++)
        std::cout << ' ' << *it;
    std::cout << '\n';

    return 0;
}
  1. erase 删除position位置的数据

指向函数调用删除的最后一个元素之后的元素的新位置的迭代器。如果操作删除了序列中的最后一个元素，则指向容器末端

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector; // 定义一个空的整数vector对象myvector

    // 设置一些值（从1到10）
    for (int i = 1; i <= 10; i++)
        myvector.push_back(i);

    // 删除第6个元素
    myvector.erase(myvector.begin() + 5); // 删除myvector中的第6个元素（索引为5）

    // 删除前3个元素
    myvector.erase(myvector.begin(), myvector.begin() + 3); // 删除myvector中的前3个元素

    std::cout << "myvector contains:";
    for (unsigned i = 0; i < myvector.size(); ++i)
        std::cout << ' ' << myvector[i];
    std::cout << '\n';

    return 0;
}
  1. swap
// swap vectors
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> foo(3, 100); // three ints with a value of 100
    std::vector<int> bar(5, 200); // five ints with a value of 200

    foo.swap(bar);

    std::cout << "foo contains:";
    for (unsigned i = 0; i < foo.size(); i++)
        std::cout << ' ' << foo[i];
    std::cout << '\n';

    std::cout << "bar contains:";
    for (unsigned i = 0; i < bar.size(); i++)
        std::cout << ' ' << bar[i];
    std::cout << '\n';

    return 0;
}
  1. operator[]
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector(10); // 定义一个包含10个元素的vector对象myvector，所有元素都初始化为0

    std::vector<int>::size_type sz = myvector.size();

    // 赋值一些数值：
    for (unsigned i = 0; i < sz; i++)
        myvector[i] = i; // 使用下标运算符[]给myvector中的每个元素赋值，使其值等于其索引

    // 使用下标运算符[]反转vector：
    for (unsigned i = 0; i < sz / 2; i++) // 只需遍历前一半元素
    {
        int temp;                           // 定义一个临时变量temp
        temp = myvector[sz - 1 - i];        // 将myvector末尾的元素赋值给temp
        myvector[sz - 1 - i] = myvector[i]; // 将myvector前半部分的元素值赋给对应的末尾位置
        myvector[i] = temp;                 // 将temp中的值（原末尾元素）赋给myvector的前半部分
    }

    std::cout << "myvector contains:";
    for (unsigned i = 0; i < sz; i++)
        std::cout << ' ' << myvector[i];
    std::cout << '\n';

    return 0;
}

5.vector 迭代器失效问题*

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对
指针进行了封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效，实际就是迭代器
底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即
如果继续使用已经失效的迭代器，程序可能会崩溃)。

  1. 插入元素导致迭代器失效:
    当向 vector 中插入元素时，特别是当插入的位置不是 vector 的末尾时，vector 可能需要重新分配内存。这是因为 vector 是基于数组实现的，如果插入操作导致 vector 的容量不足，vector 会分配一块新的更大的内存区域，并将现有元素复制到新的位置。

迭代器失效的原因：

  • 如果 vector 重新分配了内存，那么所有指向旧内存的迭代器都会失效。
  • 如果在中间插入元素，插入位置后的所有迭代器都会失效，因为这些元素的位置可能会发生改变。

避免方法：

  • 插入元素后重新获取迭代器。
  • 避免在遍历 vector 时进行插入操作。
  1. 删除元素导致迭代器失效
    当从 vector 中删除元素时，vector 中后续的元素会向前移动以填补被删除元素留下的空位。这会导致某些迭代器失效。

迭代器失效的原因：

  • 如果删除的元素不是最后一个元素，则删除位置之后的所有迭代器都会失效，因为这些元素的位置改变了。

避免方法：

  • 在删除操作后重新获取迭代器。
  • 使用返回的有效迭代器（erase 操作返回的是指向被删除元素的下一个元素的迭代器）。
  1. 容量变化导致的迭代器失效
    vector 的容量是动态增长的，每次插入新元素时，如果当前容量不足以容纳新的元素，vector 会重新分配一块更大的内存并复制现有元素。

迭代器失效的原因：

  • 每次重新分配内存后，所有迭代器都会失效，因为它们仍指向旧的内存位置。
    避免方法：
  • 可以通过调用 reserve() 方法提前分配足够的空间，以避免不必要的内存重新分配。
  1. 举例
#include <iostream>
using namespace std;
#include <vector>
int main()
{
    vector<int> v{1, 2, 3, 4, 5, 6};
    auto it = v.begin();
    v.assign(100, 8);
    while (it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
    return 0;
}

在执行 v.assign(100, 8); 之后，v 中的元素全部变为100个值为8的元素，并且这些元素会被存储在一个新的内存区域。因此，原来的迭代器 it 不再指向有效的内存位置。接下来在 while 循环中使用这个失效的迭代器会导致未定义行为。

修改代码

#include <iostream>
using namespace std;
#include <vector>
int main()
{
    vector<int> v{1, 2, 3, 4, 5, 6};

    v.assign(100, 8);
    auto it = v.begin();
    while (it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
    return 0;
}
  1. 举例2
#include <iostream>
using namespace std;
#include <vector>
int main()
{
    int a[] = {1, 2, 3, 4};
    vector<int> v(a, a + sizeof(a) / sizeof(int));
    // 使用find查找3所在位置的iterator
    vector<int>::iterator pos = find(v.begin(), v.end(), 3);
    // 删除pos位置的数据，导致pos迭代器失效。
    v.erase(pos);
    cout << *pos << endl; // 此处会导致非法访问
    return 0;
}

在 C++ 中，erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理
论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。

修改：

#include <iostream>
using namespace std;
#include <vector>
int main()
{
    int a[] = {1, 2, 3, 4};
    vector<int> v(a, a + sizeof(a) / sizeof(int));
    // 使用find查找3所在位置的iterator
    vector<int>::iterator pos = find(v.begin(), v.end(), 3);
    // 删除pos位置的数据，并返回指向下一个有效元素的迭代器
    if (pos != v.end())
    {
        pos = v.erase(pos);
    }
    // 在检查pos是否为有效的结束位置后访问元素
    if (pos != v.end())
    {
        cout << *pos << endl; // 输出删除后的位置的新元素
    }
    else
    {
        cout << "No more elements in the vector." << endl; // 如果已到达end，则提示
    }
    cout << *pos << endl; // 此处会导致非法访问
    return 0;
}
  1. 举例3
#include <iostream>
using namespace std;
#include <vector>
int main()
{
    vector<int> v{1, 2, 3, 4};
    auto it = v.begin();
    while (it != v.end())
    {
        if (*it % 2 == 0)
            v.erase(it);
        ++it;
    }
    return 0;
}

迭代器失效：在 std::vector 中，当你调用 erase 删除元素时，所有指向被删除元素以及其后元素的迭代器都会失效。换句话说，删除操作会导致当前迭代器 it 失效。失效的迭代器如果继续使用，可能会导致未定义行为，程序可能崩溃或输出错误的结果。

修改：

#include <iostream>
using namespace std;
#include <vector>
int main()
{
    vector<int> v{1, 2, 3, 4};
    auto it = v.begin();
    while (it != v.end())
    {
        if (*it % 2 == 0)
            it = v.erase(it);
        else
            ++it;
    }
    return 0;
}

在 erase 操作之后，erase 方法返回一个新的有效迭代器，该迭代器指向被删除元素之后的元素。通过将 it 赋值为这个新迭代器，可以确保后续的操作是基于有效的迭代器进行的。

二、vector深度剖析及模拟实现

1.使用memcpy拷贝问题

如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为
memcpy是浅拷贝，否则可能会引起内存泄漏甚至程序崩溃。

2.二维动态数组理解

在这里插入图片描述

vector 是动态数组
而 vector<vector< int > > 就是一个存储 vector< int > 的 vector，也就是说它是一个二维的动态数组结构

#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
class Solution
{
public:
    vector<vector<int>> generate(int numRows) // 定义一个成员函数 generate，返回值类型是二维整数向量，参数是整数 numRows
    {
        vector<vector<int>> vv(numRows);  // 声明一个二维向量 vv，大小为 numRows，用于存储帕斯卡三角形的行
        for (int i = 0; i < numRows; ++i) // 遍历每一行
        {
            vv[i].resize(i + 1, 1); // 将当前行的大小设为 i+1，并初始化所有元素为1
        }
        for (int i = 2; i < numRows; ++i) // 从第三行开始遍历每一行
        {
            for (int j = 1; j < i; ++j) // 遍历当前行的每个元素（除了第一个和最后一个）
            {
                vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1]; // 设置当前元素为上一行左边和上边元素的和
            }
        }
        return vv; // 返回构造好的帕斯卡三角形
    }
};
ruiruiupup
关注
  • 8
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++——std::Vector
zy2317878的博客
12-04 5964
写在前面： 写这篇博客的缘由是我开始通过LeetCode刷题来训练我学习C++的计划时，最开始选择的题目类别是数组题。那么自然而言要涉及到C++中STL（标准库）的Vector容器了。其实在做题过程中我还涉及到诸如Set、Map等的容器，那么我会在后续的学习中，通过博文的形式记录一下学习历程。 这将是我首次系统的重新学习Vector容器。之前有通过刷华为OJ的题积累过Vector的相关用法，但...
STL容器与算法（三）C++ Vector知识点
diviner_s的博客
02-12 1572
C++ Vector知识点 vector是C++标准模板库中的部分内容，中文偶尔译作“容器”，但并不准确。它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。 vector是STL的动态数组，在运行时能根据情况需要改变数组的大小。由...
C++语法知识汇总
myNOI_code的博客
06-27 1081
输出 判断语句 if ... else if ... else 语句 switch() {} 语句 循环 for while do-while 运算符 除了日常的四个运算符：还有一个运算符： vector 变量 顾名思义，变量，可变的量。共有以下几种：单精度浮点值，用于存储单精度浮点数。单精度是这样的格式，1 位符号，8 位指数，23 位小数，通常占用4个字节。双精度浮点值，用于存储双精度浮点数。双精度是 1 位符号，11 位指数，52
AcWing-C/C++语法基础【合集2】
violet的博客
11-15 2759
语法合集2
C/C++常见面试知识点总结附面试真题----20220326更新
热门推荐
生命在于折腾！
09-19 14万+
以下内容部分整理自网络，部分为自己面试的真题。 第一部分：计算机基础 1. C/C++内存有哪几种类型？ C中，内存分为5个区：堆(malloc)、栈(如局部变量、函数参数)、程序代码区（存放二进制代码）、全局/静态存储区（全局变量、static变量）和常量存储区（常量）。此外，C++中有自由存储区（new）一说。 2. 堆和栈的区别？ 1).堆存放动态分配的对象——即那些在程序运行时分配的对象......
C++常见语法汇总
qq_34310307的博客
04-26 6164
C++常见知识点汇总
C++语法学习笔记之三 -- 源码分析 std::vector＜bool＞ 设计，学会合理使用
~ 飞 扬 的 天 空 ~
05-30 1392
但凡上网搜索下关于 std::vector<bool> 的讨论，基本都是吐槽它的实现，分不清这么设计是feature还是bug。此外，由于 std::vector<bool> 也经常应用在leetcode刷题中。因此，本期就来聊下 它的底层实现，来帮助你正确的使用它。 前言 std::vector<bool>，是类 sd::vector<T,std::allocator<T>> 的部分特化，为了节省内存，内部实际上是按bit来表征bool类型。从
C++语法知识点-vector+子数组
yihoujian_2003的博客
11-23 540
Vector是一个封装了动态大小数组的顺序容器（SequenceContainer）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。二维vector数组vector Arrayname[size];Arrayname[]中的每一个元素都是一个vector。我们可以把二维vector数组当做两个维都可以变长的二维数组来理解。初始化：//初始化5个值为0的元素//定义了5个整型元素的向量,且给出每个元素的初值为1//从数组中获得初值。
C++基础知识点总结
深度学习 || 神经网络
02-07 1万+
自学c++过程中遇到的一些需要记忆的知识点,参考小甲鱼C++教程。
C++知识点 —— 整合（持续更新中）
逆流而尚 的博客
11-03 3万+
本文记录自己在自学C++过程中不同于C的一些知识点，适合于有C语言基础的同学阅读。如果纰漏，欢迎回复指正 目录 第一部分 基础知识 一、HelloWorld与命名空间 二、引用和引用参数 2.1引用的定义 2.2 将引用用作函数参数 2.3 将引用用于类对象 2.4 引用和继承 2.5 何时使用引用参数 2.6 引用和指针的区别 三、内联函数 四、默认参数的...
CPP.zip_site:www.pudn.com
09-24
8. **标准库的使用**：C++标准库包含大量实用的功能，如算法库（algorithm）、容器（容器如vector、list、set等）、迭代器（iterator）等，合理利用可大大简化编程。 9. **STL（Standard Template Library）**：STL...
CPP.zip_cpp入门教程_site:www.pudn.com
09-22
对于初学者来说，逐步学习并实践这些知识点，是掌握C++编程的关键步骤。同时，配合实际项目练习和阅读相关的经典书籍，如《C++ Primer》和《Effective C++》，将有助于深入理解和提升C++编程能力。在www.pudn.com...
每天学点C++（C++实例教程：教程+源码）通讯录.zip
06-21
下面我们将深入探讨C++语言的关键知识点，并结合"通讯录"这个实例进行解析。 1. **C++基础知识**：C++是C语言的增强版，支持面向对象编程（OOP）。学习C++首先要掌握基本语法，包括变量、常量、运算符、流程控制...
每天学点C++（C++实例教程：教程+源码）01C++初识.zip
06-21
"每天学点C++"的实例教程旨在帮助初学者逐步理解并掌握C++的基本概念和编程技巧。通过源码的学习，可以更直观地了解代码如何工作，从而提升编程能力。 在“01C++初识”这个部分，我们将首先接触到C++的基础知识。这...
每天学点C++（C++实例教程：教程+源码）核心编程.zip
06-21
在提供的压缩包中，"C++核心编程"可能包含一系列的源代码文件，每个文件都对应一个或多个上述知识点的具体示例。通过实际运行和分析这些代码，你可以加深对C++的理解，提升编程技能。记得实践是检验理论的最好方式，...
【C++】深入理解C++模板：从基础到进阶
最新发布
2403_86785171的博客
09-01 644
模板是C++中用于泛型编程的工具。它允许你编写可以处理任意类型的函数和类，而不必重复编写相似的代码。函数模板和类模板。
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1252
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
c++11新特性-智能指针
SuperYang_的博客
09-01 1128
智能指针RAII(Resource Acquisition Is Initialization)，是一种利用对象的生命周期来管理资源的技术。如果我们采用传统的new/delete来申请和释放资源，如果忘记调用delete，或者在调用delete之前程序抛出异常，都会导致内存泄漏问题，如代码1.1，Func函数中的new p2和Div都可能抛异常，导致后面的delete没有执行从而引发内存泄漏，采用智能指针对资源进行管理，能够杜绝这类问题。代码1.1：因异常引发的内存泄漏throw "除0错误";
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 4128
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
C++核心知识点概览：基础到STL与标准库详解
C++重要知识点总结涵盖了C++语言的基础和高级特性，主要围绕以下几个方面展开： 1. 引用与指针： - 引用是C++中的强大工具，它提供了间接访问变量的能力。引用有其特定规则，如一旦引用被初始化，就不能改变引用的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值