[SOLUCIONADO] Arreglos, vectores y matrices

[shikamarucb]

Hola todos, tengo una duda, tengo dos formas de crear un vector de "n" elementos, segun tenia entendido c++ no permitia crear un vector de esta forma :

Código C++:

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
 
int main() {
int a,n=0;
cin>>a;
int vec[a];
for(int i=0;i<a;i++){
    vec[i]=n;
    n++;
}
for(int i=0;i<a;i++){
    cout<<vec[i];
    cout.width(5);
}
}
 

Y que solo se podian hacer asi:

Código C++:

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
 
int main() {
int a=0,n,*p;
cin>>n;
p=new int[n];
 
for(int i=0;i<n;i++){
    p[i]=a;
    a++;
}
for(int i=0;i<a;i++){
    cout<<p[i];
    cout.width(5);
}
}
 

De igual modo con las matrices, Agradeceria su ayuda.

[vangodp]

¿Y cual es la duda que tienes?
¿Si tienes que usar la dinámica con las matrices?
Con las matrices bidimencionales la forma es hacer como una especie de tabla de tablas
Se usa puntero que apunta a puntero.Primero se crea el puntero que apunta otro puntero que sera las fila, eso permite guardar otro puntero que sera la columna y por eso debe ser un puntero a puntero. Se usa igual que una matriz bidimensional normal, accediendo de esta forma tabla[10][7] = unvalor;
El ejemplo y la explicación la tienes aquí: http://c.conclase.net/curso/?cap=017#inicio

Código C++:

#include <iostream>
using namespace std;
 
int main() {
    int ** tabla;//"tabla" es un puntero que apunta a un objeto de tipo puntero a int."puntero a puntero"
    int n = 134;
    int m = 231;
    int i;
    
    // Sabemos que un puntero se comporta casi igual que un array, por lo tanto nada nos impide que 
    // "tabla" apunte al primer elemento de un array de punteros:
    tabla = new int * [n]; 
    
    // Ahora estamos en un caso similar, "tabla" apunta a un array de punteros a int, 
    // cada elemento de este array puede ser a su vez un puntero al primer elemento de otro array:
    // n arrays de m ints
    for ( i = 0; i < n; i++ ) {
        tabla[i] = new int[m];
    }
 
    // Ahora tabla apunta a un array de dos dimensiones de n * m, podemos acceder a cada elemento 
    // igual que accedemos a los elementos de los arrays normales:  
    tabla[21][33] = 123;
    cout << tabla[21][33] << endl;
    
    // Otra diferencia con los arrays normales es que antes de abandonar el programa hay que liberar 
    // la memoria dinámica usada, primero la asociada a cada uno de los punteros de "tabla[i]": 
    // Liberar memoria:
    for ( i = 0; i < n; i++ ) { delete[] tabla[i]; }
    
    // Y después la del array de punteros a int, "tabla": 
    delete[] tabla;
    
    return 0;
}//END OF MAIN
 

Es muy importante no olvidar usar el delete después para liberar la memoria antes de terminar la función se suele usar los destructores para que se encarguen de realizar esa tarea por ti cuando uses las clases, usa los destructores para liberar la memoria.

[shikamarucb]

Pues la duda que tengo es que se supone que para crear una matriz de n*m elementos, tengo que crear un puntero doble que apunte a un puntero etc.... Lo que puse ahi es que yo puse 2 formas, una que no utiliza punteros que se supone que no se puede crear asi, no se supone que se tiene que usar la palabra reservada new para generar memoria dinamica y asi poder crear un matriz de n*m o un vector de n elementos?

Iniciado por vangodp

¿Y cual es la duda que tienes?
¿Si tienes que usar la dinámica con las matrices?
Con las matrices bidimencionales la forma es hacer como una especie de tabla de tablas
Se usa puntero que apunta a puntero.Primero se crea el puntero que apunta otro puntero que sera las fila, eso permite guardar otro puntero que sera la columna y por eso debe ser un puntero a puntero. Se usa igual que una matriz bidimensional normal, accediendo de esta forma tabla[10][7] = unvalor;
El ejemplo y la explicación la tienes aquí: [url]http://c.conclase.net/curso/?cap=017#inicio[/url]

Código C++:

#include <iostream>
using namespace std;
 
int main() {
    int ** tabla;//"tabla" es un puntero que apunta a un objeto de tipo puntero a int."puntero a puntero"
    int n = 134;
    int m = 231;
    int i;
    
    // Sabemos que un puntero se comporta casi igual que un array, por lo tanto nada nos impide que 
    // "tabla" apunte al primer elemento de un array de punteros:
    tabla = new int * [n]; 
    
    // Ahora estamos en un caso similar, "tabla" apunta a un array de punteros a int, 
    // cada elemento de este array puede ser a su vez un puntero al primer elemento de otro array:
    // n arrays de m ints
    for ( i = 0; i < n; i++ ) {
        tabla[i] = new int[m];
    }
 
    // Ahora tabla apunta a un array de dos dimensiones de n * m, podemos acceder a cada elemento 
    // igual que accedemos a los elementos de los arrays normales:  
    tabla[21][33] = 123;
    cout << tabla[21][33] << endl;
    
    // Otra diferencia con los arrays normales es que antes de abandonar el programa hay que liberar 
    // la memoria dinámica usada, primero la asociada a cada uno de los punteros de "tabla[i]": 
    // Liberar memoria:
    for ( i = 0; i < n; i++ ) { delete[] tabla[i]; }
    
    // Y después la del array de punteros a int, "tabla": 
    delete[] tabla;
    
    return 0;
}//END OF MAIN
 

Es muy importante no olvidar usar el delete después para liberar la memoria antes de terminar la función se suele usar los destructores para que se encarguen de realizar esa tarea por ti cuando uses las clases, usa los destructores para liberar la memoria.

[vosk]

@shikamarucb: la forma que crees que no se puede usar se llama array de longitud variable, y es aceptada desde C99:

Código C++:

int a;
cin >> a;
int vec[a];
 

El sistema intentará reservarte a*sizeof(int) bytes al momento y la liberará al finalizar el ambito de la variable. El punto en contra de este metodo es que no tienes ninguna forma de saber si el sistema pudo reservar la memoria solicitada, y el problema lo tienes cuando sin haber conseguido reservar memoria intentas trabajar con la variable y provocas un desbordamiento de pila.

Código C++:

int a;
cin >> a;
int vec[a];//no puedes comprovar la reserva
vec[0] = 1;//si hubo un error en la reserva de memoria aqui petará la aplicacion
 

A causa de esto se recomienda usar el new para reservar memoria; en c++ tambien puedes usar malloc para reservar memoria para no-objetos (variables estandar).

Retormando el ejemplo que te puso @vangodp implemento la comprovacion de error en la reserva de memoria:

Código C++:

//con try-catch
try {
    tabla = new int * [n];
}
catch (bad_alloc &e) {
    //error
}
 
//con nothrow
if(!(tabla = new (nothrow) int * [n])) {
    //error
}
 

La comprovacion de reserva tienes que hacerla para cada new, igual que al finalizar tienes que llamar a un delete para cada new.

Saludos
vosk

[vangodp]

//con try-catch
try {
tabla = new int * [n];
}
catch (bad_alloc &e) {
//error
}

Bien señalado ;). Y otra cosa mas: Si ya habías reservado memoria antes, al saltar el error no basta con comprobar, en caso de error había que liberar toda la memoria anteriormente revesada para evitar fugas ya que si el programa se rompe no le iba dar tiempo de llamar a los delete.

[shikamarucb]

Muchas gracias a los dos, ya despeje mis dudas..