[Dúvida] Declaração implícita

Olá Natan!

A função "malloc" retorna um ponteiro vazio (void*), por isso para alocar memória com ela deve-se fazer um "cast" no retorno da função.

#include <stdio.h>
#include <stdlib.h> //para utilizar "malloc()"

    char** dinamica;
    int linhas = 5;
    int colunas = 10;

int main(){
    
    //"dinamica" é um ponteiro de ponteiro (char** ) logo foi feito o 
    //cast "char**"
    
    dinamica = (char**)malloc(sizeof(char*) *linhas);

    for(int i = 0; i < linhas; i++){
    
        //dinamica[] é um "char*", logo foi feito o cast
    
        dinamica[i] = (char*)malloc(sizeof(char) * (colunas+1));
    }

    for(int i = 0; i < linhas; i++){
        free(dinamica[i]);
    }
    free(dinamica);
}

Nota: para utilizar "malloc" é necessário incluir a biblioteca "stdlib.h".

Qualquer dúvida, estou a disposição :)

Bons estudos!

O que é cast?

Realizar um "cast" é converter o retorno de uma operação, de maneira explicita, para outro tipo de dado. Vou dar um exemplo.

#include <iostream>

int main()
{
    int i = 5; //inteiro
    int n = 2; //inteiro
    
    float z; //note que 'z' é 'float'
    
    //vamos dividir dois inteiros e armazenar o valor em um float
    z = i / n;  // z = 5/2;
    
    //o resultado esperado de 5/2 = 2.5
    //então pela lógica esse deveria ser o valor de 'z';
    
    //vamos ver:
    std::cout << z << std::endl;

    //saida :  2

    return 0;
}

O retorno da operação '5/2' que deveria resultar em '2.5', mas resultou na verdade em '2'. Mas pq?

quando o programa realiza uma operação com dois números inteiros, ele espera receber um número inteiro como resultado, mesmo q a variável que recebe esse resultado possa armazenar numeros com "ponto flutuante".

Como resolver?

Para converter o valor de uma operação é utilizado o "cast" (um forma de conversão explicita). Veja o mesmo programa, mas com o cast:

#include <iostream>

int main()
{
    int i = 5; //inteiro
    int n = 2; //inteiro
    
    float z; //float
    
    z = (float)i / n;
    
    //agora com o cast, o retorno de dois inteiros será um 'float'

    //note a nova saida:
    std::cout << z << std::endl;

    //saida :  2.5

    return 0;
}

O cast foi feito de maneira explicita. Vale lembrar q o cast pode gerar perca de dados se for feito de maneira indevida, por exemplo:

• um float para um int, o numero vai perder os dados a partir do ponto flutuante.
• double para float. double oculpa 8bytes e float 4bytes, logo pode haver perca ao realizar cast de uma variável maior para uma menor.

Extra: todos os caracteres presentes no computador são na verdade representações numéricas, ou seja, cada caractere tem seu número em inteiro. Vc pode conferir isso na tabela ASCII.

https://web.fe.up.pt/~ee96100/projecto/Tabela%20ascii.htm (tabela ASCII)

O legal é que vc pode converter int em char e vice-versa para obter o caracter e valor do mesmo respectivamente:

veja:

#include <iostream>

int main()
{
    int numero = 97; //97 é o 'a' na tabela ascii
    char caractere = '#'; // # é o 35 da tabela ascii
    
    
    std::cout << (char)numero << std::endl; //cast de um int para char
    std::cout << (int)caractere << std::endl; //cast de um char para int
    
    /*saida:
        a
        35
        
        
    */
    
    return 0;
}

Como a função "malloc" retorna um ponteiro vazio (void*), por isso para alocar memória com ela deve-se fazer um "cast" no retorno da função para o valor do tipo do ponteiro desejado.

Qualquer outra dúvida estou a disposição! Bons estudos :)