arfneto

void display_queue(queue<string>q); void display_queue(queue<string>q) { while(!q.empty()) { cout << q.front() << " - "; q.pop(); } }  
Pra que isso?
 
A razão de ter um protótipo é colocar isso em outro arquivo. Ou no mínimo deslocar isso para o fim do programa, deixando SEMPRE main() no iniício. O protótipo seguido da função não faz sentido.
 
Sua função display_queue() também faz pouco sentido. Ela sugere mostrar mas na verdade esvazia a fila...
 
E claro que devia ser uma função da classe. Você vê que tem algo errado quando passa a fila como argumento. E está passando por valor. Cuidado com isso. Está copiando a fila todinha. Claro que da segunda vez em diante vai estar vazia
 
cout << "DIGITE 1 para adicionar um novo cliente no final da fila \n"; cout << "DIGITE 2 para remover o cliente do inicio da fila \n"; cout << "DIGITE 3 para imprimir todos os clientes da fila \n"; cout << "DIGITE 4 para imprimir a quantidade de clientes na fila \n"; cout << "DIGITE 5 para excluir os clientes da fila \n";  
Se tem um menu escreva uma função que mostra o menu e retorna a opção. O simples.
 
Não use 5 cout de uma linha. Use um cout de 5 linhas. É como 50x mais rápido. Pra que vai chamar a função uma vez para cada linha?
 
E não use std::endl. Use o simples e recomendado '\n'
 
int x; // ... while (x != 5)  
Isso está errado e o compilador deve ter avisado. Trate todas as mensagens de erro. Leia todas. Habilite TODAS. Como sabe o valor inicial de x? Inicialize todas as varáveis.
 
case 5: { terminate; }  
Pra que chamar terminate aqui e não um simples return? E onde estão os parenteses? std::terminate é uma função e não um comando.
 
 
Claro que como está passado a fla por valor pode esvaziar porque será uma cópia, mas se a fila tiver milhares de registros  vai sair caro. Era mesmo isso que queria fazer? Normalmente em pilhas e filas NÃO existe essa função porque não serve pra nada exceto algum teste. E não é preciso testar a STL em algo tão simples. Numa fila ou pilha não importa o conteúdo. Só o primeiro. E o último no caso da fila. Se precisa de fato listar elementos use uma lista

O cabo MDI comum tem os pinos ligados sequencialmente, 1-1 2-2 até 8-8. Um cabo dito CrossOVER ou MDI-X cruza os pinos 1-3 e 2-6. Hoje em dia (e já há muitos anos) quase todo aparelho é MDI / MDI-X compatível. E isso é o efeito de usar norma A e B cruzada por engano: Se cria um cabo crossover se queria um sequencial ou um sequencial se queria um crossover
 
 
Isso se um dos pinos sem conexão for 4,5,7,8. Apenas nesse caso conecta a 10 ou 100 mbps. Se o defeito for nos pinos 1-2-3-6 não vai ter conexão nenhuma
 
 
Sim. Para essa distância e velocidade provavelmente tanto faz a sequência de cores, desde que ligue os pinos sequencialmente 1-1 2-2 3-3 4-4 5-5 6-6 7-7 8-8.
 
No oficial tem mais metal por m2 nos pares laranja/branco e verde/branco que são destinados a TX e RX, os sinais de dados, e assim se usa a norma A com o verde no pino 2 ou a B com o laranja no pino 2. Se cruzar os pinos só pode ser com TX/RX (1-2 3-6) criando um cabo crossover, como expliquei acima.
 
No simples use pino a pino, a cor sólida sempre no par, 2 para o verde 4 para o azul 6 para o laranja e 8 para o marrom.
 

Você continua insistindo com o que eu te disse pra não fazer 😉 
 
E eu te disse pra mudar ou teria muito trabalho a toa.
 
E o que está acontecendo?
 
Você está tendo muito trabalho. A toa.
 
