STL

【问题：sizeof 与 length（string的成员函数） 区别？】

sizeof ：是C/C++中的一个操作符（operator），简单的说其作用就是返回一个对象或者类型所占的内存字节数。

size ： 一般是容器当前拥有多少元素（注意区分与 capacity）

如果说：

capacity 相当于 _array[sizeof(_array) / sizeof(int) 容积 ， 那么
strlen 相当于 size 当前占有【实际使用时候， strlen的参数是 char或者char*】

// sizeof例子
int _array[] = { 0,2,9,1,2,3,2 };
int* _begin = _array;//指针指向首元素
int* _end = &(_array[sizeof(_array) / sizeof(int)]);

//********************************************************
#include<iostream>
#include<string>

using namespace std;

int main()
{
    string str = "shi rui yu";
    size_t length_ = str.length();//10
    size_t size_ = str.size();//10
    int sizeof_ = sizeof(str)/sizeof(int);//10
    
    char str_[20] = "0123456789";
    int a = strlen(str_); //a=10;
    int b = sizeof(str_); //而b=20;
    return 1;
}

// 定义一个 零 矩阵 最简单的方法
  int const rows = 5;
int const cols = 5;
vector<vector<int>> array_;
vector<int> vec_;
vec_.resize(cols, 0);
array_.resize(rows, vec_);

#include<vector>
#include<iostream>    

using namespace std;

template <typename T>
void printf(vector<T>& vec)
{
    if (!vec.empty())
    {
        for (auto itr : vec)
        {
            cout << itr << ", ";
        }
        cout << endl;
    }
    else
    {
        cout << "容器是空的啦~~" << endl;
    }
}
//大小操作
void test03()
{
    cout << "===== test03()=====" << endl;
    int arry1[] = { 100, 200, 300, 400 };
    vector<int> v4(arry1, arry1 + sizeof(arry1)/sizeof(int));
    cout << " v4.size = " << v4.size() << endl; // size表示元素个数
    cout << " v4.capacity() = " << v4.capacity() << endl; // capatity表示容器的容量，比如：这个容器可以容纳100个元素，那么它的容量 = 100；但是其中只有50个元素，那么它的size = 50
    // 为什么有容量这个说法，比如：当你发现容量不够时，你可以resize一下
    if (!v4.empty())
    {
        cout << "不是空" << endl;
    }
    else
    {
        cout << "空" << endl;
    }
    printf(v4);// 100 200 300 400
    v4.resize(2);//将size改为2，如果改为6则会补充两个0
    printf(v4);// 100 200
}

//vector 存取数据
void test04()
{
    cout << "===== test04()=====" << endl;
    int arry1[] = { 100, 200, 300, 400 };
    vector<int> v4(arry1, arry1 + sizeof(arry1) / sizeof(int));
    int a = v4.at(3);
    int b = v4[3];
    int c = v4.front();//第一个元素
    int d = v4.back();
    cout << "第一个元素 v4.front() = " << v4.front() << endl;
    cout << "最后一个元素 v4.back() = " << v4.back() << endl;
}

//vector 插入与删除
void test05()
{
    cout << "===== test05()=====" << endl;
    vector<int> v1;
    v1.push_back(10);
    v1.push_back(20);
    //[注：insert的效率比较低，慎用]
    v1.insert(v1.begin(), 999);
    v1.insert(v1.end(), 9999);
    v1.insert(v1.begin() + 2, 30); // 一般，支持[]访问元素的容器都支持随机访问
    printf(v1); // 999, 10, 30, 20, 9999

    //删除操作
    v1.erase(v1.begin());
    printf(v1);// 10, 30, 20, 9999
    v1.erase(v1.begin() + 1, v1.end());// 10
    printf(v1);
    v1.clear();// [注：对string没卵用]
    printf(v1);
}

//巧用swap收缩空间
void test06()
{
    cout << "===== test06()=====" << endl;
    vector<int> v1;
    for (int i = 0; i < 1000; i++)
    {
        v1.push_back(i);
    }

    cout << " size = " << v1.size() << endl; // 1000
    cout << "capatity = " << v1.capacity() << endl; // 1066

    v1.resize(10);
    cout << " size = " << v1.size() << endl; // 10
    cout << "capatity = " << v1.capacity() << endl; // 1066

    vector<int>(v1).swap(v1); //这样可以节省内存
    cout << " size = " << v1.size() << endl; // 10
    cout << "capatity = " << v1.capacity() << endl; // 10
}

void test07()
{
    cout << "===== test07()=====" << endl;
    vector<int> v1;
    int num = 0;
    int* address = nullptr;
    // reserve 并没有像resize那样给空间经行初始化
    v1.reserve(10000);//reserve预留空间，理论上，加这一步操作，预留空间会使得对象v1的构造和析构次数极大减少，但是这里不加这一句貌似 MS-build 给自动优化了
    for (int i = 0; i < 10000; i++)
    {
        v1.push_back(i);
    }
    if (address != &(v1[0]))
    {
        address = &(v1[0]);
        ++num;
    }
    cout << " 对象 v1 申请和释放次数 num = " << num << endl;
}

//find
void test08()
{
    cout << "===== test08()=====" << endl;
    vector<int> v1;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);//0123456789
    }
    vector<int>::iterator itr = find(v1.begin(), v1.end(), 88);
    if ( itr != v1.end()) // be found
    {
        cout << "be fonud!" << endl;
    }
    else
    {
        cout << "not be found!" << endl; 
    }
    vector<int> v2, v3;
    v2.assign(v1.begin(), v1.begin() + 3); 
    printf(v2);// 0 1 2
    v3.assign(10, 1);
    printf(v3); // 1~10
    vector<int> v4(10,1);
    printf(v4);// 1~10
}

