La asignación de vectores se bloquea, no estoy seguro de por qué

vector< vector > resizeVector(vector< vector > m) { vector< vector > newMatrix; int i,j; for (i = 0; i < m[i].size(); i++) { for(j = 0; j < m[j].size(); j++) { newMatrix[i][j] = m[i][j]; } } return (newMatrix); } 

Estoy haciendo un progtwig que hará un montón de manipulación de matrices, y esta sección se está estrellando y no sé exactamente por qué. Lo he reducido a la línea:

 newMatrix[i][j] = m[i][j]; 

Se estrella justo aquí, y no estoy seguro de por qué.

Además de lo que @Saurav publicó, newMatrix está vacío, por lo que no puede asignar valores a newMatrix[i][j] . Puedes arreglar esto al inicializar los vectores con un tamaño dado:

 vector< vector > resizeVector(vector< vector > m) { vector< vector > newMatrix(m.size()); int i,j; for (i = 0; i < m.size(); i++) { newMatrix[i].resize(m[i].size()); for(j = 0; j < m[i].size(); j++) { newMatrix[i][j] = m[i][j]; } } return (newMatrix); } 

Antes de los bucles for, inicializamos newMatrix para tener m.size() muchos vectores vacíos dentro de él (los vectores están vacíos debido a su constructor predeterminado). Durante cada iteración del bucle for externo, nos aseguramos de que cada vector dentro de newMatrix tenga el tamaño correcto utilizando la función miembro de cambio de resize .

Tenga en cuenta que si desea una copia de un vector, simplemente puede escribir:

 vector< vector > newMatrix(m); 

Tus cheques están mal. En su lugar debería ser

 for (i = 0; i < m.size(); i++) // m.size() gives the number of rows { for(j = 0; j < m[i].size(); j++) // m[i].size() gives the number of columns in the row 

Usted está asignando a su nuevo nuevo newMatrix sin configurar primero su tamaño. Se vaciará por defecto, y cualquier bash de asignarlo dará como resultado un comportamiento indefinido.

Dado que no se pasa un nuevo tamaño, es difícil saber exactamente lo que está tratando de lograr. Es por eso que no tengo consejos más explícitos sobre cómo solucionarlo.

Si desea asignar vector de vector, debe asignar memoria para la matriz antes de indexarla. Así que tendrás que usar algo como

 newMatrix.resize(size); for (int i = 0; i < size; ++i) { newMatrix[i].resize(size); } 

O puede usar el método de vector .push_back () para agregar valores al vector sin asignar memoria de antemano.

El operator[] vector s operator[] devuelve una referencia al elemento especificado sin verificación de límites.

Eso significa que no cambia mágicamente el tamaño del vector, ni realiza ninguna otra operación para asegurar que el elemento exista. Si el elemento no existe, el resultado es un comportamiento indefinido, lo que significa que cualquier cosa puede suceder. En la práctica, a menudo hace que el progtwig acceda a una ubicación de memoria no válida, lo que provoca un locking.

Lo anterior es cierto incluso para un vector simple vector . Has agravado tus problemas al trabajar con un vector > (Cada elemento de un vector > es un vector ).

Su función es realmente un poco impresionante en el número de veces que potencialmente invoca un comportamiento indefinido. newMatrix[i][j] = m[i][j] que se newMatrix[i][j] = m[i][j] un locking en la statement newMatrix[i][j] = m[i][j] , pero el potencial de comportamiento indefinido en realidad ocurre antes de esa fecha.

En el bucle externo, m[i] no existirá si m.size() (que su código no verifica) tiene un valor cero. Si m.size() es cero, eso hace que la evaluación de m[i] (como m.operator[](i) ) tenga un comportamiento indefinido.

Esencialmente, debe asegurarse de que cualquier índice i sea ​​válido antes de evaluar m[i] , y TAMBIÉN debe asegurarse de que j sea ​​un índice válido de m[i] antes de evaluar m[i][j] . Y luego hacer lo mismo para newMatrix . Tu código no hace nada de esto en absoluto. Una representación más correcta de su función (suponiendo que la intención es crear una copia de m ) es

 vector< vector > resizeVector(vector< vector > m) { vector< vector > newMatrix; int i,j; newMatrix.resize(m.size()); // necessary to ensure we can access newMatrix[i] in the loop below for (i = 0; i < m.size(); i++) // ensure i is a valid index of m { // newMatrix[i].size() is still zero, so we need to resize for use in the inner loop newMatrix[i].resize(m[i].size()); for(j = 0; j < m[i].size(); j++) // ensure j is a valid index of m[i] { newMatrix[i][j] = m[i][j]; } } return (newMatrix); } 

Ahora, la cosa es que su código en realidad está recreando la funcionalidad que proporciona vector ya. Entonces, podríamos reemplazar el cuerpo de la función de manera bastante simple con

 vector< vector > resizeVector(vector< vector > m) { vector< vector > newMatrix(m); return newMatrix; } 

o incluso con

 vector< vector > resizeVector(vector< vector > m) { return m; } 

Esto significa que su función (como la he modificado) tiene un nombre erróneo, no cambia el tamaño de nada. De hecho, es bastante inútil ya que, si la persona que llama hace esto

 x = resizeVector(y); 

podría lograr el mismo efecto sin su función, simplemente como

 x = y; 

que también es más eficiente (sin llamada de función, sin crear copias para pasar por valor, etc.).