Que posso dizer mais? 
 
Veja isso:
 
 
 
 
Pois é.
 
Pode escrever como quiser. Mas provavelmente deveria fazer como eu disse.
 
De volta ao código que não compila
 
 
Que seria isso? Qual o tipo de tab_notas? Não pode ser tab_notas...
 
E porque as notas não estão DENTRO de Aluno? Qual o propósito de deixar separado e ter que colocar um campo id para associar um com o outro se um não existe sem o outro? Já falei disso e mostrei um exemplo
 
 
 
 

@Lucas Vaz Lencioni Para uns poucos metros mesmo cat5 está ok. Importa o cabo que está dentro da parede (se tiver algum) porque é sempre mais sujeito a interferências e mais comprido. Esses cabos são chamados genericamente de UTP e o U quer dizer que não são blindados. Claro, sempre teve a versão STP blindada. E isso vale para Cat5E, Cat6, 7 e 8. 7 e 8 em especial mesmo quando não são blindados tem algum isolamento entre os pares.
 
Para testar faça o simples: não mude nada e apenas ligue essa máquina no lugar da outra ao lado que conecta a 1g e veja o que aparece. 

Não tem acesso mas não pode mudar nada? Sabe a faixa de DHCP ao menos? Pode desativar? Usa wifi nessa rede?
 
Eu postei umas coisas sobre isso, alguns posts com números, desenhos e explicação do que pode e sai errado nesse tipo de ligação. Um dos problemas você já sabe: a rede está segmentada. Outros estão na lista.
 
Se achar interessante leia em Configurando Roteadores D-Link Dir 842 e apple - Redes e Internet - Clube do Hardware ou https://www.clubedohardware.com.br/forums/topic/1605208-como-criar-uma-rede-pública-isolado-com-um-segundo-roteador/#comment-8429612
 
Resumo: nunca ligue roteadores secundários pelas portas WAN a  menos que possa desativar NAT no roteador primário. Vai segmentar a rede e muitas coisas não vão funcionar de jeito nenhum e algumas vão funcionar às vezes. Vai ter desconexões por curtos intervalos nas redes internas. E vai perder talvez mais da metade da banda por causa do múltiplo NAT.
 

 
 
 
 
Algum que tenha uma opção como isso da foto podia ser o primário. Mas acho que no seu caso de nada adianta já que não pode trocar esse. E não deveria ter nada exceto roteadores nessa rede.
 

Então...
mostre esse formulário identifique o prazo  gere o código mostre uma janela com o código  

Esses códigos nada tem a ver com rede e nem com o tipo de rede. São simples strings. Texto. Você já tem algum mecanismo para gerar os tais "vouchers". O código QR apenas vai representar isso, o nome da rede e a senha.
 
 
 

"mais simplista" é um critério difícil de entender, ao menos para mim. Não tenho ideia do que seria uma avaliação dessas, mas o que posso dizer grátis sobre o programa de um modo mais objetivo é que
é praticamente um programa C e não C++ e é um desperdício programar assim em C++ o programa não está bom a estrutura de dados mal está presente e a implementação não é boa class Nodo { public: string data; string data2; Nodo* proximo; };  
Trocar struct por class não cria um programa C++. E como tudo no código acima é public seria mais simples deixar struct mesmo.
 
Entenda: a diferença básica entre struct e class em C++ é que na struct tudo é public por padrão. Então é até engraçado usar class desse jeito. 
 
Sobre a fila
 
Está implementando a fila através de uma lista ligada e é o comum. Só que sequer tem uma classe fila. Uma fila é um container, como seria uma pilha, uma lista, um mapa, um conjunto... E seu programa nem tem isso. C++ é talvez a melhor linguagem para criar essas representações --- abstrações é o nome comum --- mas esse código nada fez a respeito.
 
