C Vetor de varivável em estrutura (Struct)

[ytalopaulo_]

Estou fazendo um projeto de armazenamento de séries e queria saber como resolver o problema de vetor de variável dentro de struct?

Abaixo está a estrutura  do registro!!

typedef struct series{
    char nome[20];
    char genero[20];
    char emissora[20];
    char lanc, assistindo, passistir, finalz, fav;
    int ano;
    int qtdsTemps; 
    int qtdsEps; //era pra ser um vetor de episodios de cada temporada, a partir da qtds informada pela usuário int qtdsEps[qtdsTemps];
    int totalEps;
} SERIE;

 

Como resolveria esse problema já que não pode criar vetor de variável no struct?

[devair1010]

@ytalopaulo_      você pode colocar um valor alto (  1000   ) ,   ali no vetor na struct  ao invés de usar uma variável e  quando for usar em alguma função use normalmente .

[Ansi C]

Dinamicamente, determino quantidade de memória e libero quando não for mais necessário. 

SERIE *cosmos = malloc (sizeof (SERIE));
	cosmos->qtdsEps = malloc (cosmos->qtdsTemps);
/*	A serie tem 1 temporada, sendo assim 1 inteiro é necessário
 *	o primeiro para armazenar a quantidade de temporadas
 *	os próximos para número de episódios por temporada.
 */
	cosmos->qtdsEps[0] = 13;

 

Fica essa sugestão, Entenderam?

 

 

[ytalopaulo_]

Meu professor me mandou fazer a mesma coisa, mas o que eu não entendo é como isso se aplicaria quando o usuário for digital.

Tipo, vai aparece uma mensagem pra o usuário digita a quantidade de temporadas de uma série...  

Ex : 3

Ai as próximas mensagem vai ser em cima desse valor digitado:

->  Quantidades de episódios na 1 temporada: 

->  Quantidades de episódios na 2 temporada: 

->  Quantidades de episódios na 3 temporada: 

_______________________________________

Isso normalmente sem estrutura ficaria resolvido se eu declarasse a variável dos episódios após o usuário digita a quantidades de temporadas da séries 

 qtdsEps[qtdsTemps];

[Ansi C]

Você vai escrever uma função que cria uma serie.

Nela acontece primeiro a alocação de um dado tipo SERIE. Preenche-se os campos na ordem que quiser, exceto os dois campos que estamos nos referindo: Quando chegar no instante deles você primeiro pega a quantidade de temporadas e depois com esse número > 0 o programa alocará o vetor que alberga o número de episódios. Se todo o processo foi bem sucedido retorna a função esse ponteiro com o tipo serie para o bloco que a chamou. 

[isrnick]

Mas no segundo malloc deveria multiplicar pelo tamanho de int, certo?

cosmos->qtdsEps = malloc (cosmos->qtdsTemps * sizeof(int));

 

[Ansi C]

4 minutos atrás, isrnick disse:

Mas no segundo malloc deveria multiplicar pelo tamanho de int, certo?

cosmos->qtdsEps = malloc (cosmos->qtdsTemps * sizeof(int));

 

Melhor é o tipo ser char e não int.

[isrnick]

16 minutos atrás, AnsiC disse:

Melhor é o tipo ser char e não int.

Tem séries que existem a muito tempo e nunca pararam, tem milhares de episódios, mas não são divididos em temporada, logo não vai caber a quantidade de episódios no tipo char.

 

https://en.wikipedia.org/wiki/List_of_television_programs_by_episode_count

[Ansi C]

5 minutos atrás, isrnick disse:

Tem séries que existem a muito tempo e nunca pararam, tem milhares de episódios, mas não são divididos em temporada, logo não vai caber a quantidade de episódios no tipo char.

Se não são divididas em temporadas então, como vai saber o número de temporadas? (é um pergunta retórica). São casos especias, como você mesmo disse tem tipo de serie, basta criar outro tipo para esses casos. Não acho que devo desperdiçar memoria só por causa desse argumento "Tem séries ...". Mas eu entendi o seu ponto de vista, só quero agora que você entenda o meu.

[isrnick]

2 horas atrás, AnsiC disse:

Se não são divididas em temporadas então, como vai saber o número de temporadas? (é um pergunta retórica). São casos especias, como você mesmo disse tem tipo de serie, basta criar outro tipo para esses casos. Não acho que devo desperdiçar memoria só por causa desse argumento "Tem séries ...". Mas eu entendi o seu ponto de vista, só quero agora que você entenda o meu.

 

Entendo, eu escolheria adaptar essas exceções ao modelo, nesse caso a série tem uma única temporada com todos os episódios, mas tem razão de que o tipo int seria desperdício de memória, mas nesse caso eu escolheria usar um tipo com 16 bits como unsigned short int ou uint16_t, que já atenderia todos os casos.

 

No caso de escolher usar o tipo char também seria necessário mudar o tipo de qtdsEps dentro da struct para char.

[Ansi C]

Enfim, um exemplo de como fazer isso é assim (para estruturas com int)

#include  <stdio.h>  /**< Inclua printf; */
#include  <stdlib.h> /**< Inclua malloc, free */


typedef struct Serie Serie;
struct Serie{
    char    nome[20], emissora[20], genero[20];
    char    assistindo, fav, finalz, lanc, passistir;
    int     *qtdsEps, qtdsTemps;
    int     ano, totalEps; };

Serie * criar (void);
void deletar (Serie *s);

int main (int argc, char **argv){
    Serie *s = criar ();
        if (s  !=  NULL){ printf ("Nome: %s\n\n", s->nome); }
        deletar (s);
    return  0; }


Serie * criar (void){
    Serie *n = malloc (sizeof(Serie));
        if (n  ==  NULL){
              puts ("<!> Houve erro ao alocar memória.\a");
              return  n; }

        printf ("*** Dados da Nova Série\n");
        printf (" Nome (19 letras)......: "), scanf (" %19[^\n]", n->nome);
        printf (" Gênero (19 letras)....: "), scanf (" %19[^\n]", n->genero);
        printf (" Emissora (19 letras)..: "), scanf (" %19[^\n]", n->emissora);
        printf ("\n");

        /* ... "outros campos" ... */
        n->qtdsTemps = 0;
        printf (" Temporadas............: "), scanf ("%d", &n->qtdsTemps);
        if (n->qtdsTemps  >  0){
              n->qtdsEps = malloc (sizeof(int) * n->qtdsTemps);
              if (n->qtdsEps  ==  NULL){
                    puts ("<!> Houve erro ao alocar memória.\a");
                    return  n; }}

        n->totalEps = 0;
        for (int q = 0; q  <  n->qtdsTemps; q++){
              printf (" Quantidades de episódios na %d temporada: ", q + 1);
              scanf ("%d", n->qtdsEps + q);
              if (n->qtdsEps[q]  >  0){
                    n->totalEps += n->qtdsEps[q]; }}
    return  n; }


void deletar (Serie *s){
    Serie vazio = { 0 };
        if (s  ==  NULL){ return  ; }
        *s = vazio;
        free (s);
    return  ; }

 

 

[ytalopaulo_]

@AnsiC Obrigado pela a ajuda, funcionou perfeitamente.