array of vector<struct> in C++

At any given time, a std::vector<> has a constraint, size which is the maximum element number you can access + 1, and a constraint capacity which is how many elements it can contain before it has to move the data to a larger memory allocation.

size determines what you can access. When the vector is created, you cannot access anything. vec[0] is illegal when the vector is empty.

#include <vector>
#include <iostream>

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

    std::cout << "initially, vec.size = " << vec.size() << ", cap = " << vec.capacity() << "\n";

    // initially, the vector is empty. 

    // std::cout << vec[0] << '\n'; // undefined behavior, probably a crash
    // you can only ever access vec[n] where v < vec.size(),
    // this vector is empty, so size() == 0

    // Lets add a number to the vector.
    vec.push_back(5);
    std::cout << "now, vec.size = " << vec.size() << ", cap = " << vec.capacity()         

    std::cout << "vec[0] = " << vec[0] << '\n';
    // std::cout << vec[1] << '\n'; // undefined behavior because 1 >= size()

    vec.resize(5);
    std::cout << "resized, vec.size = " << vec.size() << ", cap = " << vec.capacity()         

    vec[1] = 1; // valid, resize made space for vec[0] .. vec[4]
    vec[2] = 2;

    for (auto it = vec.begin(), end = vec.end(); it != end; ++it)
        std::cout << *it << '\n';

    return 0;
}

push_back does "vec.resize(vec.size() + 1)" for you, and then inserts the value being 'push_back'ed into the new slot.

resize attempts to make room for extra elements -- if size is 3 and you say resize(5) it will try to make room for 2 new elements.

If the result causes size to exceed capacity then the vector allocates a new array, copies the old data over into it, and releases the old array. This can become very expensive. If you know roughly how big your vector is going to become, you can avoid this relocation by calling reserve()

#include <iostream>
#include <vector>

using std::cout;

struct Stud // will always tell you when it reproduces
{
    int m_i;
    Stud() : m_i(-1) {}
    Stud(int i) : m_i(i) {}
    Stud(const Stud& rhs) : m_i(rhs.m_i) { cout << "Copying(Ctor) " << m_i << '\n'; }
    Stud& operator=(const Stud& rhs) { m_i = rhs.m_i; cout << "Copying(=) " << m_i << '\n'; return *this; }
};

int main()
{
    std::vector<Stud> studs;

    studs.push_back(0);
    studs.push_back(1);

    studs.reserve(5);

    studs.push_back(5); // remember, this adds to the back.
    studs.push_back(6);

    std::cout << "size of studs " << studs.size();

    return 0;
}

Based on this

bool Update_V4(USHORT S1,USHORT S2,DWORD S3,USHORT S4);

I am guessing that you are trying to simulate multi-dimensional arrays of some kind, and you are doing something like

V4Ref[S1]

without checking

if (S1 < V4Ref.size())

C++ has a function 'assert' which will cause a Debug build application to terminate if a condition is not met.

#include <cassert>
#include <vector>

int main()
{
    std::vector<int> vec;
    assert(vec.size() == 0);
    vec.push_back(1);
    vec.resize(5);
    vec.push_back(5);
    assert(vec.size() == 10); // expect to crash here.

    return 0;
}

You could use this to help catch bad sizes:

bool V4::Update_V4(USHORT S1,USHORT S2,DWORD S3,USHORT S4)
{
    assert(S1 < V4ref.size());
    return V4ref[S1].Update_V3(S2, S3, S4);
}