¿Matriz dinámica en pila?

Question

¿Es esto correcto? Esto se compila con g ++ (3.4) con éxito.

 
int main() 
{ 
    int x = 12; 
    char pz[x]; 
} 

Answer 1

Técnicamente, esto no es parte de C++. Puede hacer arreglos de longitud variable en C99 (ISO/IEC 9899: 1999) pero no son parte de C++. Como ha descubierto, algunos compiladores lo admiten como una extensión.

Answer 2

G ++ admite una característica C99 que permite matrices de tamaño dinámico. No es estándar C++. G ++ tiene la opción -ansi que desactiva algunas características que no están en C++, pero esta no es una de ellas. Para hacer G ++ rechazar ese código, utilice la opción -pedantic:

 
$ g++ -pedantic junk.cpp 
junk.cpp: In function ‘int main()’: 
junk.cpp:4: error: ISO C++ forbids variable-size array ‘pz’ 

Answer 3

Si desea una matriz dinámica en la pila:

void dynArray(int x) 
{ 
    int *array = (int *)alloca(sizeof(*array)*x); 

    // blah blah blah.. 
} 

Answer 4

En términos prácticos, si desea hacer una matriz dinámica se debe utilizar std :: vector, como en:

 
#include <iostream> 
#include <cstdlib> 
#include <vector> 

int main(int argc, char* argv[]) 
{ 
    int size; 
    std::cin>>size; 
    std::vector<int> array(size); 
    // do stuff with array ... 
    return 0; 
} 

Si usted simplemente tiene curiosidad acerca de la sintaxis, a continuación, lo que busca es:

 
//... 
int* array = new int[size]; 
// Do stuff with array ... 
delete [] array; 
//... 

Ninguno de estos se asignan con almacenamiento local. Una matriz de tamaño dinámico que se asigna automáticamente utilizando el almacenamiento local actualmente no es compatible con C++ estándar, pero es compatible con el estándar C actual.

Answer 5

Aquí está tu respuesta combinación de todos estos otros:

Su código en este momento es no estándar de C++. Es es estándar C99. Esto se debe a que C99 le permite declarar matrices dinámicamente de esa manera. Para aclarar, esto también es estándar C99:

#include <stdio.h> 

int main() 
{ 
    int x = 0; 

    scanf("%d", &x); 

    char pz[x]; 
} 

Esta es no nada estándar:

#include <iostream> 

int main() 
{ 
    int x = 0; 
    std::cin >> x; 
    char pz[x]; 
} 

No puede ser de C++ estándar, ya que requiere tamaños matriz constante, y no puede ser C estándar, ya C no tiene std::cin (o espacios de nombres, o clases, etc ...)

Para que sea estándar de C++, haga lo siguiente:

int main() 
{ 
    const int x = 12; // x is 12 now and forever... 
    char pz[x]; // ...therefore it can be used here 
} 

Si desea una matriz dinámica, que puede hace esto:

#include <iostream> 

int main() 
{ 
    int x = 0; 
    std::cin >> x; 

    char *pz = new char[x]; 

    delete [] pz; 
} 

embargo, usted debe hacer esto:

#include <iostream> 
#include <vector> 

int main() 
{ 
    int x = 0; 
    std::cin >> x; 

    std::vector<char> pz(x); 
} 

Answer 6

La asignación de matrices con longitud variable en la pila es un buen idea, porque es rápido y no fragmenta la memoria. Pero el estándar C++ desafortunadamente no lo admite. Puede hacer esto usando el contenedor de plantilla a la función alloca. Pero usar alloca no es realmente un ajuste estándar.

La manera estándar es usar std :: vector con asignador personalizado si desea evitar la fragmentación de memoria y la aceleración de las asignaciones de memoria. Eche un vistazo en boost::pool_alloc para obtener una buena muestra de asignación rápida.