fork(1) download 
  1. #include <vector>
  2. #include <utility>
  3. #include <iostream>
  4.  
  5. template <typename T>
  6. class Matrix
  7. {
  8. private:
  9.     class Row
  10.     {
  11.     friend class Matrix;
  12.  
  13.     public:
  14.         T& operator[] (int j) &&
  15.         {
  16.             return matrix->mappedVector[i * matrix->n + j];
  17.         }
  18.         const T& operator[] (int j) const &&
  19.         {
  20.             return matrix->mappedVector[i * matrix->n + j];
  21.         }
  22.     private:
  23.         int i;
  24.         Matrix* matrix;
  25.  
  26.         Row(int i, const Matrix* matrix):
  27.             i(i),
  28.             matrix(const_cast<Matrix*>(matrix))
  29.         {
  30.         	std::cout << "int ctor" << std::endl;
  31.         }
  32.         Row(int i, Matrix* matrix):
  33.             i(i),
  34.             matrix(matrix)
  35.         {
  36.         	std::cout << "int ctor" << std::endl;
  37.         }
  38.         Row()
  39.         {
  40.             std::cout << "ctor" << std::endl;
  41.         }
  42.         Row(const Row&)
  43.         {
  44.             std::cout << "copy ctor" << std::endl;
  45.         }
  46.         Row& operator=(const Row&)
  47.         {
  48.             std::cout << "assign lvalue" << std::endl;
  49.         }
  50.         Row(Row&&)
  51.         {
  52.             std::cout << "move ctor" << std::endl;
  53.         }
  54.         Row& operator=(Row&&)
  55.         {
  56.             std::cout << "assign rvalue" << std::endl;
  57.         }
  58.     };
  59. public:
  60.     Matrix():
  61.         m(0),
  62.         n(0)
  63.     {}
  64.     explicit Matrix(size_t m, size_t n):
  65.         m(m),
  66.         n(n),
  67.         mappedVector(m*n)
  68.     {}
  69.     Matrix(const Matrix& rhs):
  70.         m(rhs.m),
  71.         n(rhs.n),
  72.         mappedVector(rhs.mappedVector)
  73.     {}
  74.     Matrix& operator=(const Matrix& rhs)
  75.     {
  76.         if(&rhs != this)
  77.         {
  78.             m = rhs.m;
  79.             n = rhs.m;
  80.             mappedVector.resize(rhs.mappedVector.size);
  81.             mappedVector = rhs.mappedVector;
  82.         }
  83.     }
  84.     Matrix(Matrix&& rhs):
  85.         m(std::exchange(rhs.m, 0)),
  86.         n(std::exchange(rhs.n, 0)),
  87.         mappedVector(std::exchange(rhs.mappedVector, {}))
  88.     {}
  89.     Matrix& operator=(Matrix&& rhs)
  90.     {
  91.         if(&rhs != this)
  92.         {
  93.             m = std::exchange(rhs.m, 0);
  94.             n = std::exchange(rhs.n, 0);
  95.             mappedVector = std::exchange(rhs.mappedVector, {});
  96.         }
  97.     }
  98.     Row operator[] (int i)
  99.     {
  100.         return Row(i, this);
  101.     }
  102.     const Row operator[] (int i) const
  103.     {
  104.         return Row(i, this);
  105.     }
  106. private:
  107.     size_t m;
  108.     size_t n;
  109.     std::vector<T> mappedVector;
  110. };
  111.  
  112. int main()
  113. {
  114. 	Matrix<int> matrix(2, 5);
  115.     matrix[1][0] = 1;
  116.  
  117.     auto autoRowProxy = matrix[1];
  118.  
  119. 	return 0;
  120. }
Compilation error #stdin compilation error #stdout 0s 4492KB
comments (?)
stdin 
Standard input is empty
compilation info 
prog.cpp: In function ‘int main()’:
prog.cpp:117:33: error: ‘Matrix<T>::Row::Row(Matrix<T>::Row&&) [with T = int]’ is private within this context
     auto autoRowProxy = matrix[1];
                                 ^
prog.cpp:50:9: note: declared private here
         Row(Row&&)
         ^~~
stdout 
Standard output is empty
https://ideone.com/ID9hkN
language:
C++14 (gcc 8.3)
created:
5 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!