No geral entenda que a fila é de nós. Não é de palavras. Nem de músicas ou livros como é presença comum nas listas de exercícios para iniciantes 😉 . Todos esses containers C++ chamados de coleções em java são de nós. Os nós é que tem os dados ou apontam para eles.
 
Quanto mais longe seu modelo ficar dessa realidade mais trabalho vai ter para criar o programa. E menos o código vai servir para usar em outros programas.
 
E está bem longe aqui. 
 
O simples é ter uma classe fila. A fila tem um começo e um fim. É uma fila. E tem operações. E um número de nós. O simples é isso. 
 
Não tem isso em seu programa e por isso por exemplo deletaNodo() recebe um ponteiro e tem mais 3 ponteiros dentro para a mesma coisa: nós.
 
E append recebe um argumento Nodo** que é um pesadelo de manutenção e tem mais 2 Nodo* dentro...
 
Use protótipos. É muito melhor. Veja a diferença no mesmo programa:
 
#include <iostream> #include <fstream> #include <string> using namespace std; class Nodo { public: string data; string data2; Nodo* proximo; }; void append(Nodo** head_ref, string new_data); void deletaNodo(Nodo* key); void printList(Nodo* Nodo); int main(int argc, char** argv) { fstream arquivo; string palavra; if (argc < 2) { cout << "Faltou passar o arquivo como argumento!\n"; return 1; } // arg 1 é um arquivo com as palavras a ser aberto arquivo.open(argv[1]); if (!arquivo.is_open()) { // Se retornar algum erro: cout << "Erro ao abrir o arquivo!\n"; return 1; } Nodo* head = NULL; // extrai todas as palavras e adiciona a lista: while (arquivo >> palavra) { append(&head, palavra); } cout << "ENTRADA:" << endl; printList(head); /* Aqui é chamada a função que filtra os dados * duplicados */ cout << endl; cout << "RESULTADO REMOVENDO DUPLICADOS:" << endl; deletaNodo(head); // passa o valor alocado no "head" printList(head); return 0; } void append(Nodo** head_ref, string new_data) { // 1. aloca Nodo* new_Nodo = new Nodo(); // usado no passo 5 Nodo* last = *head_ref; // 2. preenche com dados new_Nodo->data = new_data; /* 3. o novo nodo será o último, então o proximo será * NULL*/ new_Nodo->proximo = NULL; /* 4. se a lista encadeada está vazia, faz o novo ser o * início */ if (*head_ref == NULL) { *head_ref = new_Nodo; return; } /* 5. ou percorra até o último nodo */ while (last->proximo != NULL) { last = last->proximo; } /* 6. altera o proximo do útil nodo */ last->proximo = new_Nodo; return; } /* Implemente aqui a funçao que identifica e remove palavras duplicadas */ void deletaNodo( Nodo* key) // pega um valor de ponteiro como chave { Nodo* ptr; // ponteiro fixo Nodo* temp; // comparador Nodo* dup; // valor duplicados ptr = key; // ptr passa a ser "head", já que o ponteiro // "key" recebe head como referência while (ptr != NULL && ptr->proximo != NULL) { temp = ptr; while (temp->proximo != NULL) // se houverem valores no nodo { if (ptr->data == temp->proximo ->data) // se os valores comparados // forem iguais { dup = temp->proximo; // dup recebe o valor // duplicado temp->proximo = temp->proximo ->proximo; // temp pula o valor // duplicado delete (dup); // deleta o duplicado } else // não iguais { temp = temp->proximo; // temp pula para o // proximo nodo e // continua comparando } } // acabem os nodos para "temp->proximo" ptr = ptr->proximo; // fixo passa pro proximo nodo // e começa outra comparação } } // imprime o conteúdo da lista a partir do início recebido void printList(Nodo* Nodo) { while (Nodo != NULL) { cout << " " << Nodo->data; Nodo = Nodo->proximo; } cout << endl; }  
 
Porque é melhor?
 
Simples:
 
