¿Cómo convertimos uint8[3] a uint8[]?

Entonces el código es

estructura A {
    uint8[] un;
}

Quiero inicializar Apor A a = A([1,2,3]);. Sin embargo, solc dice que no se puede convertir uint8[3]a uint8[].

En conclusión, estoy buscando una forma de convertir una matriz de longitud fija en una matriz de tamaño dinámico. (sin recrear la matriz por pushn veces)

Respuestas (2)

Esto funciona:

Prueba de contrato {
    estructura A {
        uint8[] un;
    }
    Una;
    A[] muchos;

    prueba de funcionamiento() {
        uno.a = [1, 2, 3];

        muchos.longitud++;
        muchos[0].a = [1, 2, 3];
    }
}

Como nota al margen, para mostrarle el diseño de almacenamiento de una matriz, si tiene este contrato:

prueba de contrato1 {
    uint8[3] un; // Tamaño fijo
    función Prueba1() {
        a = [1, 2, 3];
    }
}

Luego, después de la implementación, obtiene lo siguiente:

> web3.eth.getStorageAt(test1Address, 0) // Ranura 0
"0x00000000000000000000000000000000000000000000000000000000000030201"
                                                             ^^^^^^ 3 valores aquí

Vea cómo los 3 valores se empaquetan justo en la ranura 0.

Por otro lado, si tienes este contrato:

contrato Prueba2 {
    uint8[] un; // tamaño dinámico
    función Prueba2() {
        a = [1, 2, 3];
    }
}

Luego, después de la implementación, obtiene lo siguiente:

> web3.eth.getStorageAt(dirección de prueba2, 0)
"0x00000000000000000000000000000000000000000000000000000000000000003"
// Esa es la longitud de la matriz en la ranura 0
> var arrayLocation = web3.sha3("0x00000000000000000000000000000000000000000000000000000000000000000", {codificación: "hexadecimal"})
// Eso es 0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563 Por cierto
> web3.eth.getStorageAt(test2Address, arrayLocation)
"0x00000000000000000000000000000000000000000000000000000000000030201"

Vea cómo los 3 valores se envían a una ubicación pseudoaleatoria.

Más en Diseño de variables de estado en almacenamiento

No estoy seguro de dónde salió la cuerda. Cuando lo probé, se quejó de int8[] a uint256[], así que modifiqué la estructura para que coincidiera con uint8[]. También tenga en cuenta que definí la longitud de la matriz como 3, por lo que no estamos tratando de forzar una matriz de longitud fija en una matriz de longitud dinámica.

contract test {

    struct A {
      uint8[3] a;
    }

    A a = A([1,2,3]); 

    function getb() returns(uint8[3] whatWeGot) {
        return a.a;
    }
}

Mirando de nuevo tu pregunta principal. Si el objetivo es una matriz de longitud dinámica que comienza con tres valores, entonces inicializaría con push(). Tal vez algo como esto:

contract Test {

    struct Struct {
      uint[] myArray;
    }

    Struct myStruct; 

    function Test()  {
        myStruct.myArray.push(1);
        myStruct.myArray.push(2);
        myStruct.myArray.push(3);
    }

    function getter(uint index) returns(uint value) {
        return myStruct.myArray[index];
    }

}

Debido a que mencionó "cadena", existen algunas diferencias importantes entre bytes y cadenas para este tipo de cosas.

Espero eso ayude.

ups. Gracias por tu respuesta, stringfue un error tipográfico. Y sí, estoy encontrando una manera de convertir una matriz de longitud fija en una matriz de tamaño dinámico. Empujar elementos es básicamente lo que hice en mis contratos... Pero, no parece ser bueno tener...
Estoy casi seguro de que no es posible convertir entre dinámico y fijo y ese es el final de la historia. La experiencia me ha enseñado que a menudo hay una persona inteligente que puede encontrar el camino. Este podría ser uno de esos momentos, así que lo dejé fuera de mi "respuesta". ¿Cuál es la preocupación sobre el empuje?
Usando un ensamblaje en línea, puede convertir una matriz de longitud fija en una dinámica, pero es más legible y no menos eficiente simplemente empujar cada elemento nuevo a su vez.
¿Cómo convertimos uint8[3] a uint8[]?
RespuestasAquíPolítica de privacidad1y, 0v