validar limite para todas mis funciones

[Micah Genji]

hola a todos

Hoy tengo un problema grave; hasta al momento no tengo la idea especifica de como poder leer el limite de espacio que quiero separar y asi mismo usarlo para cada una de mis funciones a usar:

Código (cpp) [Seleccionar] Expandir

#include<iostream>
#define LIM 3

using namespace std;

int vector_a[LIM][LIM];
int vector_b[LIM][LIM];
int vector_r[LIM][LIM];

int insertar(){
    int fila, columna;
    //vector a
    for (fila=0; fila<LIM; fila++){
        for (columna=0; columna<LIM; columna++){
            cout<<"\nIngrese valor a vector a["<<fila<<"]["<<columna<<"] :";
            cin>>vector_a[fila][columna];
        }
    }
    //vector b
     for (fila=0; fila<LIM; fila++){
        for (columna=0; columna<LIM; columna++){
            cout<<"\nIngrese valor a vector b["<<fila<<"]["<<columna<<"] :";
            cin>>vector_b[fila][columna];
        }
    }
}

int calcular(){
    int fila, columna, aux;
        for(fila=0; fila<LIM; fila++){
                for(columna=0; columna<LIM; columna++){
                    vector_r[fila][columna]=0;
                    for(aux=0; aux<LIM; aux++){
                        vector_r[fila][columna] += vector_a[fila][aux]*vector_b[aux][columna];
                        }
                    }
            }
}

int mostrar(){
    //matriz a
    int fila,columna;
    cout<<"\nVector a: \n";
    for (fila=0; fila<LIM; fila++){
        for (columna=0; columna<LIM; columna++){
            cout<<vector_a[fila][columna]<<"\t";
            if(columna == (LIM-1)){
                cout<<"\n";
            }
        }
    }
    //matriz b
    cout<<"\nVector b: \n";
    for (fila=0; fila<LIM; fila++){
        for (columna=0; columna<LIM; columna++){
            cout<<vector_b[fila][columna]<<"\t";
            if(columna == (LIM-1)){
                cout<<"\n";
            }
        }
    }
    //matriz resultado
    cout<<"\nVector resultado: \n";
    for (fila=0; fila<LIM; fila++){
        for (columna=0; columna<LIM; columna++){
            cout<<vector_r[fila][columna]<<"\t";
            if(columna == (LIM-1)){
                cout<<"\n";
            }
        }
    }
}

main(){
    insertar();
    calcular();
    mostrar();
    cin.get();
}

alguna idea de como hacerlo, por que cada vez pongo un LIM para poder ingresarlo desde teclado tengo errores en STD.

lo que quiero lograr es lo siguiente:

Código (cpp) [Seleccionar] Expandir


...
leer(LIM)
desde i <--0 hasta LIM hacer
         leer (V[i])
fin_desde
...

saludos

[Og.]

No se si entendí bien tu duda, quieres poder hacer que el usuario ingrese el tamaño de las matrices que usaras?
si es así, manteniendo tu código lo mas similar posible seria:

Código (cpp) [Seleccionar] Expandir

#include<iostream>
using namespace std;

int LIM;

int **vector_a;
int **vector_b;
int **vector_c;
int **vector_r;

int insertar(){
   int fila, columna;
   //vector a
   for (fila=0; fila<LIM; fila++){
       for (columna=0; columna<LIM; columna++){
           cout<<"\nIngrese valor a vector a["<<fila<<"]["<<columna<<"] :";
           cin>>vector_a[fila][columna];
       }
   }
   //vector b
    for (fila=0; fila<LIM; fila++){
       for (columna=0; columna<LIM; columna++){
           cout<<"\nIngrese valor a vector b["<<fila<<"]["<<columna<<"] :";
           cin>>vector_b[fila][columna];
       }
   }
}

int calcular(){
   int fila, columna, aux;
       for(fila=0; fila<LIM; fila++){
               for(columna=0; columna<LIM; columna++){
                   vector_r[fila][columna]=0;
                   for(aux=0; aux<LIM; aux++){
                       vector_r[fila][columna] += vector_a[fila][aux]*vector_b[aux][columna];
                       }
                   }
           }
}