class Nodo { public: string data; string data2; Nodo* proximo; }; void append(Nodo** head_ref, string new_data); void deletaNodo(Nodo* key); void printList(Nodo* Nodo);  
esse trecho logo no começo já tem a estrutura e as funções pra você ler e lembrar delas. Tudo junto e não espalhado pelo código.
 
Sobre o código
 
Como eu disse, é um programa C apenas. 
Essas funções deveriam estar na classe não use void use nomes padrão para as operações camelCase é algo de java. Em C++ raramente se usa Remover palavras duplicadas é uma operação a executar em uma fila de palavras. O simples é ter o código de fila normal e ter uma função que recebe o endereço de uma fila e elimina as palavras duplicadas:
 
Algo assim
 
int remove_dup(Fila* fila);  
Isso é o simples. Você lê um arquivo de palavras e cria uma fila e depois remove as palavras duplicadas.
 
Imagine isso ANTES de começar a programar:
 
class Fila{}; Fila* cria_fila(const char* arquivo); int mostra_fila(Fila*, const char*); int remove_dup(Fila*);  
Isso faz a vida simples. Seu programa seria
 
Fila* fila = cria_fila("palavras.txt"); if (fila != nullptr) return -1; // ok criou a fila mostra_fila(fila,"lista original de palavras"); remove_dup(fila); mostra_fila(fila,"lista sem palavras duplicadas"); return 0;  
Sugiro considerar 😉 

No tópico #2 eu já te disse o que estava errado. E como corrigir. E mostrei um exemplo.
 
Você continua com o mesmo programa e erro de antes, e o mesmo resultado de antes.
 
Rodou o programa que eu te mostrei? Entendeu a diferença? Porque não usou o exemplo para mudar seu código?
 
 
Sim, é igual ao outro.
 
 
Você declarou 3 ponteiros. São como envelopes, prontos para ter algo dentro. Ao iniciar com NULL deixa claro que não apontam para nada.
 
Depois aloca uma área do tamanho de um int e coloca o endereço em p2. 
 
Nada faz em relação aos outros 2 ponteiros, e assim quando tenta atribuir um valor na área apontada por p1 seu programa cancela, já que p1 não aponta para nada

Não sei se entendi a pergunta. Afinal você postou as diferenças e aí citou apenas o que é igual, a referência ao nome.
 
typedef cria um nome. Não necessariamente uma estrutura.
 
Uma struct pode ser anônima, como em
 
struct { char nome[40]; int numero; float nota; } aluno;  
ou não, como em seu exemplo
 
struct ficha_aluno { char nome[40]; int numero; float nota; } aluno;  
onde aluno é struct ficha_aluno como seu compilador pode te dizer. Ou o IDE 
 
como nessa figura.
 
E note que o compilador está avisando que você não inicializou a variável...
 
Há uma convenção em C que talvez deva seguir, no sentido de usar a primeira letra em maiúscula para as struct que cria e reservar os nomes em maiúsculas para os #define. É o que espera em toda parte e o que vai ver em todo software open source por exemplo. 
 
EXEMPLO
 
size_t coisa = 0;  
size_t é usado em toda parte em C. Várias funções de stdlib.h esperam isso como argumento.
 
Não por acaso está em vcruntime.h no Windows e veja o que é
 
// Definitions of common types #ifdef _WIN64 typedef unsigned __int64 size_t;  
e que diabo é __int64? É long long.
 
typedef oferece um tipo de encapsulamento também. É muito mais conveniente declarar Aluno como um typedef se vai passar como parâmetro em dúzias de funções, porque não precisa repetir struct TODA vez. E se acabar esquecendo alguma o programa não vai compilar.
 
EXEMPLO
 
Esse programa mostra como é mais conveniente usar typedef
 
