Массив-ссылка на некоторые элементы другого массива

//большая матрица
int a[nRows][nCols];
 
//нужные индексы
int index[numInd];
 
//тут неверно, так как объявили без присваивания
int& b[numInd][nCols];
 
//и эту матрицу связать с определенными элементами матрицы a 
for (int j = 0; j < numInd; j++)
   for (int i = 0; i < nCols; i++)
       // тут тоже вроде неверно. просто излагаю идею
       b[j][i] = a[index[j]][i];

mpi_send(destination = destination_proc, tag = tag, type = mpi_int, numElements = numInd*nCols, dataToSend = b);

int **a=new int[nRowns];
for( int i=0;i<nRows;++i)
    *a[i]=new int [nCols];

class Matrix;

mymath::Vector<Matrix> a(nMatrix);

mymath::Vector<Matrix*> b(nMatrix);

std::vector<boost::reference_wrapper<Matrix>> matrixes;

boost::optional<boost::reference_wrapper<T>>

#include <vector>
#include <iostream>
#include <boost/optional.hpp>
#include <boost/ref.hpp>
 
int main()
{
    int array[] = {1,2,3,4,5,6,7,8,9};
    int indices[] = {0, 5, 8};
    typedef boost::optional<boost::reference_wrapper<int>> value_t;
    std::vector<value_t> w_vector(10);
    for (int i = 0; i < sizeof(indices) / sizeof(*indices); ++i)
    {
        w_vector[indices[i]] = boost::ref(array[indices[i]]);
    }
    for (const auto& v : w_vector)
    {
        if (v.is_initialized())
        {
            std::cout << *v << std::endl;
        }
        else
        {
            std::cout << "uninit" << std::endl;
        }
    }
}

typedef Matrix<int> MatrixInt;
std::vector<MatrixInt> mainVector(numMatrixes);
 
typedef optional<int&> intRef;
typedef Matrix<intRef> matrRef;
 
std::vector<matrRef> subVector(numMatrixes);
 
int indexArray[numIndexes];
 
for (int iMatrix = 0; iMatrix < numMatrixes; iMatrix++)
{  
    subVector[iMatrix].resize(numIndexes, numCols );
    for (int iIndex = 0; iIndex < numIndexes; iIndex ++)
        for (int iCol = 0; iCol < numCols; iCol++)
            // Описание трех скобок подряд:
            // доступ к нужной матрице: iMatrix
            // доступ к элементу матрицы: iIndex, iCol
            // и как аргумент для конструктора cоответствующий элемент из iMatrix: mainVector[iMatrix](indexArray[iIndex], iCol)
            subVector[iMatrix](iIndex, iCol)(mainVector[iMatrix](indexArray[iIndex], iCol));
}

#include <iostream>
#include <boost/optional.hpp>
 
template<typename T>
class optional_ref : public boost::optional<T&>
{
public:
   using boost::optional<T&>::optional;
   using boost::optional<T&>::operator =;
 
   optional_ref& operator = (const T& value)
   {
      this->operator *() = value;
   }
   operator T& ()
   {
      // assert is initialized
      return this->operator *();
   }
};
 
int main()
{
   int i = 0;
   int& ri = i;
   optional_ref<int> ref(ri);
   std::cout << ref << " " << i << std::endl;
   ref = 100;
   std::cout << ref << " " << i << std::endl;
}

namespace boost { 
namespace serialization {
 
template<class Archive, class T>
void save(
    Archive & ar, 
    const boost::optional< T > & t, 
    const unsigned int /*version*/
){
 
        ar << *t;
    }
}

namespace boost { 
namespace serialization {
 
template<class Archive, class T>
void save(
    Archive & ar, 
    const boost::optional< T > & t, 
    const unsigned int /*version*/
){
    const bool tflag = t.is_initialized();
    ar << boost::serialization::make_nvp("initialized", tflag);
    if (tflag){
        const boost::serialization::item_version_type item_version(version< T >::value);
        #if 0
        const boost::archive::library_version_type library_version(
            ar.get_library_version()
        };
        if(boost::archive::library_version_type(3) < library_version){
            ar << BOOST_SERIALIZATION_NVP(item_version);
        }
        #else
            ar << BOOST_SERIALIZATION_NVP(item_version);
        #endif
        ar << boost::serialization::make_nvp("value", *t);
    }
}