c++ - una - variables en lenguaje c

¿Es posible crear dinámicamente una matriz de tamaño constante en C++?

Question

En primer lugar, quiero asegurarles que estoy haciendo esta pregunta por curiosidad. Quiero decir, no me digas que si necesito esto, entonces mi diseño tiene problemas porque no lo necesito en código real Espero haberte convencido :) Ahora a la pregunta:

Para la mayoría de los tipos T podemos escribir

T* p = new T;

¿Y ahora si T es un tipo de matriz?

int (*p)[3] =  new ???; //pointer to array of 3 = new ???

Intenté esto:

typedef int arr[3];
arr* p = new arr;

pero esto no funciona.

¿Hay alguna sintaxis válida para esto o es imposible en C ++? Si es imposible, entonces ¿por qué? Gracias

Edición : supongo que no estaba lo suficientemente claro. Quiero poder usarlo en esta situación:

void f(int(&)[3]);
int (*p)[3] = new ???;
f(*p);

Answer 1

La razón por la que no puede hacerlo es que new int[3] ya asigna exactamente lo que desea, un objeto de tipo int[3] . Es solo que lo que devuelve la nueva expresión es un puntero a su primer elemento. 5.3.4 / 1:

Si la entidad no es un objeto de matriz, la nueva expresión devuelve un puntero al objeto creado. Si es una matriz, la nueva expresión devuelve un puntero al elemento inicial de la matriz.

Devolver un puntero al primer elemento es lo que permite que los 3 sean desconocidos hasta el tiempo de ejecución, por lo que supongo que al saberlo de antemano, ha tropezado con la flexibilidad que no está utilizando.

Supongo que la forma de evitar esto es volver a interpretar de nuevo el tipo de puntero que desee (no necesariamente portátil), o asignar una estructura que contenga un int[3] (y usar un puntero a su miembro de datos).

[Editar: er, yeah, o la idea de FredOverflow, que no tiene ninguna desventaja, pero requiere el uso de delete[] lugar de delete .]

Supongo que la moraleja es que si escribes plantillas que ingenuamente asignan algún tipo T desconocido con el new , la plantilla no funcionará cuando alguien pase un tipo de matriz como T Lo asignará al tipo de puntero incorrecto, y si lo arregla (tal vez con auto ), lo eliminará incorrectamente.

Editar en respuesta a la pregunta de j_kubik:

Aquí hay una forma de distinguir entre tipos de matriz y no de matriz. Si escribe una función como esta, que devuelve un objeto que contiene el puntero y es capaz de eliminarlo correctamente, entonces tiene un nuevo genérico / eliminar para cualquier tipo T.

#include <iostream>

template <typename T>
void make_thing_helper(T *) {
    std::cout << "plain version/n";
}

template <typename T, int N>
void make_thing_helper(T (*)[N]) {
    std::cout << "array version/n";
}

template <typename T>
void make_thing() {
    make_thing_helper((T*)0);
}

int main() {
    typedef int T1;
    typedef int T2[3];
    make_thing<T1>();
    make_thing<T2>();
}

Answer 2

Para obtener un puntero a una matriz desde new , debe asignar dinámicamente una matriz bidimensional:

int (*p)[3] = new int[1][3];

Answer 3

Siempre se puede usar boost :: array, que estará en C ++ 0x. De lo contrario, cualquier solución será incómoda en el mejor de los casos: las matrices se dividen en C, y C ++ mantiene la compatibilidad con C a este respecto. Fred Overflow ofreció una solución; incluso más fácil (pero sintácticamente ruidoso) sería envolver la matriz en una estructura: estructura A {int arr [3]; }; y asignar y manipular esto.

Answer 4

Tu solo haces

int *p = new unsigned int [3]

Luego puede usar *p como un puntero o una matriz, es decir *(p+1) or p[1]