Android 12系统源码_Settings（一）认识Preference

目录

vector的介绍

vector的使用

构造函数

赋值operator        

迭代器

容量

创建二维数组

1. 创建一维向量 v：

2. 创建二维向量 vv：

3. 修改元素：

4. 遍历二维向量：

vector实现

命名空间定义

类模板定义

公共类型定义

构造函数

析构函数

成员函数

测试函数

这篇博客我讲的不会很多，因为他和前面的string非常的像，并且更加简洁，还是一样我们根据文章来讲解，然后给一些特殊情况，然后再简单的实现一下vector.

vector的介绍

vector - C++ Reference (cplusplus.com)https://legacy.cplusplus.com/reference/vector/vector/?kw=vector这个是一个c++的文档，可以根据这里面的介绍来合理的运用接口

vector的使用

构造函数

我写一下这些构造，我相信大家其实也可以看懂

#include <iostream>
#include <vector>

void test1() {
    // 构造一个包含10个元素的向量，所有元素初始化为0。
    std::vector<int> v(10, 0);

    // 复制构造 - 创建一个新的向量，包含与 'v' 相同的元素。
    std::vector<int> v1(v);

    // 迭代器构造 - 从 'v1' 的后五个元素创建一个新的向量。
    std::vector<int> v2(v1.begin() + 5, v1.end());

    // 初始化一个数组，并从其内容构建一个向量。
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    std::vector<int> v3(arr, arr + sizeof(arr) / sizeof(arr[0]));

    // 遍历 'v3' 并打印其元素。
    for (int ch : v3) {
        std::cout << ch << " ";
    }
    std::cout << std::endl; // 打印换行符。
}

// 示例用法：
int main() {
    test1();
    return 0;
}

赋值operator        

#include <iostream>
#include <vector>

void test2() {
    // 创建两个向量，v1 和 v2，分别包含5个元素，初始化为1和2。
    std::vector<int> v1(5, 1);
    std::vector<int> v2(5, 2);

    // 将 v2 的内容赋给 v1。
    v1 = v2;

    // 打印 v1 的内容。
    std::cout << "v1: ";
    for (auto ch : v1) {
        std::cout << ch << " ";
    }
    std::cout << std::endl;

    // 再次将 v2 的内容赋给 v1（实际上这里没有改变 v1 的内容）。
    v1 = v2;

    // 打印 v2 的内容。
    std::cout << "v2: ";
    for (auto ch : v2) {
        std::cout << ch << " ";
    }
    std::cout << std::endl;
}

// 示例用法：
int main() {
    test2();
    return 0;
}

迭代器

#include <iostream>
#include <vector>

