15.11.2024

Lição: 031: Arrays Multidimensionais em Solidity

Nesta aula, vamos explorar o conceito de arrays multidimensionais em Solidity, a linguagem de programação usada para desenvolver contratos inteligentes na blockchain Ethereum. Arrays multidimensionais permitem armazenar dados de forma estruturada, possibilitando o trabalho com arrays de arrays. Isso pode ser particularmente útil em várias aplicações, como na gestão de conjuntos de dados complexos.

Compreendendo Arrays Multidimensionais

Um array multidimensional é essencialmente um array que contém outros arrays como seus elementos. Em Solidity, você pode criar arrays de várias dimensões, sendo o mais comum os arrays bidimensionais.

Sintaxe

Para declarar um array multidimensional em Solidity, você precisará especificar o tamanho de cada dimensão. Aqui está a sintaxe geral:

tipo[][] nomeArray; // Para um array bidimensional dinâmico
tipo[tamanhoFixo1][tamanhoFixo2] nomeArray; // Para um array bidimensional de tamanho fixo

Exemplo 1: Array Bidimensional de Tamanho Fixo

Vamos começar com um exemplo simples de um array bidimensional de tamanho fixo que representa uma grade 3x3 de inteiros.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ArrayTamanhoFixo {
    uint[3][3] public grade;

    constructor() {
        // Inicializa a grade com valores
        grade[0][0] = 1;
        grade[0][1] = 2;
        grade[0][2] = 3;
        grade[1][0] = 4;
        grade[1][1] = 5;
        grade[1][2] = 6;
        grade[2][0] = 7;
        grade[2][1] = 8;
        grade[2][2] = 9;
    }

    function obterValor(uint x, uint y) public view returns (uint) {
        return grade[x][y];
    }
}

Neste contrato, declaramos um array bidimensional de tamanho fixo chamado grade do tipo uint. O construtor inicializa a grade com números de 1 a 9. A função obterValor permite que os usuários recuperem valores do array ao especificar os índices da linha e da coluna.

Exemplo 2: Array Bidimensional Dinâmico

Agora, vamos criar um array bidimensional flexível que pode mudar de tamanho dinamicamente.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ArrayDinamico {
    uint[][] public gradeDinamica;

    constructor() {
        // Inicializa um array dinâmico com duas linhas
        gradeDinamica.push([1, 2, 3]);
        gradeDinamica.push([4, 5, 6]);
    }

    function adicionarLinha(uint[] memory novaLinha) public {
        gradeDinamica.push(novaLinha);
    }

    function obterValor(uint x, uint y) public view returns (uint) {
        require(x < gradeDinamica.length, "Índice da linha fora dos limites");
        require(y < gradeDinamica[x].length, "Índice da coluna fora dos limites");
        return gradeDinamica[x][y];
    }
}

Nesta versão dinâmica, usamos uint[][] para permitir um número flexível de linhas e um número variável de colunas em cada linha. A função adicionarLinha permite que os usuários adicionem novas linhas ao array. A função obterValor verifica se os índices fornecidos estão dentro dos limites antes de tentar recuperar um valor.

Exemplo 3: Arrays Multidimensionais com Estruturas

Você também pode criar arrays de estruturas, o que permite a criação de estruturas de dados mais complexas.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ArrayDeEstruturas {
    struct Aluno {
        string nome;
        uint idade;
    }

    Aluno[][] public turmasDeAlunos;

    constructor() {
        // Adicionando turmas iniciais
        turmasDeAlunos.push([Aluno("Alice", 20), Aluno("Bob", 21)]);
        turmasDeAlunos.push([Aluno("Charlie", 22), Aluno("David", 23)]);
    }

    function adicionarAluno(uint indiceTurma, string memory nome, uint idade) public {
        require(indiceTurma < turmasDeAlunos.length, "Índice da turma fora dos limites");
        turmasDeAlunos[indiceTurma].push(Aluno(nome, idade));
    }

    function obterAluno(uint indiceTurma, uint indiceAluno) public view returns (string memory, uint) {
        require(indiceTurma < turmasDeAlunos.length, "Índice da turma fora dos limites");
        require(indiceAluno < turmasDeAlunos[indiceTurma].length, "Índice do aluno fora dos limites");
        Aluno memory aluno = turmasDeAlunos[indiceTurma][indiceAluno];
        return (aluno.nome, aluno.idade);
    }
}

Neste exemplo, definimos uma estrutura Aluno para armazenar o nome e a idade de um aluno. Criamos um array bidimensional dinâmico turmasDeAlunos para armazenar várias turmas de alunos. A função adicionarAluno permite adicionar novos alunos a uma turma específica, enquanto a função obterAluno recupera os detalhes do aluno com base nos índices fornecidos.

Conclusão

Arrays multidimensionais em Solidity oferecem uma forma poderosa de estruturar e gerenciar dados. Ao compreender como criar arrays de tamanho fixo e dinâmico, bem como trabalhar com arrays de estruturas, você pode lidar efetivamente com cenários mais complexos em seus contratos inteligentes. Lembre-se de sempre validar as entradas para evitar erros e garantir a integridade dos seus dados.

Nas próximas aulas, continuaremos a explorar tópicos e recursos avançados em Solidity para aprimorar suas habilidades no desenvolvimento de contratos inteligentes. Boa codificação!

Video

Navigation