Store some elements of a struct array in another struct array

Question

I have defined a struct array struct CAMPO campo[2] in which it will be pointed out by a pointer struct CAMPO *ptr_campo and that pointer will be aimed at the players inserted in the field, here is the code defined...

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

#define MAX 10
#define MAX_PONTOS 10

typedef struct JOGADOR JOGADOR;
typedef struct CAMPO CAMPO;

struct JOGADOR {
    int num_jogador;
    int pontos;
};

struct CAMPO {
    struct JOGADOR jogadores[MAX];
};

/*novo jogador*/
struct JOGADOR novo_jogador;
/*apontador para  novo jogador*/
struct JOGADOR *ptr_jogador;
/*Array campo jogo e campo prolonagamento*/
struct CAMPO campo[2];
/*apontador para campo jogo e campo prolonagamento */
struct CAMPO *ptr_campo;

/*Prototipos das funções*/
void criar_jogador_no_campo0(void);
void definir_vencedor_ou_empate_jogo(void);
void adicionar_jogadores_empatados_campo1(int, int);
void mostrar_jogadores_no_prolongamento(void);
...
}

in this function creates the player and inserts into the playing field, ie the campo[0]

void criar_jogador_no_campo0(void) {

    int i, j;
    //aponta para campo de jogo
    ptr_campo = &campo[0];

    for (i = 0, j = 0; i < MAX; i++) {
        campo[0] = *(ptr_campo);
        novo_jogador.num_jogador++;
        novo_jogador.pontos = 1 + rand() % MAX_PONTOS;
        ptr_jogador = &novo_jogador;
        campo[0].jogadores[i] = *ptr_jogador;
        *(ptr_campo) = campo[0];
        printf(">> Criar jogador %d com pontos %d no campo[0]...\n",
                ptr_campo->jogadores[i].num_jogador,
                ptr_campo->jogadores[i].pontos);
        j++;
    }

    if (j == MAX) {
        definir_vencedor_ou_empate_jogo();
    }
}

in this function set winning player with the highest number of points or in the event of a tie will go to the prolog field, ie the campo[1]

void definir_vencedor_ou_empate_jogo(void) {

    int j, k, m, t;
    int contador = 0;
    int max = 0;

    puts("\n Determinar o jogador vencedor ou em situação de empate\n");
    //para todos os jogadores
    for (j = 0; j < MAX; j++) {
        //se o jogador listado tiver mais pontos marcados do que max
        if (ptr_campo->jogadores[j].pontos > max) {
            //max = pontos do jogador
            max = ptr_campo->jogadores[j].pontos;
            //contador será igual a um
            contador = 1;
            //se tiver os mesmo pontos que max
        } else if (ptr_campo->jogadores[j].pontos == max) {
            //incrementa o contador
            contador++;
        }
    }//se contador for igual a um
    if (contador == 1) {
        //para todos os jogadores
        for (k = 0; k < MAX; k++) {
            //se o jogador listado tiver mais do que max pontos
            if (ptr_campo->jogadores[k].pontos == max) {
                //o jogador iterado é o vencedor
                printf(">> Jogador %d é o VENCEDOR com %d pontos(s)\n",
                        ptr_campo->jogadores[k].num_jogador,
                        ptr_campo->jogadores[k].pontos);
            }
        }//caso contrário (contador diferente de um)
    } else {
        //iterar todos os jogadores
        for (m = 0; m < MAX; m++) {
            //se os pontos do jogador listado for igual a max
            if (ptr_campo->jogadores[m].pontos == max) {
                //o jogador iterado faz parte do prolongamento
                printf(">> Jogador %d com %d pontos(s) e vai para campo[1]\n", 
                        ptr_campo->jogadores[m].num_jogador,
                        ptr_campo->jogadores[m].pontos);
            }
        }
        puts("\n\t\t--- Lista de Jogadores para campo[1] ---");
        //iterar todos os jogadores
        for (t = 0; t < MAX; t++) {
            //se os pontos do jogador listado for igual a max
            if (ptr_campo->jogadores[t].pontos == max) {
                //o jogador iterado faz parte 
               //da lista de jogadores para prolongamento
                 adicionar_jogadores_empatados_campo1
                       (ptr_campo->jogadores[t].num_jogador, contador);
            }
        }
    }
}