void test3() {
    // 初始化数组：定义了一个整数数组 arr，并初始化了10个元素。
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

    // 构造向量：使用数组的内容创建了一个常量 std::vector<int>，命名为 v。
    const std::vector<int> v(arr, arr + sizeof(arr) / sizeof(arr[0]));

    // 使用迭代器遍历向量：
    // 定义了一个 std::vector<int>::const_iterator 类型的迭代器 it，并将其初始化为指向向量的第一个元素。
    // 使用 while 循环遍历整个向量，每次迭代输出当前迭代器所指的元素，并递增迭代器。
    // 输出完所有元素后，换行。
    for (std::vector<int>::const_iterator it = v.begin(); it != v.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 使用范围for循环遍历向量：
    // 使用范围for循环遍历向量 v，并输出每个元素。
    for (auto ch : v) {
        std::cout << ch << " ";
    }
    std::cout << std::endl;

    // 使用反向迭代器遍历向量：
    // 定义了一个 std::vector<int>::const_reverse_iterator 类型的反向迭代器 it，并将其初始化为指向向量的最后一个元素。
    // 使用 while 循环遍历整个向量，每次迭代输出当前反向迭代器所指的元素，并递增反向迭代器。
    // 输出完所有元素后，换行。
    for (std::vector<int>::const_reverse_iterator it = v.rbegin(); it != v.rend(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 使用引用范围for循环遍历向量：
    // 使用范围for循环遍历向量 v，并输出每个元素的引用。虽然这里没有修改元素的值，但是这种方式可以用来修改向量中的元素。
    for (auto &ch : v) {
        std::cout << ch << " ";
    }
    std::cout << std::endl;
}

// 示例用法：
int main() {
    test3();
    return 0;
}

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

这里我举几个例子

#include <iostream>
using namespace std;
#include <vector>
int main()
{
    vector<int> v{1,2,3,4,5,6};
    
    auto it = v.begin();
    
    // 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
    // v.resize(100, 8);
    
    // reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容
量改变
    // v.reserve(100);
    
    // 插入元素期间，可能会引起扩容，而导致原空间被释放
    // v.insert(v.begin(), 0);
    // v.push_back(8);
    
    // 给vector重新赋值，可能会引起底层容量改变
    v.assign(100, 8);
    
    /*
    出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释
放掉，而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块
已经被释放的空间，而引起代码运行时崩溃。
    解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给
it重新赋值即可。
    */
    while(it != v.end())
   {
        cout<< *it << " " ;
        ++it;
   }
    cout<<endl;
    return 0;
}

#include <iostream>e
/*rase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理
论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end
的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素
时，vs就认为该位置迭代器失效了。
以下代码的功能是删除vector中所有的偶数，请问那个代码是正确的，为什么？*/
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;
}

还有和这个删除是一样的就是头插入，这个也会出现迭代器失效，因为pos位置没有进行映射改变

容量

#include <iostream>
#include <vector>

void test4() {
    // 初始化一个整数数组。
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

    // 使用数组的内容构造一个 std::vector<int>，命名为 v。
    std::vector<int> v(arr, arr + sizeof(arr) / sizeof(arr[0]));

    // 输出向量的信息。
    std::cout << "大小 -> " << v.size() << std::endl;
    std::cout << "容量 -> " << v.capacity() << std::endl;

    // 调整向量的大小，并填充额外的元素。
    v.resize(12, 1);
    for (auto& ch : v) {
        std::cout << ch << " ";
    }
    std::cout << std::endl;

    // 再次调整向量的大小，并填充额外的元素。
    v.resize(5, 2);
    for (auto& ch : v) {
        std::cout << ch << " ";
    }

    // 创建一个向量，并移除其中的偶数元素。
    std::vector<int> v1{1, 2, 3, 4, 5, 6};
    auto it = v1.begin();
    while (it != v1.end()) {
        if (*it % 2 == 0) {
            it = v1.erase(it); // 注意：erase 返回指向下一个元素的新迭代器。
        } else {
            ++it;
        }
    }
    for (auto e : v1) {
        std::cout << e << " ";
    }
    std::cout << std::endl;
}

// 示例用法：
int main() {
    test4();
    return 0;
}

创建二维数组

void test5(){
    vector<int> v(5,0);  
    vector<vector<int>>vv(5,v);
    vv[0][1] = 5;//operator[]返回
    //第一个[]，访问的是外层的vector -- 也就是行
    //第二个[],访问的是里层的vector  -- 也就是列
    //遍历二维数组
    for (size_t i = 0; i < vv.size(); i++)
    {
        for (size_t j = 0; j < v.size();j++) {
            cout << vv[i][j] << " ";
        }
        cout << endl;
    }
}

vector实现

这个实现我只会实现个别的接口

#pragma once
#include <iostream>
#include <vector>
#include <cassert>
using namespace std;

namespace yang {
    // 定义类模板
    template <class T>
    class vector {
    public:
        typedef T* iterator;          // 非常量迭代器类型定义
        typedef const T* const_iterator; // 常量迭代器类型定义

        // 默认构造函数
        vector() = default;

        // 拷贝构造函数
        vector(const vector<T>& v) {
            // 分配与原向量相同大小的空间
            reserve(v.size());
            for (const auto& it : v) {
                pushback(it); // 将原向量的每个元素复制到新向量
            }
        }

        // 迭代器范围构造函数
        template <class inputiterator>
        vector(inputiterator fast, inputiterator last) {
            while (fast != last) {
                pushback(*fast); // 将迭代器范围内的元素添加到向量中
                ++fast;
            }
        }

        // 构造函数，创建指定大小的向量，并用给定值初始化
        vector(size_t n, const T val = T()) {
            reserve(n); // 分配足够大的空间
            for (int i = 0; i < n; i++) {
                pushback(val); // 添加初始化值
            }
        }

        // 构造函数，创建指定大小的向量，并用给定值初始化
        // 注意：使用 int 参数可能会导致溢出问题
        vector(int n, const T val = T()) {
            reserve(n); // 分配足够大的空间
            for (int i = 0; i < n; i++) {
                pushback(val); // 添加初始化值
            }
        }

        // 析构函数
        ~vector() {
            delete[] _start; // 释放分配的内存
            _start = _finish = _end_of_storage = nullptr; // 清理指针
        }

        // 获取向量中的元素数量
        size_t size() const {
            return _finish - _start;
        }

        // 获取向量的容量
        size_t capacity() const {
            return _end_of_storage - _start;
        }

        // 判断向量是否为空
        bool empty() {
            return _finish == _start;
        }

        // 清空向量内容
        void clear() {
            _finish = _start;
        }

        // 返回向量开始迭代器
        iterator begin() {
            return _start;
        }

        // 返回向量开始的常量迭代器
        const_iterator begin() const {
            return _start;
        }

        // 返回向量结束迭代器
        iterator end() {
            return _finish;
        }

        // 返回向量结束的常量迭代器
        const_iterator end() const {
            return _finish;
        }

        // 扩容函数
        void reserve(size_t n) {
            if (n > capacity()) {
                // 记录原来的元素数量
                size_t old_size = size();

                // 分配新的内存空间
                T* tmp = new T[n];
                //memcpy(tmp, _start, sizeof(T) * size()); // 旧版代码使用memcpy
                for (int i = 0; i < old_size; i++) {
                    tmp[i] = _start[i]; // 复制原有元素
                }

                // 销毁旧内存
                delete[] _start;

                // 更新指针
                _start = tmp;
                _finish = tmp + old_size;
                _end_of_storage = tmp + n;
            }
        }

        // 调整向量大小
        void resize(size_t n, T val = T()) {
            if (n < size()) {
                _finish = _start + n; // 缩小向量
            } else {
                reserve(n); // 扩容
                while (_finish < _start + n) {
                    *_finish = val; // 填充新元素
                    ++_finish;
                }
            }
        }

        // 在向量末尾添加元素
        void pushback(const T& val) {
            if (_finish == _end_of_storage) {
                reserve(capacity() == 0 ? 4 : capacity() * 2); // 如果空间不足则扩容
            }
            *_finish = val; // 添加新元素
            ++_finish;
        }

        // 移除向量末尾的元素
        void popback() {
            assert(!empty()); // 断言向量非空
            --_finish; // 向量末尾减一
        }

        // 交换两个向量的内容
        void swap(vector<T>& v) {
            std::swap(_start, v._start);
            std::swap(_finish, v._finish);
            std::swap(_end_of_storage, v._end_of_storage);
        }

        // 赋值运算符重载
        vector<T>& operator=(vector<T> v) {
            swap(v); // 使用swap函数完成赋值
            return *this;
        }

        // 下标访问
        T& operator[](size_t i) {
            assert(i < size()); // 断言索引在范围内
            return _start[i]; // 返回元素的引用
        }

        // 常量下标访问
        const T& operator[](size_t i) const {
            assert(i < size()); // 断言索引在范围内
            return _start[i];
        }

        // 在指定位置插入元素
        iterator insert(iterator pos, const T& val) {
            assert(pos >= _start && pos < _finish); // 断言位置合法
            if (_finish == _end_of_storage) {
                // 存储pos到_start的位置（如果扩容，地址会改变）
                size_t len = pos - _start;

                // 扩容
                reserve(capacity() == 0 ? 4 : capacity() * 2);
                // 更新位置（映射）
                pos = _start + len;
            }

            // 向右移动元素以留出空间
            iterator end = _finish - 1;
            while (end >= pos) {
                *(end + 1) = *end;
                --end;
            }

            *pos = val; // 插入新元素
            ++_finish; // 更新结束指针

            // 返回新元素的位置（注意返回pos+1是为了不影响实参）
            return pos + 1;
        }

        // 删除指定位置的元素
        iterator erase(iterator pos) {
            assert(pos >= _start && pos < _finish); // 断言位置合法

            // 移动后面的元素向前覆盖被删除的元素
            iterator it = pos + 1;
            while (it != _finish) {
                *(it - 1) = *it;
                ++it;
            }

            --_finish; // 更新结束指针
            return pos; // 返回删除位置
        }

    private:
        iterator _start = nullptr; // 开始迭代器
        iterator _finish = nullptr; // 结束迭代器
        iterator _end_of_storage = nullptr; // 存储区结束迭代器
    };

    //-- 测试函数 --
    void test1() {
        vector<int> v;
        v.reserve(5); // 预留5个元素的空间
        v.pushback(1);
        v.pushback(2);
        v.pushback(3);
        v.pushback(4);
        v.pushback(5);
        v.pushback(1);
        v.pushback(2);
        v.pushback(3);
        v.pushback(4);
        v.pushback(5);

        cout << v.size() << endl; // 输出向量的大小
        cout << v.capacity() << endl; // 输出向量的容量
        auto pos = find(v.begin(), v.end(), 2); // 查找值2的位置
        pos = v.insert(pos, 10); // 在找到的位置插入10
        *pos *= 10; // 修改插入的元素值为100

        // 利用迭代器打印
        vector<int>::iterator it = v.begin();
        while (it != v.end()) {
            cout << *it << " ";
            ++it;
        }
    }

    void test2() {
        // 删除
        vector<int> v;
        for (int i = 0; i < 10; i++) {
            v.pushback(i); // 添加偶数
            v.pushback(i); // 添加偶数
        }

        auto it = v.begin(); // 自动类型推导
        while (it != v.end()) {
            if (*it % 2 == 0) {
                it = v.erase(it); // 删除偶数
            } else {
                ++it;
            }
        }

        for (auto ch : v) {
            cout << ch << " "; // 输出剩余的奇数
        }
    }

    void test3() {
        vector<int> v;
        for (int i = 0; i < 10; i++) {
            v.pushback(i); // 添加0-9
        }

        cout << v.size() << endl; // 输出向量大小
        for (auto ch : v) {
            cout << ch << " "; // 输出所有元素
        }
        cout << endl;

        v.resize(5); // 缩小向量
        for (auto ch : v) {
            cout << ch << " "; // 输出前五个元素
        }
        cout << endl;

        v.resize(20); // 扩大向量
        for (auto ch : v) {
            cout << ch << " "; // 输出所有元素
        }
    }

    void test4() {
        vector<int> a1;
        a1.pushback(1);
        a1.pushback(1);
        a1.pushback(1);
        a1.pushback(1);
        a1.pushback(1);

        vector<int> a2 = a1; // 拷贝构造
        for (auto ch : a2) {
            cout << ch << " "; // 输出拷贝的内容
        }
        cout << endl;

        a1.clear(); // 清空a1
        cout << a1.size() << endl; // 输出a1的大小
    }

    void test5() {
        vector<string> v;
        v.pushback("hello"); // 添加字符串"hello"
        vector<string> vv(v); // 拷贝构造
        for (auto ch : vv) {
            cout << ch << " "; // 输出拷贝的内容
        }
    }
}