#include<algorithm>
#include<atomic>
#include<array>
#include<chrono>
#include<condition_variable>
#include<cstddef>
#include<ctime>
#include<fstream>
#include<future>
#include<iostream>
#include<iterator>
#include<limits>
#include<memory>
#include<mutex>
#include<numeric>
#include<sstream>
#include<string>
#include<vector>
using namespace std;
template<class T>
class Middle
{
public:
using size_type=typename vector<T>::size_type;
private:
vector<T> *vec_;
const size_type column_;
const size_type index_;
public:
Middle(vector<T> &vec,const size_type column,const size_type index) noexcept
:vec_{addressof(vec)},column_{column},index_{index}{}
Middle(const Middle &)=default;
operator T&()
{
return vec_->operator[](index_);
}
Middle& operator=(const Middle &)=delete;
T& operator[](const size_t i)
{
return vec_->operator[](index_*column_+i);
}
};
template<class T>
class Const_Middle
{
public:
using size_type=typename vector<T>::size_type;
private:
const vector<T> *vec_;
const size_type column_;
const size_type index_;
public:
Const_Middle(const vector<T> &vec,const size_type column,const size_type index) noexcept
:vec_{addressof(vec)},column_{column},index_{index}{}
Const_Middle(const Const_Middle &)=default;
operator const T&()
{
return vec_->operator[](index_);
}
Const_Middle& operator=(const Const_Middle &)=delete;
const T& operator[](const size_t i)
{
return vec_->operator[](index_*column_+i);
}
};
template<class T>
class Test
{
public:
using size_type=typename vector<T>::size_type;
vector<T> vec_;
private:
const size_type column_;
public:
Test(const size_type row,const size_type column)
:column_{column},vec_(row*column){}
Middle<T> operator[](const size_t i)
{
return Middle<T>{vec_,column_,i};
}
Const_Middle<T> operator[](const size_t i) const
{
return Const_Middle<T>{vec_,column_,i};
}
};
int main()
{
Test<int> test(3,4);
iota(begin(test.vec_),end(test.vec_),0);
const Test<int> &test2{test};
cout<<test[6]<<endl;
cout<<test[1][1]<<endl;
cout<<test[2][3]<<endl;
cout<<test2[6]<<endl;
cout<<test2[1][1]<<endl;
cout<<test2[2][3]<<endl;
}
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