my doubt begins in this function in adding only the tied players in the campo[0] for campo[1], in order to get the winner, kind after tying will go to the extension, only I do not know if it will be necessary,add them to the new field array or do not know well what to ask....

void adicionar_jogadores_empatados_campo1(int num_jogador, int quant_jogador) {

    int j = 0;
    //aponta para campo de prolongamento
    //*(ptr_campo + 1) = &campo[1]; //-> dá erro

    for (int i = 0; i < MAX; i++) {
        if (num_jogador == ptr_campo->jogadores[i].num_jogador) {
            campo[1] = *(ptr_campo + i);
            campo[1].jogadores[i] = ptr_campo->jogadores[i];
            *(ptr_campo + i) = campo[1];
            printf("\t\t\t Jogador %d com %d pontos(s) adicionado no campo[1]\n",
                    (ptr_campo + i)->jogadores[i].num_jogador,
                    (ptr_campo + i)->jogadores[i].pontos);
            j++;
        }
    }

    if (j == quant_jogador) {
        //mostra os jogadores no prolongamento
        mostrar_jogadores_no_prolongamento();
    }
}

in this function will show the added players in the campo[1]

void mostrar_jogadores_no_prolongamento(void) {
    printf("\n\n--- Ponteiro para Campo 1 ---");
    for (int i = 0; i < MAX; i++) {
        //mostra os valores do novo ponteiro
        printf("\nAponta para ->Jogador %d com pontos %d no campo[1]",
                (ptr_campo + i)->jogadores[i].num_jogador,
                (ptr_campo + i)->jogadores[i].pontos);
    }
}

main function

int main(void) {

    criar_jogador_no_campo0();

    return 0;
}

each time I test the program, it shows only that data below, never draws despite testing several times

This doubt is similar to the doubt that was resolved yesterday see link only that yesterday’s post was used a array of integers and in this doubt is used a struct array to store players in different situations

Behold functioning on the ideone.

Answer 1

A first problem with your code is that you are not feeding the seed of the pseudo-random number generator correctly, thus the result of rand will be predictable.

To change the seed value, use the function srand. A good seed is the present time:

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

int main(void) {

    srand((unsigned int)time(NULL));

    criar_jogador_no_campo0();

    return 0;
}

Additionally, there is confusion about pointers in functions adicionar_jogadores_empatados_campo1 and mostrar_jogadores_no_prolongamento.

A pointer to the extension field can be obtained as follows:

struct CAMPO *ptr_campo_2 = ptr_campo + 1;

Using this pointer you can rewrite your function as follows:

void adicionar_jogadores_empatados_campo1(int num_jogador, int quant_jogador) {

    int j = 0;

    for (int i = 0; i < MAX; i++) {
        if (num_jogador == ptr_campo->jogadores[i].num_jogador) {
            ptr_campo_2->jogadores[i] = ptr_campo->jogadores[i];
            printf("\t\t\t Jogador %d com %d pontos(s) adicionado no campo[1]\n",
                    ptr_campo_2->jogadores[i].num_jogador,
                    ptr_campo_2->jogadores[i].pontos);
            j++;
        }
    }
    // O maior valor possível de j eh quant_jogador - 1
    if (j + 1 == quant_jogador) {
        //mostra os jogadores no prolongamento
        mostrar_jogadores_no_prolongamento();
    }
}

Of course you can also get the pointer to the extension field from the address of the game field with the expression (ptr_campo + 1), so you could rewrite your role mostrar_jogadores_no_prolongamento thus:

void mostrar_jogadores_no_prolongamento(void) {
    printf("\n\n--- Ponteiro para Campo 1 ---");
    for (int i = 0; i < MAX; i++) {
        //mostra os valores do novo ponteiro
        printf("\nAponta para ->Jogador %d com pontos %d no campo[1]",
                (ptr_campo + 1)->jogadores[i].num_jogador,
                (ptr_campo + 1)->jogadores[i].pontos);
    }
}

But if you already have a pointer to the extension field there is no reason to repeat pointer arithmetic. Just use the original pointer:

printf("\nAponta para ->Jogador %d com pontos %d no campo[1]",
         ptr_campo_2->jogadores[i].num_jogador,
         ptr_campo_2->jogadores[i].pontos);