Передача указателя на динамический двумерный массив в функцию в C++

#include <memory>
#include <cstdio>

template <typename T, size_t rows, size_t cols>
using Matrix = T[rows][cols];

int main()
{
    std::unique_ptr<Matrix<int, 4, 4>> array(new int[1][4][4]);

    for (auto const& row : *array) {
        for (auto const& el : row) printf("%p ", &el);
        puts("");
    }

}

/*

0x59f9040 0x59f9044 0x59f9048 0x59f904c 
0x59f9050 0x59f9054 0x59f9058 0x59f905c 
0x59f9060 0x59f9064 0x59f9068 0x59f906c 
0x59f9070 0x59f9074 0x59f9078 0x59f907c

 */

/*

  total heap usage: 1 allocs, 1 frees, 64 bytes allocated

 */

#include <stdlib.h>
#include <stdio.h>

class MYCLASS
{
 public:
 int val;
 void print()
 {
 printf("%d\n",val); 
 };
} ;

#define WIDTH  3
#define HEIGHT 2

typedef MYCLASS* A[WIDTH][HEIGHT];

void print(A * a , int x,int y)
{
 for(int i=0;i<x;i++)
 for(int j=0;j<y;j++)
 { 
  printf("[%d][%d]",i,j);
  (*a)[i][j]->print();
 }
}

int main(void)
{
 A* a=(A*)malloc(sizeof(void*)*WIDTH*HEIGHT);
 
 for(int i=0;i<WIDTH;i++)
 {
  for(int j=0;j<HEIGHT;j++)
  { 
   (*a)[i][j]=new MYCLASS;
   (*a)[i][j]->val=100*i+j;
  }
 }
 printf("\n");
 print(a,WIDTH,HEIGHT);
 return 0;
}

A* a=(A*)malloc(sizeof(void*)*WIDTH*HEIGHT);

A* a=(A*)malloc(sizeof(A));

#include <malloc.h>
#include <math.h>
#include <stdio.h>

typedef struct { int m, n; double *e; } matrix;

matrix *matrix_create(int m, int n);
void matrix_free(matrix *a);
int matrix_set(matrix *a, int i, int j, double v);
int matrix_get(matrix *a, int i, int j, double *v);

// Создание матрицы
matrix *matrix_create(int m, int n) {

    matrix *a = NULL;
    if (m > 0 && n > 0 && ((a = (matrix *) malloc(sizeof(matrix))) != NULL)) {

        a->m = m;
        a->n = n;
        if ((a->e = (double *) malloc(sizeof(double) * m * n)) != NULL)
        for (int i = 1; i <= m; i++) for (int j = 1; j <= n; j++) matrix_set(a, i, j, 0);
        else { free(a); a = NULL; }
    }
    return a;
}

// Освобождение матрицы
void matrix_free(matrix *a) { free(a->e); free(a); }

// Присвоение значения элементу матрицы
int matrix_set(matrix *a, int i, int j, double v) {

    int ret = i > 0 && j > 0 && i <= a->m && j <= a->n;
    if (ret) *(a->e + (i - 1) * a->n + j - 1) = v;
    return ret;
}

//  Получение элемента матрицы
int matrix_get(matrix *a, int i, int j, double *v) {

    int ret = i > 0 && j > 0 && i <= a->m && j <= a->n;
    if (ret) *v = *(a->e + (i - 1) * a->n + j - 1);
    return ret;
}

// Пример использования
int main(void) {

    double v;
    matrix *a = matrix_create(3, 3);
    matrix_set(a, 1, 1, M_PI);
    matrix_set(a, 2, 2, 2 * M_PI);
    matrix_set(a, 3, 3, M_PI * M_PI);
    for (int i = 1; i <= 3; i++) for (int j = 1; j <= 3; j++) {

        matrix_get(a, i, j, &v);
        printf("%f%s", v, j == 3 ? "\n" : " ");
    }
    matrix_free(a);
    return 0;
}

if (!(a->e = calloc(m * n, sizeof(double)))) { free(a); a = NULL; }

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct { size_t m, n; double e[]; } matrix;

matrix* matrix_create(const size_t m, const size_t n)
{
    matrix *a = NULL;
    if ((a = calloc(sizeof(matrix) + m * n * sizeof(a->e[0]), 1))) {
        a->m = m; a->n = n;
    }
    return a;
}

void matrix_set(matrix *const a, const size_t i, const size_t j, const double v)
{
    assert(i < a->m && j < a->n);
    a->e[i * a->n + j] = v;
}

double matrix_get(const matrix *const a, const size_t i, const size_t j)
{
    assert(i < a->m && j < a->n);
    return a->e[i * a->n + j];
}

#define M_PI 3.14159265358979323846

int main()
{
    matrix *const a = matrix_create(3, 3);
    matrix_set(a, 0, 0, M_PI);
    matrix_set(a, 1, 1, M_PI * M_PI);
    matrix_set(a, 2, 2, M_PI * M_PI * M_PI);

    for (size_t i = 0; i < 3; ++i)
        for (size_t j = 0; j < 3; ++j)
            printf("%f%s", matrix_get(a, i, j), j == 2 ? "\n" : " ");

    free(a);
}