#include <stdio.h> typedef struct { char nome[40]; int numero; float nota; } Aluno; struct ficha_aluno { char nome[40]; int numero; float nota; }; Aluno* junta_info(Aluno* um, Aluno* outro) { return NULL; }; struct ficha_aluno* junta_info(struct ficha_aluno* um, struct ficha_aluno* outro) { return NULL; }; int main(void) { Aluno teste = {.numero = 12, .nome = "Jhonny"}; struct ficha_aluno other = {.numero = 2, .nome = "Cash"}; size_t coisa = 0; __int64 x = 0; return (0); }  
Espero que tenha entendido
 
 

@Heitor Brito não vai funcionar. Claro, pode habilitar qualquer coisa mas os pacotes não vão chegar lá. broadcasts também não.

Mas qual é o gateway deles? Veja num dos primeiros qual é o gateway. E se for 241
 
D8-36-5F é o Manufacturer Code da Intelbras. Pode ser o servidor.
 
 
A internet não cai. Nenhum desses dispositivos está conectado com a internet. Mas você tem um servidor DHCP perdido aí --- rogue --- e se por acaso ele responder aos pedidos de endereço antes dos servidores legítimos, os que receberem vão ficar com endereço de gateway inválido. Nada tem a ver com a internet.
 
 

Essa configuração é só para o roteador. A rede do roteador tem que ser acessível porque seu gateway está nela, por definição
 
Eu não tenho esse paricular equipamento, mas acho estranho que se você marcar como está aí no desenho ainda consiga acessar ouras estações, via wifi na rede de convidados. Essa é a definição desse recurso.
 
Sugiro rever.
 
 
De todo modo pode usar as soluções que te expliquei. Se quer algo que possa só ligar na tomada e esquecer pode usar outro roteador com o recurso que te expliquei. Ou usar algo como esses aparelhos que fazem balanceamento de carga (não fazem 😉 ) como o clássico no BR TP-Link TL-R480T+  e o RouterBoard MIKROTIK 750. O segundo tem portas gigabit.
 
E se tem um micro qualquer que possa ficar ligado na primeira rede e que possa ter uma segunda placa de rede pode fazer isso com mais controle  de muitas maneiras diferentes

Esses aparelhos da multilaser tem apenas uma porta lan e uma porta WAN. Então a porta WAN deve estar sempre desconecada e a LAN ligada ao apaelho da vivo ou a um switch local.
Na configuração de DNS dos roteadores multilaser deve estar ou o modem da vivo ou um servidor DNS. Para testar configure um por vez e use os endereços normais da VIVO, 200.204.0.10 e 200.204.0.138 que são quase sempre os que tem menor latência. Ou simplesmente meç usando DNSBench pra confirmar. Esses roteadores sequer permitem especificar o endereço de gateway para o DHCP então usar outros servidores seria mesmo difícil. Mas em geral é bem conveniente. Uma pena Na configuração de WAN dos R060 deixe como PPTP e coloque qqr coisa, para evitar conflitos.

@Alvaro José Masiero Sim, existem. Se tiver portas USB 3 procure adaptadores desse tipo

J. , seu curso adota um livro? Tem alguma apostila? Aprendeu algo sobre tipos de dados por exemplo?
 
Exemplo
 
Esse programa calcula uma média de 5 notas e grava 4 vezes no arquivo. Serve pra ver como construir. Rode em sua maquina.
 
#include <stdio.h> int main(void) { const char* aluno = "Clube do Hardware"; const double nota[] = { 6., 4., 8., 9.5, 10. }; double soma = 0.; int qtd = sizeof(nota) / sizeof(nota[0]); for (int i = 0; i < qtd; i += 1) soma = soma + nota[i]; printf("Aluno: %s\n\tNotas: ", aluno); for (int i = 0; i < qtd; i += 1) printf("%4.2f ", nota[i]); printf("\n\tMedia: %4.2f", soma / qtd); // grava isso 4x no arquivo const char* arquivo = "Nota.txt"; FILE* fp = fopen(arquivo, "w"); if (fp == NULL) { printf("Erro ao tentar abrir o arquivo."); return -1; } for (int i = 0; i < 4; i += 1) { fprintf( fp, "Aluno: %s\n\tNotas: ", aluno); for (int i = 0; i < qtd; i += 1) fprintf( fp, "%4.2f ", nota[i]); fprintf(fp, "\n\tMedia: %4.2f\n\n", soma / qtd); } fclose(fp); return 0; }  
Eis o arquivo gerado
 