int main()
{
    //<1>用数组初始化vector
    int arry[] = { 10, 20, 30, 40 };
    vector<int> vec1(arry, arry + sizeof(arry) / sizeof(int));  
    printf(vec1);
    vector<int> vec2(vec1.begin(), vec1.end());   
    printf(vec2);
    vector<int> vec3(vec1);   
    printf(vec3);
    //<2>赋值
    vector<int> vec4;
    vec4 = vec3; // 这是深度拷贝
    printf(vec3);
    vec3.push_back(50);
    printf(vec4);
    printf(vec3);
    //<3>大小操作

    test03();
    test04();
    test05();
    test06();
    test07();
    test08();
    return 1;
}

 insert：

// inserting into a vector
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector(3, 100);// 100 100 100
    std::vector<int>::iterator it;

    it = myvector.begin();
    it = myvector.insert(it, 200); // 200 100 100 100

    myvector.insert(it, 2, 300);// 300 300  200 100 100 100

    // "it" no longer valid, get a new one:
    it = myvector.begin();

    std::vector<int> anothervector(2, 400);
    myvector.insert(it + 2, anothervector.begin(), anothervector.end()); // 300 300 400 400 200 100 100 100

    int myarray[] = { 501,502,503 };
    myvector.insert(myvector.begin(), myarray, myarray + 3); // 501 502 503 300 300 400 400 200 100 100 100

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

    return 0;
}

erase

// erasing from vector
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> myvector;

    // set some values (from 1 to 10)
    for (int i = 1; i <= 10; i++) myvector.push_back(i); // 123456789 10

    // erase the 6th element
    myvector.erase(myvector.begin() + 5);// 12345 789 10

    // erase the first 3 elements:
    myvector.erase(myvector.begin(), myvector.begin() + 3);// [ , )

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

    return 0;
}

//********************************************以下是手动实现一个动态数组的代码

#include<iostream>

using namespace std;

namespace MY
{
    class Vector
    {
    public:
        Vector();
        ~Vector();
        void push_back(int value);
        void removeByPose(int pos);
        void removeByValue(int value);
        int find(int value);
        int& operator[](int index)// 可以是返回引用
        {
            return array_[index];
        }
        void show() const;
        void clear()
        {
            size_ = 0;
        }
        bool empty()
        {
            if (array_ == nullptr)
                return true;
            else
                return false;
        }
    public:
        int* array_;
        int size_;
        int capacity_;
    };

    Vector::Vector()
    {
        size_ = 0;
        capacity_ = 10;
        array_ = new int[capacity_];
    }
    Vector::~Vector()
    {
        delete[] array_;
        cout << "free " << array_ << endl;
    }
    void MY::Vector::push_back(int value)
    {
        if (empty()) return;
        //判断空间是否足够
        if (size_ == capacity_)
        {
            int* newspace = new int[capacity_ * 2]; // 扩容
            memcpy(newspace, array_, capacity_ * sizeof(int));// 备份 - > newsapce
            delete[] array_;// 删除旧空间
            capacity_ *= 2;//扩容
            array_ = newspace;//转移旧空间的值 - > 新空间
        }
        //在末尾插入元素
        array_[size_] = value;
        size_++;
    }
    void MY::Vector::show() const
    {
        cout << "size_ = " << size_ << " ||";
        for (int i = 0; i < size_; i++)
        {
            cout << array_[i] << " ";
        }
        cout << endl;
    }
    void MY::Vector::removeByPose(int pos)
    {
        if (empty()) return;
        if (pos < 0 || pos >= size_)//越界
        {
            cout << "out of range!" << endl;
            return;
        }
        for (int i = pos; i < (size_ - 1); i++) //注意越界
        {
            array_[i] = array_[i + 1];
        }
        size_--;
    }
    int MY::Vector::find(int value)
    {
        if (empty()) return -1;
        int pos = -1;
        for (int i = 0; i < size_; i++)
        {
            if (array_[i] == value)
            {
                pos = i;
                break;
            }
        }
        return pos;
    }
    void MY::Vector::removeByValue(int value)
    {
        if (empty()) return;
        int pos = find(value);
        if (pos == -1)
        {
            cout << "没有元素：" << value << endl;
            return;
        }
        removeByPose(pos);
    }
}

int main()
{
    // 参考别人博客：https://blog.csdn.net/qq_26816591/article/details/52214313
    //// 我的博客： https://www.cnblogs.com/winslam/articles/9146832.html
    //int *p1 = new int; //在自由存储区开辟一个int变量 
    //int *p2 = new int[10];//在自由存储区开辟一个int数组，有10个元素
    //for (int i = 0; i < 10; i++)
    //{
    //    p2[i] = i;
    //    cout << "p2 = " << p2[i] << endl;
    //}
    //p2[2] = p2[1];
    //int *p3 = new int(10);//在自由存储区开辟一个int变量,并初始化为10
    //cout << "*p3 = " << *p3 << endl;

    MY::Vector vec;
    for (int i = 0; i < 12; i++)
    {
        vec.push_back(i*i);
    }
    vec.push_back(88);
    vec.show();
    vec.removeByPose(1);
    vec.show();
    vec.removeByPose(2);
    vec.show();
    vec.removeByValue(49);
    vec.show();
    int position = vec.find(25);
    //测试重载
    cout << "test for overload " << endl;
    for (int i = 0; i < vec.size_; i++)
    {
        cout << vec[i] << " ";
    }
    cout << endl;

    vec.clear();
    vec.show();
    return 1;
}