vector

Some example for stl vector.

#include<iostream>
#include<vector>
#include<string>

using namespace std;

class Student{
public:
    string strNO;
    string strName;
    string strSex;
    string strDate;

    Student(string strNO_, string strName_, string strSex_, string strDate_)
    :strNO(strNO_), strName(strName_), strSex(strSex_), strDate(strDate_){}

    void display(){
        cout <<strNO<<"\t"<<strName<<"\t"<<strSex<<"\t"<<strDate<<endl;
    }
};

class VecStudent{
private:
    vector<Student> vs;
public:
    void addStudent(Student& s){
        vs.push_back(s);
    }

    vector<Student> getStudent(){
        return vs;
    }

    void printInfor(){
        vector<Student>::iterator itr = vs.begin();
        while(itr!=vs.end()){
            itr->display();
            itr++;
        }
    }

    Student* Find(string strNO_){
        vector<Student>::iterator itr = vs.begin();
        while(itr!=vs.end()){
            if(itr->strNO==strNO_){
                return &(*itr);
            }else{
                itr++;
            }
        }
        return NULL;
    }
};

int main(){
    Student s1("1001", "Tim", "B", "1986-01-01");
    Student s2("1002", "Sam", "B", "1986-01-02");
    Student s3("1003", "Betty", "G", "1986-01-03");
    Student s4("1004", "David", "G", "1986-01-04");

    VecStudent s;
    s.addStudent(s1);
    s.addStudent(s2);
    s.addStudent(s3);
    s.addStudent(s4);
    s.printInfor();

    Student* i = s.Find("1005");

    if(i==NULL){
        cout << "Could not find such student!" << endl;
    }else{
        i->display();
    }
    return 0;
}

Copy one vector to the end of another vector

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main(){
    vector<int> v1{1,2,3,4,5};
    vector<int> v2{6,7};

    copy(v2.begin(), v2.end(), back_inserter(v1));

    auto itr = v1.begin();
    while(itr != v1.end()){
        std::cout << *itr << " ";
        itr++;
    }
    std::cout << std::endl;

    return 0;
}

miniVector class, help us understand internal mechnism of vector

#ifndef MINIVECTOR_HPP_INCLUDED
#define MINIVECTOR_HPP_INCLUDED

template <typename T>
class miniVector {
public:
    miniVector(int size=0){};
    miniVector(const miniVector<T>& v);
    ~miniVector();

    miniVector& operator=(const miniVector<T>& v);

    T& back();
    const T& back();

    T& operator[](int i);
    const T& operator[](int i) const;

    void push_back(const T& item);
    void pop_back();

    int size() const;

    bool empty() const;

    int capacity() const;

private:
    int vCapacity;
    int vSize;
    T *vArr;

    void reserve(int n, bool copy);
};

template <typename T>
miniVector<T>::miniVector(int size):vSize(0),vCapacity(0),vArr(NULL){
    if (size == 0){
        return;
    } else {
        reserve(size, false);
        vSize = size;
        vCapacity = size;

        for(int i=0; i<size; i++){
            vArr[i] = T();
        }
    }
}

template<typename T>
miniVector<T>::~miniVector(){
    if(vArr != NULL)
        delete [] vArr;
        vArr = NULL;
}

template <typename T>
void miniVector<T>::reserve(int n, bool copy){
    T *newArr = new T[n];

    if (newArr == NULL){
        throw memoryAllocationError("miniVecotr::reserve(): memory allocation failure!";)
    }

    if ((copy)&&(vArr!=NULL)){
        for(int i=0; i<vSize; i++){
            newArr[i] = vArr[i];
        }
        delete [] vArr;
        vCapacity = n;
        vArr = newArr;
        newArr = NULL;
    }else{
        vCapacity = n;
        vArr = newArr;
        newArr = NULL;
    }
}

template <typename T>
miniVector<T>& miniVector<T>::operator=(const miniVector<T>& v){
    if(vCapacity < v.size()){
        reserve(v.size(), false);
        vSize = v.size();
    }

    for(int i=0; i<vSize; i++){
        vArr[i] = v.vArr[i];
    }

    return *this;
}

template <typename T>
miniVector<T>& miniVector<T>::push_back(const T& item){
    if(vSize == vCapacity){
        if(vCapacity==0){
            reserve(1, false);
        }else{
            reserve(2*vCapacity, true);
        }
    }
    vArr[vSize] = item;
    vSize++;
}

template <typename T>
void miniVector<T>::pop_back(){
    if(vSize == 0){
        throw underflowError("miniVector pop_back(): vector is empty");
    }
    vSize--;
}

template <typename T>
miniVector<T>& miniVector<T>::back(){
    if(vSize == 0){
        throw underflowError("miniVector pop_back(): vector is empty");
    }
    return vArr[vSize-1];
}

template <typename T>
T& miniVector<T>::operator[](int i){
    if(i < 0 || i >= vSize){
        throw underflowError("miniVector pop_back(): vector is empty");
    }
    return vArr[i];
}
#endif // MINIVECTOR_HPP_INCLUDED