Foro de elhacker.net

Buenas ¿puedo hacer esto en c++?

class A
{
private:
          int N;
          int(*p)[N];
public:
          A(int N);
          ~A();
}
 
A::A(int N)
{
          this->N;
          p=new int [N][N];
}
A::~A(){}
 

En caso de que no, ¿como podria hacer una matriz con new que reserve de una vez las NxN celdas y asi me queden todas las celdas juntas (con respecto a la dirección de memoria)?

Salvo que quieras hacer algún "hack" , 1 new y un for para hacer otros new es la solución normal.

Otra opción es reservar NxM elementos, y acceder con la fórmula (siendo 'i' el primer índice y 'j' el segundo): matriz[j + i*N]. Teniendo cuidado con matrices especialmente grandes ya que es más probable que obtengas un error al tratar de encontrar NxMx(sizeof) bytes contiguos (cosa más complicada si lo divides en filas).

En cuanto a eficiencia, si bien compiten bastante (y no olvidando que utilizar varios punteros aumenta mucho la legibilidad), se pueden ver pequeños cambios:

#include <ctime>
#include <iostream>
 
using namespace std;
 
template <typename ...Args>
void test(void(*func)(Args...), const char* text, Args... args){
    clock_t cl = clock();
 
    func(args...);
 
    cout << (clock() - cl) << "ms on: " << text << endl;
}
 
int main(){
    const int N = 1000, M = 1000, TIMES = 1000;
 
    int **mat1;
    int *mat2;
 
    test(+[](int*** mat){
        *mat = new int*[N];
        for(int i = 0; i < N; i++){
            (*mat)[i] = new int[M];
        }
    }, "Initialization 1", &mat1);
 
    test(+[](int** mat){
        *mat = new int[N*M];
    }, "Initialization 2", &mat2);
 
 
    test(+[](int** mat){
        for(int l = 0; l < TIMES; l++){
            for(int i = 0; i < N; i++){
                for(int j = 0; j < M; j++){
                    volatile int k = mat[i][j];
                }
            }
        }
    }, "Loop 1 - 1", mat1);
 
        test(+[](int** mat){
            for(int l = 0; l < TIMES; l++){
                for(int i = 0; i < N; i++){
                    for(int j = 0; j < M; j++){
                        volatile int k = mat[j][i];
                    }
                }
            }
        }, "Loop 1 - 2", mat1);
 
    test(+[](int* mat){
        for(int l = 0; l < TIMES; l++){
            for(int i = 0; i < N; i++){
                for(int j = 0; j < M; j++){
                    volatile int k = mat[j + i*N];
                }
            }
        }
    }, "Loop 2", mat2);
}

Una forma es almacenar los NxN elementos en un arreglo, el elemento de la posicion A(i,j) se almacena en A(i*N+j) y reciprocamente el elemento el la posicion i se encuentra en la fila i div N,
 y en la columna j (mod N)

int* matriz = new int[N * N];
for (int i = 0; i < N * N; i++) {
	int fila = i / N;
	int columna = i % N;
	matriz[fila * N + columna] = valor; // matriz[i] = valor
}

Y la forma tipica usando memoria dinámica:

int** matriz = new int*[N];
for (int i = 0; i < N; i++)
	matriz[i] = new int[N];
for (int i = 0; i < N; i++)
	for (int j = 0; j < N; j++)
		matriz[i][j] = valor;