Aluno: Clube do Hardware Notas: 6.00 4.00 8.00 9.50 10.00 Media: 7.50 Aluno: Clube do Hardware Notas: 6.00 4.00 8.00 9.50 10.00 Media: 7.50 Aluno: Clube do Hardware Notas: 6.00 4.00 8.00 9.50 10.00 Media: 7.50 Aluno: Clube do Hardware Notas: 6.00 4.00 8.00 9.50 10.00 Media: 7.50  
É uma maneira comum de fazer essas coisas.
 
 
 
 
 
 
 
 

Provavelmente nenhum. Talvez todos. Esses componentes são parte de outras coisas que foram instaladas no micro e podem ou não estar em uso porque essas coisas podem nem estar lá mais.
 
Então pode desinstalar e se aparecer algum problema com algo que usava isso você reinstala.
 
Acho por exemplo que o Real Player, um programa comum, foi escrito em C++ e usa um desses run-time aí. O mesmo para coisas como o Plex, servidor de mídia, o DivX, o SkecthUp de 2D 3D... São componentes desses programas. Mas pelo tamanho não parece ser algo preocupante.

@Pedro Herrmann não é que vira broadcast. É a definição.
Pode usar os 510 hosts ou mesmo subdividir isso e
reagrupar como precisar
Mas todo endereço com todos os bits 1 é um endereço de broadcast e com todos os bits 0 é um endereço de rede

Você pode rodar isso --- OpenVPN --- de graça em qualquer computador de sua rede. Basta instalar o serviço, configurar os certificados e pronto. Não uso há muitos anos mas não deve ter mudado.
E pode usar a versão cloud de graça também, para 3 conexões.
 

Simplesmente leia os vértices a partir de um arquivo. No arquivo digite de acordo com o desenho, claro.
 
Depois disso vai ter a matriz de adjancência e pode usar um métdo de percurso entre 1 e 36 o algoritmo vai te mostrar o melhor caminho.

Provavelmente não vai funcionar como está imaginando 😞 
 
Eis o que acontece: o Huawei está programado para atender até 4 dispositivos nas portas LAN e mais os dispositivos no wifi. É um switch de 4 portas e também um Access Point wifi6. Mas também é um "modem" para acesso a internet. Então ele usa umas tabelas e implementa um prtocolo chamado NAT para compartilhar o único endereço público que ele tem, o tal endereço WAN.
 
Ao ligar seu roteador ao Huawei se usar a porta WAN dele o novo roteador vai fazer a mesma coisa e imlementar NAT de novo. E vai segmentar sua LAN em dois segmentos e criar toda sorte de problemas. E entre eles pode perder at'metade da velocidade nesse lance de duas camadas de NAT e toda a tradução de endereços associada a isso.
 
Como esse aparelho da operadora é moderno e implementa até wifi6 o mais simples para não perder nada é pedir ao provedor a faixa de endereços DHCP que ele usa. É o universo de endereços de rede que ele pode atribuir.
 
Ex: o endereço do Huawei em 192.168.0.1 e o DHCP entre 192.168.0.2 e 192.168.0.254. Isso quer dizer que ele reserva todos os endereços possíveis. Se for de .10 a .199 quer dizer que tem 190 endereços possíveis. Os endereços vão de 0 a 254.
 
Você precisa de um endereço fora da faixa em uso do DHCP para usar em seu novo roteador, e é só isso que tem que pedir a eles.
 
Feito isso: o clássico é usar os endereços seguintes a partir do endereço do Huawei para usar em seus roteadores.
 
