Entende-se que o tamanho da matriz é definido pelo usuário e esta deve ser alocada dinamicamente usando malloc() em tempo de execução. O processo de criar um modelo na matriz consiste em atribuir aos seus elementos os valores inteiros Nesta aplicação, as matrizes devem ser definidas como tipos de dados int. Isto posto, pede-se que o programador prepare os algoritmos de alocação dinâmica (usando malloc()/free()) para guardar os dados da matriz tridimensional e crie um programa de testes para verificar se a sua implementação foi realizada corretamente de modo a garantir as seguintes condições:
a. O usuário do programa de testes deverá poder fornecer o tamanho da matriz tridimensional que deseja manipular, inserindo as dimensões da altura, largura e profundidade desta.
b. O usuário do programa de testes poderá solicitar a impressão de um dos planos da matriz tridimensional.
c. O usuário do programa de testes poderá modificar o estado de um dos elementos da matriz. Insira no seu código comentários para indicar como as posições da matriz poderão ser acessadas.

Passo 1

Beleza, vamos lá! O que a questão está pedindo é para criar um programa em C que lida com matrizes tridimensionais. A gente vai precisar usar alocação dinâmica de memória com as funções malloc() e free(). O usuário vai poder definir o tamanho da matriz (altura, largura e profundidade), imprimir um dos “planos” dessa matriz e também modificar qualquer elemento dentro dela. Para resolver isso, vamos precisar entender como alocar e acessar memória dinamicamente para uma matriz 3D em C.

Passo 2

Primeiro, vamos entender como criar uma matriz tridimensional usando alocação dinâmica. Em C, uma matriz 3D pode ser pensada como um array de arrays de arrays. Para alocar essa estrutura dinamicamente, usamos malloc() para reservar espaço na memória para cada dimensão.

Passo 3

Vamos começar criando uma função para alocar a matriz tridimensional. Essa função vai receber as dimensões (altura, largura e profundidade) e retornar um ponteiro para o início da matriz.
int ***alocarMatriz(int altura, int largura, int profundidade) {
    int ***matriz = malloc(altura * sizeof(int **));
    for(int i = 0; i < altura; i++) {
        matriz[i] = malloc(largura * sizeof(int *));
        for(int j = 0; j < largura; j++) {
            matriz[i][j] = malloc(profundidade * sizeof(int));
        }
    }
    return matriz;
}
Aqui, primeiro alocamos espaço para a altura, depois para a largura dentro de cada altura, e finalmente para a profundidade dentro de cada largura.

Passo 4

Agora, vamos criar uma função para liberar essa memória quando não for mais necessária. Isso é importante para evitar vazamento de memória.
void liberarMatriz(int ***matriz, int altura, int largura) {
    for(int i = 0; i < altura; i++) {
        for(int j = 0; j < largura; j++) {
            free(matriz[i][j]);
        }
        free(matriz[i]);
    }
    free(matriz);
}
Essa função libera a profundidade primeiro, depois a largura e, por último, a altura.

Passo 5

Vamos agora criar o programa de testes onde o usuário vai poder interagir com a matriz. Primeiro, vamos pedir para o usuário inserir as dimensões da matriz.
#include <stdio.h>
#include <stdlib.h>

// Funções alocarMatriz e liberarMatriz vêm aqui

int main() {
    int altura, largura, profundidade;
    printf("Insira a altura da matriz: ");
    scanf("%d", &altura);
    printf("Insira a largura da matriz: ");
    scanf("%d", &largura);
    printf("Insira a profundidade da matriz: ");
    scanf("%d", &profundidade);
    
    int ***matriz = alocarMatriz(altura, largura, profundidade);
    
    // Inicializando a matriz com valores
    for(int i = 0; i < altura; i++) {
        for(int j = 0; j < largura; j++) {
            for(int k = 0; k < profundidade; k++) {
                matriz[i][j][k] = 0; // Inicializa com zero
            }
        }
    }
    
    // Aqui vai continuar o resto das funcionalidades

Passo 6

Agora, vamos permitir que o usuário escolha imprimir um dos planos da matriz. Um “plano” pode ser, por exemplo, toda uma camada de altura fixada.
    int escolha;
    printf("Deseja imprimir um plano da matriz? (1 para sim, 0 para não): ");
    scanf("%d", &escolha);
    if(escolha == 1){
        int plano;
        printf("Digite o índice do plano que deseja imprimir (0 a %d): ", altura-1);
        scanf("%d", &plano);
        if(plano >= 0 && plano < altura){
            printf("Plano %d:\n", plano);
            for(int j = 0; j < largura; j++) {
                for(int k = 0; k < profundidade; k++) {
                    printf("%d ", matriz[plano][j][k]);
                }
                printf("\n");
            }
        } else {
            printf("Plano inválido.\n");
        }
    }

Passo 7

Por último, vamos permitir que o usuário modifique qualquer elemento da matriz. Para acessar um elemento específico, usamos os índices de altura, largura e profundidade, assim: matriz[i][j][k].
    printf("Deseja modificar um elemento da matriz? (1 para sim, 0 para não): ");
    scanf("%d", &escolha);
    if(escolha == 1){
        int i, j, k, novoValor;
        printf("Digite os índices (altura, largura, profundidade) do elemento a modificar: ");
        scanf("%d %d %d", &i, &j, &k);
        if(i >=0 && i < altura && j >=0 && j < largura && k >=0 && k < profundidade){
            printf("Digite o novo valor: ");
            scanf("%d", &novoValor);
            matriz[i][j][k] = novoValor;
            printf("Elemento modificado com sucesso.\n");
        } else {
            printf("Índices inválidos.\n");
        }
    }
    
    // Liberando a memória alocada
    liberarMatriz(matriz, altura, largura);
    
    return 0;
}

Resposta

Pronto! Com esse programa, você consegue alocar dinamicamente uma matriz tridimensional com os tamanhos que o usuário desejar, imprimir qualquer plano dessa matriz e modificar elementos específicos. Lembre-se sempre de liberar a memória após o uso para evitar problemas. Testa aí e vê se tá tudo funcionando certinho!

Exercícios relacionados