int mostrar(){
   //matriz a
   int fila,columna;
   cout<<"\nVector a: \n";
   for (fila=0; fila<LIM; fila++){
       for (columna=0; columna<LIM; columna++){
           cout<<vector_a[fila][columna]<<"\t";
           if(columna == (LIM-1)){
               cout<<"\n";
           }
       }
   }
   //matriz b
   cout<<"\nVector b: \n";
   for (fila=0; fila<LIM; fila++){
       for (columna=0; columna<LIM; columna++){
           cout<<vector_b[fila][columna]<<"\t";
           if(columna == (LIM-1)){
               cout<<"\n";
           }
       }
   }
   //matriz resultado
   cout<<"\nVector resultado: \n";
   for (fila=0; fila<LIM; fila++){
       for (columna=0; columna<LIM; columna++){
           cout<<vector_r[fila][columna]<<"\t";
           if(columna == (LIM-1)){
               cout<<"\n";
           }
       }
   }
}

main(){
   cout << "ingrede el limite: ";
   cin >> LIM;
   vector_a = new int*[LIM];
   vector_b = new int*[LIM];
   vector_c = new int*[LIM];
   vector_r = new int*[LIM];
   for(int i=0;i<LIM;i++)
   {
     vector_a[i] = new int[LIM];
     vector_b[i] = new int[LIM];
     vector_c[i] = new int[LIM];
     vector_r[i] = new int[LIM];
   }
   insertar();
   calcular();
   mostrar();
   cin.get();
   delete vector_a;
   delete vector_b;
   delete vector_c;
   delete vector_r;
}

Saludos!!

[Littlehorse]

Og. estas liberando la memoria en forma incorrecta:

Código (cpp) [Seleccionar] Expandir


for(i=0; i < LIM; i++)
   delete[] vector_x[i];

delete[] vector_x;


Y para Micah Genji, main siempre debe devolver un entero (int main). Evita las declaraciones globales al menos que realmente las necesites.

Saludos

[Micah Genji]

agradezco al aporte a ambos

pero tengo unas dudas, si pueden aclararme:

Código (cpp) [Seleccionar] Expandir

int **vector_a
esta instruccion es acaso: doble puntero.

Código (cpp) [Seleccionar] Expandir

vector_a = new int*[LIM];
-la instruccion new no tengo una idea de que es lo que hace.

agradezco a q me expliquen su forma de uso.

La verdad es que muy poco programo en c++. conozco mas la algoritmia pero en la implementacion estoy pesimo.

Ah Littlehorse gracias por la sugerencia pero casi siempre eh obviado el int. creo que mi teoria dice que esta funcion no retorna algun valor valido, por eso ya ni hago return o estoy equivocado.

Saludos.

[Littlehorse]

Con el operador new reservas memoria dinámica de el heap (malloc en C, por ejemplo).

En el contexto que mencionas, lo que haces es reservar memoria para un arreglo de punteros a entero, y luego recorres dicho arreglo reservando memoria para cada puntero a entero. La liberación de la memoria es el proceso inverso, es decir, liberas lo que reservaste para cada puntero en el arreglo, luego liberas el arreglo de punteros.

Seria algo así:


STACK                 HEAP                      HEAP
  Pila                 Montículo                 Montículo

        new int*[LIM]                   new int[LIM]               
**ptr-----------> arreglo[0]----------->arreglo
                                         new int[LIM]
                        arreglo[1]----------->arreglo
                                         new int[LIM]
                        arreglo[2]----------->arreglo
                           etc                         etc


En cuanto a lo del int. Acorde al estándar la función principal debe devolver un entero. En el estándar actual, ya sea si pones o no pones el return al final, el return 0; esta implícito. Por otro lado el int main debe estar puesto en forma explicita al inicio.

Puede ser que tu teoría diga eso, ya que en estándares anticuados, poner solo main se sobrentendía como int main, pero ahora mismo eso invoca comportamiento indefinido.

Saludos