Ex: se vai usar mais 2 separe .1 .2 .3 para o huawei e os seus dois roteadores. Ligue o roteador novo no seu pc e programe o endereço de LAN dele para o .2. Desabilite o servidor DHCP dele. Faça o mesmo para todos os roteadores que for usar.
 
Ligue os roteadores via cabo ao Huawei apneas pelas portas LAN. Esqueça a WAN porque só vai isolar a rede e perder perfomance.
 
Assim não vai perder acesso a nenhum deles a partir de qualquer dispositivo ligado em qualquer ponto da rede. E aí configura o wifi como precisar e soma a banda de todos eles. E soma o número de portas LAN nos switch.

@Samuel Bittencourt usando um endereço fixo no IPv4 na configuração de rede do seu micro. Claro, um endereço na rede do seu gateway, o roteador. VIVO em SP usa 192.168.15.1 se você não mudou.

Seu exemplo e descrição são quase a mesma coisa que você tinha escrito antes e não fui capaz de entender nada além do que antes. Eu imaginava algo mais formal. Minha falha.
 
Vou tentar te explicar com um outro exemplo

 
typedef struct{   char *descricao;   void *variavel;   char tipo; }params_t; params_t Params0[]={   {"Tempo restante (seg)", &tempo_restante, FLOAT},   {"Velocidade de execucao (mm/min)", &feed_rate, FLOAT},   {"Temperatura da mesa (graus)", &temper_mesa, FLOAT},   {"Temperatura da extrusora (graus)", &temper_extrusora, FLOAT},   {NULL,NULL,NULL} };
 
Isso está em seu código. params_t não é assim um nome expressivo e depois declarar Params0 e  Params1 como vetores desse tal tipo não ajuda muito também. E note que se `tipo` é `char` não deve usar a última linha como está. `NULL` é `void*` e o compilador vai claro reclamar como você deve ter notado.
 
Se quer um vetor null-terminated basta usar um único NULL
 
params_t Params0[]={   {"Tempo restante (seg)", &tempo_restante, FLOAT},   {"Velocidade de execucao (mm/min)", &feed_rate, FLOAT},   {"Temperatura da mesa (graus)", &temper_mesa, FLOAT},   {"Temperatura da extrusora (graus)", &temper_extrusora, FLOAT},   {NULL} };  
Em relação à estrutura em si considere que    
 
typedef struct {   char *descricao;   void *variavel;   char tipo; } params_t;    Em `C` você declara um nome associando o mesmo a um tipo. No código fonte os espaços são irrelevantes para o compilador. Mas para o leitor entenda que `descricao` é do tipo `char*` `variavel` é do tipo `void*` `tipo` é `char`   o asterisco faz parte do tipo e não do nome. é claro que se `descricao` é `char*` então `*descricao` é `char`. É consequência. É a definição em C, mas não é o que está declarando: está declarando o nome.
 Provavelmente pode abrir mão do tipo e usar uma parte da descrição, como a primeira letra, já que pelo visto nesse caso tinha apenas `float`, `unsigned long` e `unsigned int`. Pode usar os mesmos valores dos `#define` no primeiro byte da descrição por exemplo Quando ao lado genérico disso, `void*` e `char*` são a expressão do genérico em `C`  
Container em C
    
Seja lá o que quer representar parece ser um simples container de estruturas, e deve separar o container do conteúdo. E aí pode usar um array, como fez, uma lista ligada, um mapa, uma pilha, qualquer coisa.
Como vai ter um processamento disso talvez uma implementação de lista fosse bem conveniente porque resolveria as duas coisas: podia usar uma lista de `params_t` para compor uma tarefa e uma fila (lista) para representar os eventos.
 
Um exemplo de uma hierarquia simples
 
