(Resolvido) PROBLEMA COM PASSAGEM DE PONTEIROS PARA FUNÇÃO

[Luis Paulo Silva Pereira]

Galera estou fazendo uma função simples. A função principal passa um valor a outra função que esta calcula os termos da sequencia de fibonacci e devolve os termos em um vetor para a função principal exibir. Qual é o problema que está acontecendo? ai está o código:

#include <stdio.h>
int* fibo (int n);

int main (void)
{
int n1;
int *f;
printf ("Digite um numero: ");
scanf ("%d", &n1);
f = fibo (n1);
for (int i=0; i<n1; i++)
printf ("%d ", f);

return 0;
}

int* fibo (int n)
{
int n1 = 0;
int n2 = 1;
int f[n];
f[0] = n1;
f[1] = n2;

for (int i = 2; i <= n; i++)
{
f = n1 + n2;
n1 = n2;
n2 = f;
}

return (f);
}

[Dan Oliveira]

Eu não dei uma olhada na lógica, mas quando você quer criar um vetor com um tamanho definido pelo usado em tempo de execução você vai usar alocação de memória.

"Mas o que é isso?"

Quando você escreve um programa você tem que especificar tipos, retorno de função, loops... Tudo isso precisa de ter um endereço da memória e um espaço para ser guardado, ou seja seu programa já diz quanto de memória vai precisar para o sistema e ele vai dar. Quando ele for executado ele poderá alterar os valores na memória que foi permitido e previamente declarada. Para usar alguma memória durante o tempo de execução do programa(quando ele está rodando) o sistema oferece um espaço para os programas em que eles possam alocar (alugar) tais blocos de memória.

"E o por quê disso?"

Por mera segurança, se um sistema deixasse o programa ter total controle sobre a memória RAM ele poderia reescrever a memória usada pelo próprio sistema e assim conseguiria fazer qualquer coisa com ele, tipo roubar senha. Você pode pesquisar um pouco como os programas realmente são executados.

Vamos a prática.

A linguagem C oferece uma biblioteca padrão para alocação de memória sujo o arquivo de cabeçalho é stdlib.h. Existe três funções relacionadas a alocação de memória.

void* malloc(size_t size) //aloca um bloco tamanho size na memória

void free(void* ptr) //libera a memória apontada por ptr

void* realloc(void* ptr, size_t size) //realoca um bloco já alocado

O que você tem que saber:

size_t é unsigned int, ou seja não aceita valores negativos então teste para ver se o usuário digita algo entre zero e o maior valor aceito por size_t

void* é o retorno das funções de alocação, ou seja quando você for converter para qualquer tipo você precisa fazer um casting (conversão)

o retorno da função malloc será NULL se ela não conseguir alocar eespaço.

se eu quiser alocar um int faço o seguinte

declaro um ponteiro para int

int* ptr;

e aloco a memória fazendo uma conversão da memória para um int (int)

ptr = (int) malloc(sizeof(int)); //o operador sizeof() especifica quantos bytes(2 ou 4 na maioria) preciso para representar um int

if(ptr = NULL) //não foi alocado a memoria

return 1; //retorna um valor com o código esse um é arbitrário toda vez que o programa retornar ele eu sei q foi problema com a memória

ptr = (int* ) realloc(ptr, 4 * sizeof(int)); //Aqui você realoca a memóriia para suportar um vetor de 4 ints, convertendo então o ponteiro para suportar tal dado

free() é uma função que libera a memeória alocada pelo ponteiro

ou seja

free(ptr); //libera a memória que tinha alocado antes

serve para grande programa, às vezes precisamos de um espaço para determinda tarefa, ou função e como a alocação é válida até quando nosso programa é encerrado temos que liberar o espaço quando não precisamos dele

#include <stdio.h>
#include <stdlib.h>

int* fibo (int n);

int main (void)
{
int n1;
int *f;
printf ("Digite um numero: ");
scanf ("%d", &n1);
f = fibo (n1);
if(f == NULL)
{
printf("Falha ao alocar memória\n");
return 1; //programa finalizado com erro
}
for (int i=0; i<n1; i++)
printf ("%d ", f[i]);
free(f); //libera espaço da memória
return 0;
}

int* fibo (int n)
{
int n1 = 0;
int n2 = 1;
int* f; //ponteiro para um vetor int, equivale a int f[], só que da maneira correta
f = (int* )malloc(n * sizeof(int)); //aqui a um casting dizendo que é um vetor de int
if (f == NULL) //se a alocação deu errada
return NULL;
f[0] = n1;
f[1] = n2;

for (int i = 2; i <= n; i++)
{
f[i] = n1 + n2;
n1 = n2;
n2 = f[i];
}

return (f);
}

Tem outras boas práticas também a ser seguidas, consulte cplusplus.com/reference para saber mais.

Lembrando não analisei sua lógica, só expliquei como trabalhar com alocação, dúvidas fique a vontade para pergunta todos estarão à disposição

[Luis Paulo Silva Pereira]

Obrigado! Funcionou corretamente! Eu não sabia que em tempo de execução teria que ser obrigatoriamente a alocação dinâmica. Achava que era apenas mais uma opção.