Strange values in output when running newly compiled application

Question

When I compile and execute this code on Linux, it shows a strange result. I believe it is memory junk. What is happening for it to show this result, and how I can solve?

Command lines to compile code

gcc -c aluno.c
gcc -c test.c
gcc test.o aluno.o -o test.bin

Upshot

Student file. h

/* TAD: Aluno (matricula, nome, curso) */
typedef struct aluno Aluno;

/* Aloca e retorna um aluno com os dados passados por parâmetro */
Aluno *novo(int matricula, char *nome, char *curso);

/* Libera a memória de um aluno previamente criado */
void libera(Aluno *aluno);

/* Copia os valores de um aluno para as referências informadas */
void acessa(Aluno *aluno, int *matricula, char *nome, char *curso);

/* Atribui novos valores aos campos de um aluno */
void atribui(Aluno *aluno, int matricula, char *nome, char *curso);

/* Retorna o tamanho em bytes do TAD aluno */
int size(); 

Student file. c

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


typedef struct aluno{
    int matricula;
    char nome[50];
    char curso[20];
}Aluno;

Aluno *novo(int matricula, char *nome, char *curso){
    Aluno *a;
    a=malloc(sizeof(Aluno));
    a->matricula=matricula;
    strcpy(a->nome,nome);
    strcpy(a->curso,curso);

}

void libera(Aluno *aluno){
    free(aluno);
}

void acessa(Aluno *aluno, int *matricula, char *nome, char *curso){
    matricula=(int*)&aluno->matricula;
    nome=(char*)&aluno->nome;
    curso=(char*)&aluno->curso;
}

void atribui(Aluno *aluno, int matricula, char *nome, char *curso){
    aluno->matricula=matricula;
    strcpy(aluno->nome,nome);
    strcpy(aluno->curso,curso);
}

int size(){
    return (int)sizeof(Aluno);
}

File test. c

int main()
{
    Aluno *a;
    a=malloc(sizeof(size()));
    a=novo(123,"victhor","computacao");

    int *matricula;
    char *nome, *curso;

    acessa(a,matricula,nome,curso);

    printf("Matrícula: %d\n",*matricula);
    printf("Nome: %s\n", nome);
    printf("Curso: %s\n", curso);
    return 0;
}

Answer 1

The code has several problems. Some are organizing and I haven’t solved them all. I wouldn’t use this function acessa, at least this way is not useful, it may be later changed to be more useful. With the warnings suitable linked and they should be linked to help find the problems, this code would not even compile.

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

typedef struct aluno {
    int matricula;
    char nome[50];
    char curso[20];
} Aluno;

Aluno *novo(int matricula, char *nome, char *curso) {
    Aluno *a = malloc(sizeof(Aluno)); // o ideal é receber o espaço já alocado
    a->matricula = matricula;
    strcpy(a->nome, nome);
    strcpy(a->curso, curso);
    return a; //não tinha return aqui
}

void libera(Aluno *aluno) {
    free(aluno);
}

void acessa(Aluno *aluno, int *matricula, char *nome, char *curso) {
    *matricula = aluno->matricula; //não estava jogando o dando em um ponteiro
    strcpy(nome, aluno->nome); //não estava copiando uma *string* para a outra
    strcpy(curso, aluno->curso);
}

void atribui(Aluno *aluno, int matricula, char *nome, char *curso) {
    aluno->matricula = matricula;
    strcpy(aluno->nome, nome);
    strcpy(aluno->curso, curso);
}

int size() {
    return (int)sizeof(Aluno);
}

int main() {
    Aluno *a = novo(123, "victhor", "computacao"); //simplifiquei e não aloquei de novo
    int matricula; //o dado não é um ponteiro
    char nome[50], curso[20]; //reserve o espaço para a *string*
    acessa(a, &matricula, nome, curso); //aqui manda o endereço da variável
    printf("Matrícula: %d\n", matricula);
    printf("Nome: %s\n", nome);
    printf("Curso: %s\n", curso);
}

Behold working in the ideone. And in the repl it.. Also put on the Github for future reference.