Tengo la siguiente mapping(uint => Foo[])estructura de datos. He mapeado 10 identificadores únicos con 10 estructuras Foo, donde cada Foo es una lista de arreglos de 10 elementos.
Paso 1:
for(int i = 0; i < 10; i++)
for(int j = 0; j < 10; j++)
add(i, j);
Paso 2: elimino los elementos enviados antes. No estoy seguro de cuál es el enfoque correcto entre a) yb) a continuación. El enfoque b) deja huecos restableciendo solo los miembros en la estructura
a) for(int i = 0; i < 10; i++) | b) for(int i = 0; i < 10; i++)
delete(i); | for(int j = 0; j < 10; j++)
| delete_items(i, j)
Paso 3: Empujo nuevos elementos con diferentes ID de uint de mapeo.
for(int i = 20; i < 30; i++)
for(int j = 20; j < 30; j++)
add(i, y);
[Q] ¿Liberaría delete mapping_array[id]realmente la memoria asignada por la lista de arreglos dentro del mapping? ¿O solo pondría a cero la memoria como si deletese usara en Array List, y el elemento permanece mappingvacío, pero aún ocupa espacio en la memoria?
[P] En total, he asignado 10 identificadores únicos con 10 estructuras Foo, donde cada Foo es una lista de matriz de 10 elementos. Más tarde, elimino los elementos en mi mappingestructura de datos y luego inserto nuevos elementos en ella. Entonces, ¿se les asignaría nueva memoria a los elementos recién insertados o se sobrescribirían en la memoria de los elementos eliminados recientemente?
Estos son importantes porque estoy usando una estructura de datos de mapeo de tamaño muy grande y los elementos se insertan y eliminan con frecuencia. Sé que eliminar no liberará memoria en una matriz, pero no estoy seguro de si es lo mismo en el mapeo.
Estoy usando el siguiente código de la respuesta de esta pregunta: https://ethereum.stackexchange.com/a/1458/4575
struct Foo{
uint x;
}
mapping(uint => Foo[]) mapping_array;
function add(uint id, uint _x) public {
mapping_array[id].push(Foo(_x));
}
function get(uint id, uint index) public returns(uint){
return mapping_array[id][index].x;
}
function delete_(uint id) public {
delete mapping_array[id];
}
function delete_items(uint id, uint index) public {
delete mapping_array[id][index];
}
Borrar:
delete a asigna el valor inicial del tipo a a. Es decir, para números enteros es equivalente a a = 0. Para estructuras, asigna una estructura con todos los miembros reiniciados.
delete no tiene efecto en las asignaciones completas (ya que las claves de las asignaciones pueden ser arbitrarias y generalmente desconocidas). Entonces, si elimina una estructura, restablecerá todos los miembros que no sean asignaciones y también recurra a los miembros a menos que sean asignaciones. Sin embargo, las claves individuales y lo que asignan se pueden eliminar.
Es importante borrar a realmente se comporta como una asignación a a, es decir, almacena un nuevo objeto en a.
Enlace: http://solidity.readthedocs.io/en/develop/types.html
Gracias por su valioso tiempo y ayuda.
Basado en mi observación de depuración:
He probado eso:
Este resultado de depuración: me lleva a concluir que la memoria está liberada o que la dirección no contiene información válida.
Código de prueba:
set_txn_hash = my_contract.transact().map_insert();
contract_address = unmigrated_chain.wait.for_receipt(set_txn_hash)
for x in range(0, 9):
for y in range(0, 9):
output = my_contract.call().get_(x, y);
print(output); //returns correct value.
set_txn_hash = my_contract.transact().map_remove_map();
contract_address = unmigrated_chain.wait.for_receipt(set_txn_hash)
set_txn_hash = my_contract.transact().get_map_address(0);
contract_address = unmigrated_chain.wait.for_receipt(set_txn_hash)
output = my_contract.call().get_map();
print(output);
output = my_contract.call().try_();
print(output); //Solidity gives error if delete map_remove_map() is called
Funciones adicionales dentro de mi Contrato:
function map_insert(){
for(uint i = 0; i < 10; i++)
for(uint j = 0; j < 10; j++)
add(i, i*10 + j);
}
function map_remove_map(){
for(uint i = 0; i < 10; i++)
delete_(i);
}
function map_remove_map_item(){
for(uint i = 0; i < 10; i++)
for(uint j = 0; j < 10; j++)
delete_items(i, j);
}
function get_map_address(uint id) {
uint addr;
Foo[] a = foo[id];
assembly{
addr := a
}
map_address = addr;
}
function get_map() constant returns (uint){
return map_address;
}
function try_() constant returns (uint ){
uint addr = map_address;
Foo[] a;
assembly{
a := addr
}
return a[1].x;
}
Badr Bellaj
alper
alper
alper