Как у вас двумерные вектора устроены?

#include <stdlib.h>
#include <stdio.h>
 
int NUM_OBJECTS = 20;
 
typedef struct{
    int* val;
    void* next;
} n_obj;
 
#define Q_INT malloc(sizeof(int))
#define Q_OBJ malloc(sizeof(n_obj))
#define Q_SEQ(x) calloc((x), sizeof(int))
 
int main()
{
    int clear_i;
    int i, left_i, cur_sz, cur_num;
    n_obj **cl;
    n_obj *temp;
    n_obj *cur_list;
    n_obj *cur_seq;
     
    cl = malloc(sizeof(n_obj*)*NUM_OBJECTS);
     
    for(i=0;i<NUM_OBJECTS;i++)
    {
        cl[i] = Q_OBJ;
        cl[i]->val = NULL;
         
        temp = Q_OBJ;
        temp->val = Q_SEQ(1);
         
        temp->val[0] = i + 1;
         
        temp->next = cl[i]; 
        cl[i] = temp;
         
        cur_list = cl[i];
        for(left_i=0; left_i<i; left_i++)
        {
            for(cur_seq=cl[left_i];cur_seq->val!=NULL;cur_seq=cur_seq->next)
            {               
                if(cur_seq->val[0]<=(i - left_i))
                {
                    temp = Q_OBJ;
                    temp->val = Q_SEQ(left_i + 3);
                     
                    temp->val[0] =  i - left_i;
                     
                    temp->next = cur_list->next;
                    cur_list->next = temp; 
                    cur_list = temp;
                     
                    for(cur_num=0;cur_num<=left_i;cur_num++)
                        cur_list->val[cur_num+1] = cur_seq->val[cur_num];
                }
            }
        }
    }
     
    for(i = 0; i < NUM_OBJECTS; i++)
    {
        cur_sz = 0;
        printf("---------------------------\n");
        for(cur_list = cl[i]; cur_list->val != NULL; cur_list = cur_list->next)
        {
            for(clear_i = 0; cur_list->val[clear_i] != 0; clear_i++)
            {
                printf("%d ", cur_list->val[clear_i]);
            }
            printf("\n");
            cur_sz++;
        }
        printf("Number of partitions = %d\n", cur_sz);
     
    }
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;
 
int main(int argc, char* argv[])
{
size_t s=10;
//typedef vector<s, int> v10; //так не получится к сожалению и это не проблема компиляторов и стандартов
//это проблема мозга тех кто их создавал
//поэтому нельзя сразу захватить константное количество элементов на уровне типа так, как это делается при объявлении
int A[10];
//то есть ты можешь
typedef int Array10int[10];
//а потом 
Array10int array10int[10];// аналогично объявлению int  array10int[10][10];
//а с вектором так нельзя так как он не параметризуется на конечном размере и для векторов строк всё нужно делать в конструкторе
//который нельзя вызвать для строк
//то есть можно
vector<int>v10int(10);
//но ты не можешь создать вектор таких векторов в объявлении, так же как объявить а потом вызвать конструкторы для строк
//остаётся лишь
vector<vector<int>> vecvec10int(10);
//а потом заниматься сексом с командой resize, например на строках в цикле по ним
for(int i=0; i<10; ++i) vecvec10int[i].resize(10);
//а это, если даже не цементировать при помощи reserve может быть достаточно накладно
//это потому, что размер не может быть параметром шаблона vector
//но есть std::array и можно получить неплохую поддержку не прибегая к вектору.
cout<<endl;
system("pause");
return 0;
}

int A[10]

std::array<std::array<int, 10>, 10> Array;

class Matrix {
private:
  size_t m_rows;
  size_t m_cols;
  std::vector<double> m_data;
 
public:
  Matrix(size_t rows, size_t cols)
      : m_rows(rows)
      , m_cols(cols)
      , m_data(rows * cols)
  {}
 
  size_t rows()
  {
    return m_rows;
  }
 
  size_t cols()
  {
    return m_cols;
  }
 
  double &operator()(size_t row, size_t col)
  {
    return m_data[row * m_cols + col];
  }
};