Problema na compilação de string em C

#include<stdio.h>
#include<string.h>
#define tam 100

typedef struct TipoAluno{
    char *nome;
    char *curso;
    char *cota;
    int matricula;
    int coef;
}TipoAluno;

void GeraArquivo(FILE *arq, TipoAluno vet[tam]){
    int i;
    for (i = 0; i < tam; ++i){
        /* code */
    }
}

int main(){
    FILE *f;
    char *aux;
    TipoAluno *aux2;
    aux2=(*TipoAluno)malloc(sizeof(TipoAluno));
    f=fopen("CadatrosAlunos.txt","a");
    if(f==NULL)
    {
    printf("Ocorreu um erro!");
    }else
    {
    printf("n escreva uma string:");
    scanf("%s",aux);
    printf("n Digite o nome do aluno:");
      scanf("%s",aux2->nome);
    fprintf(f,"%s",aux);
    fprintf(f,"%s",aux2);
    printf("Essa palavra foi escrita no arquivo com sucesso!");
    }
    //poderia usar o tipo rw que é melhor 
    return 0;
}

O primeiro grande erro que você cometeu foi criar uma struct com atribuições nas variáveis, pensa que as structs são como classes tu pode usar mais do que uma vez... Esse é um exemplo que você pode fazer.

Para fazer do jeito que quer é assim:

#include<stdio.h>
#define tam 100

typedef struct {
    char nome[51];
    char curso[51];
    char cota[51];
    int matricula;
    int coef;
} TipoAluno;

int main() {
    TipoAluno aluno = {
        .nome = "A",
        .curso = "B",
        .cota = "C",
        .matricula = 1
    };
    printf("%s", aluno.nome);
}

Veja funcionando no ideone. E no repl.it. Também coloquei no GitHub para referência futura.

Você não pode inicializar a estrutura nela mesma, e nem faz sentido.

É verdade que não se costuma fazer assim em aplicação real. Você está desperdiçando memória. Não que seja errado, na verdade tem casos que é melhor assim porque evita alocação e liberação de memória desnecessária, que é algo que custa caro e que pode gerar erros inadvertidamente. Há quem prefira fazer assim em alguns casos. Para exercício é bom começo fazer assim, mas o mais comum é alocar a string separadamente de acordo com o tamanho necessário.

Então poderia fazer:

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define tam 100

typedef struct {
    char *nome;
    char *curso;
    char *cota;
    int matricula;
    int coef;
} TipoAluno;

int main() {
    TipoAluno aluno = {
        .nome = malloc(2),
        .curso = malloc(2),
        .cota = malloc(2),
        .matricula = 1
    };
    strcpy(aluno.nome, "A");
    strcpy(aluno.curso, "B");
    strcpy(aluno.cota, "C");
    printf("%s", aluno.nome);
}

Veja funcionando no ideone. E no repl.it. Também coloquei no GitHub para referência futura.

O 2 no malloc() é porque a string que será usada tem 1 de tamanho (precisa de mais um para o terminador). Não faria sentido alocar mais do que o necessário.

Note que isso é uma implementação bem ingênua, tem uma série de cuidados para usar corretamente, inclusive quando resolve alterar o valor da string. Alias, ela deveria ser constante, mas não vou tentar resolver todas as questões, não tem porque selecionar alguma para resolver. Isso funciona, e estritamente está correto, mas não é a forma ideal para um código real em produção.

Note também que eu não dei free() em alugar algum, isso faz vazar memória. Para um caso simples assim, não é problema, mas em um programa real precisaria fazer no local e momento adequado, o que não é fácil gerenciar e depende de uma série de fatores.

Na verdade o ideal mesmo aí talvez fosse usar uma union, mas é algo avançado demais e depende dos requisitos, não é algo para um exercício.