#include <stdlib.h>
#include <stdio.h>

class MYCLASS
{
 public:
 int val;
};

class TROW
{
  int size;
  MYCLASS** cells;
 public:
  
  TROW(int n)
  {
   size=n;
   cells=(MYCLASS**)malloc(sizeof(void*)*n);
   for(int i=0;i<n;i++) cells[i]=new MYCLASS;
  };
  
  MYCLASS*& operator[] (int i)
  {
	 return  cells[i];
  }; 
 };

class TMATRIX
{
 TROW** rows;
 public:
  int row_count;
  int col_count;

  TMATRIX(int n,int m)
  {
   row_count=n;
   col_count=m;
   rows=(TROW**)malloc(sizeof(void*)*n);
   for(int i=0;i<n;i++) rows[i]=new TROW(m);
  };
  
  TROW& operator[] (int i)
  {
	 return  *rows[i];
  };
};

int main(void)
{
 int WIDTH=3;
 int HEIGHT=4;

 TMATRIX m(WIDTH,HEIGHT);
 
 for(int i=0;i<WIDTH;i++)
 for(int j=0;j<HEIGHT;j++)
 {
  m[i][j]->val=(i*100+j);
 }
 
 for(int i=0;i<WIDTH;i++)
 for(int j=0;j<HEIGHT;j++)
 {
  printf("[%d][%d]=%d\n",i,j,m[i][j]->val);
 }
 
 return 0;
}

const int QwMatrixWidth = 20;
const int  QwMatrixHeight = 20;

QwMatrixElement QwMatrix[QwMatrixHeight][QwMatrixWidth];

void QwDrawMatrix(QwMatrixElement** matrix, int n, int m) {

    //Производятся операции над элементами матрицы

}

 row0col0 |  row0col1 | row0col2 |  row1col0 |  row1col1 | row1col2 

// где-то ранее инициализироан int **pp  ;
for (int i = 0; i<rows; i++ ){
		for (int j=0; j<columns; j++) {
			//pp {+X} - указатель на строку
			//*pp {+Y}- указатель на столбец
			//**pp - значение в ячейке
			std::cout << *(*(pp+i)+j) << " " ;
		}
		std::cout << "\n";
	}

#include <iostream>
class CC {
public:
	int aa;
	CC() {aa=10;};
};

void drawCC (CC* cc, int rows, int columns) {	
	for (int i = 0; i<rows; i++ ){
		for (int j=0; j<columns; j++) {
			std::cout << "aa:" << (cc+i*rows+j)->aa+10*i+j << " " ;
		}
		std::cout << "\n";
	}
}

int main(int argc, char **argv)
{

	int rows;
	int columns;	
	std::cin >> rows >> columns ;

	CC cc[rows][columns];
	
	drawCC(reinterpret_cast<CC*> (&cc),rows,columns);
	
	return 0;
}

#define WIDTH  3
#define HEIGHT 2

typedef MYCLASS* A[WIDTH][HEIGHT];

#define WIDTH  3
#define HEIGHT 2
#define HEIGHT_NEW 8

typedef MYCLASS* A[WIDTH][HEIGHT_NEW];

A* a=(A*)malloc(sizeof(void*)*WIDTH*HEIGHT);

#include <stdlib.h>
#include <stdio.h>


class TMATRIX
{
 TMATRIX** rows;
 public:
  int val;

  TMATRIX(int * size)
  {
   int n=size[0];
   size++;
   rows=(TMATRIX**)malloc(sizeof(void*)*n);
   for(int i=0;i<n;i++)
   {
    if(n) rows[i]=new TMATRIX(size); else rows[i]=this;
   } 
  }

  TMATRIX& operator[] (int i)
  {
	 return  *rows[i];
  };
};


int main(void)
{
 int size[4]={2,3,4,0};

 TMATRIX m(size);
 
 for(int k=0;k<2;k++)
 for(int i=0;i<3;i++)
 for(int j=0;j<4;j++)
 {
   m[k][i][j].val=(k*100+i*10+j);
 }

 for(int k=0;k<2;k++)
 for(int i=0;i<3;i++)
 for(int j=0;j<4;j++)
 {
  printf("[%d][%d][%d]=%d\n",k,i,j,m[k][i][j].val);
 }
 
 return 0;
}

#include <array>
#include <numeric>
#include <functional>

template <size_t length, size_t from_end>
struct static_product;

template <size_t length>
struct static_product<length, 1> {
    template <typename T>
    static T result(std::array<T, length> const& array) {
        return array[length - 1];
    }
};

template <size_t length, size_t from_end>
struct static_product {
    template <typename T>
    static T result(std::array<T, length> const& array) {
        return array[length - from_end] * static_product<length, from_end - 1>::result(array);
    }
};

