Hello, Matrix!

#include <array>
#include <stdio.h>

template <class T, size_t D>
using Matrix = std::array<std::array<T, D>, D>;

// 9'012 инструкций процессора
int main()
{
    constexpr int dim = 3;
    constexpr Matrix<int, dim> matrix{{
        { 1, 2, 3 },
        { 4, 5, 6 },
        { 7, 8, 9 },
    }};

    puts("Printing matrix diagonally");

    for (int r = 0; r < dim * 2; ++r) {
        for (int c = r, tr = 0; c >= 0; --c, ++tr) {
            if (tr < dim && c < dim)
                printf("%i ", matrix[tr][c]);
        }
        puts("");
    }

    return 0;
}

(defun main ()
  (let* ((matrix #2A((1 2 3)
                     (4 5 6)
                     (7 8 9)))
         (min-dim-1 (- (apply #'min (array-dimensions matrix))
                       1)))
    (loop :for i :from 0 :to min-dim-1 
          :collect (aref matrix i i)
            :into d1
          :collect (aref matrix i (- min-dim-1 i))
            :into d2
          :finally (return (values d1 d2)))))

#include <iostream>
#include <sstream>
#include <vector>

class Matrix {
private:
  size_t m_; // количество строк
  size_t n_; // количество столбцов
  std::vector<double> a_; // храним матрицу в одномерном массиве с доступом к i,j элементу как i*n_+j
public:

  // Конструктор, передаём количество строк m и количество столбцов n
  Matrix(size_t m, size_t n)
    : m_(m),  // инициализация m_
      n_(n),  // инициализация n_
      a_(m*n) // инициализация вектора размером m*n
  {} // больше делать нечего

  Matrix(size_t m, size_t n, const std::vector<double> &a)
    : m_(m),
      n_(n),
      a_(a)
  {
    if (a_.size() != m*n)
      a_.resize(m*n);
  }

  // деструктор и т.п. нам реализовывать незачем, "правило нуля" не нарушали.

  // для внешних пользователей класса определим возможность прямого доступа к элементам
  // нарушаем ряд канонов об правилах изменения данных класса, но нам побоку :)
  // не забываем про проверку диапазона
  double& operator() (size_t i, size_t j) { return a_.at(i*n_+j); };

  size_t rows() const { return m_; };
  size_t cols() const { return n_; };

  // это пример использования матрицы внутри класса
  void test() {
    (*this)(1,1) = 100;
  }

  // остальное реализуй по необходимости
};

int main() {

  size_t n = 3;
  Matrix M(n,n,
    { 1.0, 2.0, 3.0,
      4.0, 5.0, 6.0,
      7.0, 8.0, 9.0 });

  std::stringstream ss;

  for (size_t slice = 0; slice < 2 * n - 1; ++slice) {
    ss << "Slice " << slice << ":";
    size_t z = slice < n ? 0 : slice - n + 1;
    for (size_t j = z; j <= slice - z; ++j) {
      ss << " " << M(j,slice - j);
    }
    ss << std::endl;
  }

  std::cout << ss.str();

  return 0;
};