Partindo da tal `params_t` como a unidade genérica de trabalho uma abstração simples seria considerar que o programa tem uma Missao composta por  Tarefas que são simples listas de Item. Assim poderia mesmo usar um item, como um sensor, em mais de uma tarefa, monitorando uma família de sensores como unidade e usando os smesmos ensores em outras tarefas.

Para poder cria um log das alterações e reconstruir os dados em caso do programa cancelar podia ter um arquivo de log.
 
typedef struct {     char id_[4];     clock_t ts;      char* descr;// 0 1 3 para uint ulong float      void* val; }   Item; typedef struct {     char    id_[4];     clock_t ts;     char*   descr;     size_t size;     Item*  item; }   Tarefa; typedef struct {     char     id_[4];     clock_t  ts;     char*    descr;     size_t size;     Tarefa*  t; }   Missao;
`_id` facilita a pesquisa pelas coisas, e `ts` é a hora do evento. Bem conveniente já que a hora da última atualização sendo conhecida é o que basta para saber por exemplo o que atualizar num painel ou *dashboard*.
 

O programa é single-thread, roda um único segmento de código. E toda a estrutura é interna ao programa e não parece haver mecanismo de por exemplo algum sensor gravar direto na memória sem o programa "saber". Assim não parece ter razão para espelhar nada. Bastaria saber o que aconteceu depois da última atualização. E sendo single-thread precisa ser repensado para não parar por exemplo na interface de usuário esperando por alguma alteração de descrição.
 
Um arquivo de log permitira voltar no tempo reconstruindo as estruturas e um esquema simples de serialização traria de volta as estruturas do disco e levaria de volta no final
Um event loop é o caminho comum.

@XXMythLuan Você pode resolver as 2 coisas ao mesmo tempo se puder estar lá na hora
 
Pode pedir ao técnico para instalar o modem no quarto onde precisa, passando o cabo pelo mesmo duto onde passaria aquele cabo que comprou. E dizer a ele para passar o cabo de fibra ótica e ap mesmo tempo passar o cabo de rede pelo duto junto com o de fibra ótica, Não tem dificuldade porque o de rede é fino e o de fibra ótica mais fino ainda. E pode tirar o cabo de telefone se tiver um no duo pra deixar tudo vazio mesmo.
 
Pode ser que o técnico não tenha ferramenta ou interesse em terminar o trabalho, mas deixando o cabo já na parede você pode contratar alguém ou fazer isso você mesmo outra hora. Tem conectores RJ45 femea --- acho que da marca Pial entre outras --- para uso doméstico que são instalados sem ferramenta, exceto uma chave de fenda. Eles tem uns furos onde você insere os cabos coloridos nos furos da mesma cor, e uma ranhura de uns 3mm onde você coloca uma chave de fenda e gira 1/4 de volta pra direita e já era.
 
Compra dois desses e você mesmo faz isso outro dia... 
E nesse caso quando der você coloca outro roteador na sala. Ou ao menos leva um cabo de rede para a TV que consome muito do wifi que já vai ficar ruim.

@LucasrodriguesP visual studio
Resumindo: em https://vcpkg.io/en/index.html você instala esse trem que é como se vê pelo nome um gerenciador de pacotes grátis multiplataforma
Instala o visual studio
Roda o vcpkg e uma única  vez na vida dá o comando vcpkg integrate install
Depois pode instalar qualquer pacote que tenha lá de graça e tem mais de 1500. Com uma linha
E ele baixa o pacote e compila tudo em sua máquina. A partir daí todo projeto que abrir tem acesso a todo pacote que instalar. Basta ir usando os óbvios include. Seu programa rodou igualzinho com copiar e collar
No vscode funciona também, usando a integração com o CMake, bem profissional e também multiplataforma, mas no visual studio é mais simples mesmo que use o CMake. 
 
 

@Jefferson Callegaretti Toledo Bateria não é uma boa ideia e não acho que exista algo assim. Compre um adaptador Poe ou um switch. Ou passe um cabo de rede a mais apenas com a tensão DC da fonte do switch