template <typename A, typename... As>
std::array<A, 1 + sizeof...(As)> make_array(A a, As... as) {
    std::array<A, 1 + sizeof...(As)> array = { { a, as... } };
    return array;
}

template <typename T, size_t rank>
struct tensor {

    typedef T value_type;
    typedef std::array<size_t, rank> size;

    const size sizes;

private:

    T *data;

public:

    tensor(size const& sizes_) :
        sizes(sizes_),
        data(new T[std::accumulate(sizes_.begin(), sizes_.end(), 1,
                                   std::multiplies<size_t>())]) {}

    template <typename... As>
    tensor(size_t size, As... sizes_) : tensor(make_array(size, sizes_...)) {}

    ~tensor() { delete[] data; }

    template <size_t>
    size_t toOffset(size_t index) { return index; }

    template <size_t from_end, typename... As>
    size_t toOffset(size_t index, As... indexes) {
        return index * static_product<rank, from_end>::result(sizes) +
               toOffset<from_end - 1>(indexes...);
    }

    template <typename... As>
    T& operator()(As... indexes) {
        return data[toOffset<rank - 1>(indexes...)];
    }
    // ^ Tensor<long, 3> :
    //
    // imulq	8(%rdi), %rsi
    // movq	24(%rdi), %rax
    // addq	%rdx, %rsi
    // imulq	16(%rdi), %rsi
    // addq	%rcx, %rsi
    // movq	(%rax,%rsi,8), %rax
    // ret

    T& get1(size_t index) { return data[index]; }

};

#include <cstdio>
#include <iostream>

int main()
{
    size_t I, J, K;
    std::cin >> I >> J >> K;

    tensor<long, 3> t(I, J, K);

    for(size_t i = 0; i < I; ++i)
        for(size_t j = 0; j < J; ++j)
            for(size_t k = 0; k < K; ++k)
                t(i, j, k) = long(i * 100 + j * 10 + k);

    // t(); <- error
    t(0);
    t(0, 0);
    t(0, 0, 0);
    // t(0, 0, 0, 0); //<- error
    // ...

    for(size_t i = 0; i < I; ++i)
        for(size_t j = 0; j < J; ++j)
            for(size_t k = 0; k < K; ++k)
                printf("t(%ld, %ld, %ld) = %ld (%p)\n",
                       i, j, k, t(i, j, k), &t(i, j, k));
}

#include <stdlib.h>
int main() { return (malloc(0))!=0; }

$ rm a.out;
$ gcc main.c -o a.out;
$ valgrind --leak-check=full ./a.out 2>&1 | grep ERROR
==3490== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 2 from 2)

int (*array)[nCollumns] = new int[nRows][nCollumns];
//Прототип функции:
void f(int (*a)[nCollumns]);
//Удаление
delete[] array;

#include <cassert>
#include <cstddef>
#include <initializer_list>

template <typename T>
class tensor {
public:

    typedef T value_type;
    typedef std::initializer_list<size_t> indexes;

private:

    size_t size;

    union {
        tensor *nested;
        T value;
    } data;

public:

    tensor() : size(0) {}

    tensor(indexes::iterator begin, indexes::iterator end) {
        if (begin == end)
            size = 0;
        else {
            size = *begin;
            data.nested = size ? new tensor[size] : 0;
            for (size_t i = 0; i < size; ++i)
                new (data.nested + i) tensor(begin + 1, end);
        }
    }

    tensor(indexes sizes) : tensor(sizes.begin(), sizes.end()) {}

    ~tensor() {
        if (size) delete [](data.nested);
    }

    tensor& operator[](size_t index) {
        assert(size);
        return data.nested[index];
    }

    T& operator()() {
        assert(!size);
        return data.value;
    }

};

/*
 t[a][b][c]()

 gcc:

	salq	$4, %rsi
	addq	8(%rdi), %rsi
	salq	$4, %rdx
	salq	$4, %rcx
	addq	8(%rsi), %rdx
	addq	8(%rdx), %rcx
	movq	8(%rcx), %rax

 clang:

	shlq	$4, %rsi
	movq	8(%rdi), %rax
	movq	8(%rax,%rsi), %rax
	shlq	$4, %rdx
	movq	8(%rax,%rdx), %rax
	shlq	$4, %rcx
	movq	8(%rax,%rcx), %rax
 */

#include <cstdio>
#include <iostream>

int main()
{
    size_t I, J, K;
    std::cin >> I >> J >> K;

    tensor<long> t{I, J, K};

    for(size_t i = 0; i < I; ++i)
        for(size_t j = 0; j < J; ++j)
            for(size_t k = 0; k < K; ++k)
                t[i][j][k]() = long(i * 100 + j * 10 + k);

    for(size_t i = 0; i < I; ++i)
        for(size_t j = 0; j < J; ++j)
            for(size_t k = 0; k < K; ++k)
                printf("t(%ld, %ld, %ld) = %ld (%p)\n",
                       i, j, k, t[i][j][k](), &t[i][j][k]());
}