arfneto

o que fez você escrever essa linha?
 
Sabe o que é time()? É exatamente o que perguntou...
 
strftime() formata como preferir. Leu alguma documentação, por exemplo do header  ctime que incluiu em seu programa?
Eis um exemplo, direto de CPlusPlus.com, que é um site que você deveria frequentar. Todo mundo faz isso, de iniciantes a especialistas
 
/* strftime example */ #include <stdio.h> /* puts */ #include <time.h> /* time_t, struct tm, time, localtime, strftime */ int main () { time_t rawtime; struct tm * timeinfo; char buffer [80]; time (&rawtime); timeinfo = localtime (&rawtime); strftime (buffer,80,"Now it's %I:%M%p.",timeinfo); puts (buffer); return 0; }  
Isso compila em C e C++ mas não use como argumento para achar que essas linguagens são a mesma coisa. São absolutamente diferentes animais. Se trocar time.h for ctime vai ter as mesmas funções...

A janela do IDE é um ambiente infeliz pra você mudar qualquer coisa que afete o ambiente.
Não precisa do Terminal, mas considere que vale a pena: programas de console escritos para o terminal rodam igual no Windows e no MAC. Linux, Unix e nas olimpíadas. Ok, talvez não nessa última. E rodam muito mais rápido, já que usam aceleração da placa de vídeo. A Microsoft avisa há anos para que não se use mais a tal console dos anos 80. Mas é uma mudança grande se você usava Windows e a console desde sempre. E um passeio se você usava Unix ou derivados
 
Se você mudar algo e der erro no meio do caminho vai zoar a configuração da janela do IDE para todos os programas que vem depois desse. E se não der erro e você não voltar para o original pode ter surpresas...
 
Em resumo: meu palpite: deixe uma janela do terminal aberta na pasta onde está gerando seu programa no IIDE e teste nessa janela. Pode ter várias abertas na mesma janela e se uma dá pau as outras estarão lá... Não demora nada mais. E se vai usar o debugger então use o próprio sistema para  ver se alterou a fonte ou não. Eu devo ter escrito isso no exemplo, a menos que eu estivesse com muita pressa  

 

Pois é: estava escrito lá no tópico.... Vi agora...
 
 
tem esse fragmento de um programa que salva e restaura essas coisas, é parte de algo que funciona mas de que não me lembro mais. Veja:
 
_cs_status* guarda(_cs_status* antes) { antes->cp_original = GetConsoleCP(); antes->ocp_original = GetConsoleOutputCP(); strcpy(antes->local_original, setlocale(LC_ALL, NULL)); HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE); char buffer[80]; char* pBuffer = buffer; int res = 0; res = GetCurrentConsoleFont(h, 0, &(antes->font_info)); // pois e: mas qual a fonte? Tem que ver na tabela // precisa da versao ex da rotina e eu nao sabia antes->font_infoEx.cbSize = sizeof(CONSOLE_FONT_INFOEX); res = GetCurrentConsoleFontEx(h, 0, &(antes->font_infoEx)); // A fonte em uso fica aqui no registro // Computador\HKEY_LOCAL_MACHINE\SOFTWARE\ // Microsoft\Windows NT\CurrentVersion\Console\TrueTypeFont // GetConsoleMode(h, &antes->mode_original); // agora falta SCREEN BUFFER antes->infoEx.cbSize = sizeof(CONSOLE_SCREEN_BUFFER_INFOEX); GetConsoleScreenBufferInfoEx(h, &antes->infoEx); return antes; }; // guarda()  
E a irmã
 
void restaura(_cs_status* antes) { // restaura locale e paginas de codigo SetConsoleCP(antes->cp_original); SetConsoleOutputCP(antes->ocp_original); setlocale(LC_ALL, antes->local_original); // restaura a fonte HANDLE ho = GetStdHandle(STD_OUTPUT_HANDLE); int res = SetCurrentConsoleFontEx(ho, 0, &antes->font_infoEx); if (res == 0) printf("SetCurrentConsoleFontEx() falhou: %d\n", GetLastError()); // console mode SetConsoleMode(ho, antes->mode_original); // cor e fundo SetConsoleTextAttribute(ho, antes->infoEx.wAttributes); }; // restaura();  
E a estrutura
 
typedef struct { int cp_original; int ocp_original; char local_original[40]; int mode_original; FILE* log; CONSOLE_FONT_INFO font_info; CONSOLE_FONT_INFOEX font_infoEx; CONSOLE_SCREEN_BUFFER_INFO info; CONSOLE_SCREEN_BUFFER_INFOEX infoEx; } _cs_status;  
Use algo assim
 
 

Se escreveu algo então tem imagino que escreveu uma função para listar todos os elementos da lista... Apesar de não ser uma função comum da biblioteca é uma função comum para quem implementa, porque é a maneira trivial de testar o programa.
 
Se não escreveu essa função, escreva. Se escreveu perceba que pode copiar essa função para a função que precisa, essa que conta, porque é a mesma coisa: percorre a lista e, ao invés de mostrar, compara e conta... É o mesmo caso de apagar...
 
Poste o código

use um vetor para as medias e ao final de cada leitura das notas de cada materia calcule a armazene a media no vetor...

... Sugiro muito que esqueça esse modo de programar. Ninguém usa isso desde o final dos '80 e deve ter uma boa razão. 
Não via aprender nada exceto sobre o message loop do Windows, e vai gastar um tempo enorme para um resultado em geral não tão bom. 

Use .Net e outra linguagem, ou Allegro5, ou SDL2 ou Qt5 ou GTK+ ou wswidgets para usar esses controles. É muito simples, tudo pareido e o resultado é bom e portável.
 
Se quer mesmo aprender algo básico e poderoso e complicado, mas útil depois de 1986  , tente OpenGL ou DirectX.
 
Li agora melhor o que você quer fazer e pra isso não precisa de multithreading. Basta usar um slideshow e criar um timeframe. A menos que precise de fato processar algo durante a exibição
Pode usar o comum: uma taxa de atualização e a cada digamos .5s verifica uma fila de eventos, o seu "message loop". Assim pode inserir outras atividades, como um menu. E executa o que estiver na fila. Nada original  

Não precisa de um novo executável. Apenas de parâmetros. Use a linha de comando ou um arquivo de configuração.

float maioresnotas(float *n1, float *n2, float *n3){ if ( ( *n1 > *n2 ) && ( *n1 > *n3 ) ) return (*n1); if ( ( *n2 > *n1 ) && ( *n2 > *n3 ) ) return (*n2); return (*n3);  

Sim, está confuso. 
 
Escreva sempre em torno dos dados.
 
Precisa retornar as duas maiores notas de um conjunto de 3 notas.
 

Você precisa retornar as DUAS maiores notas mas está retornando uma em n3. De nada serve.
 
Há duas maneiras de retornar isso: ou você coloca as duas notas em um registro, uma struct, e retorna a tal struct, ou passa para a função dois endereços de float onde você enfia as duas maiores notas. Isso quer dizer passar por referência, da função para fora. 
 
Então note que sua função tem 3 argumentos de entrada e dois de saída. Se vai retornar os valores por referência então não vai retornar nada pela função. Não complique as coisas. Veja os dados e escreva de acordo. Por exemplo:
 
void maioresnotas( float nota1, float nota2, float nota3, // entrada por valor float* maior1, float* maior2 // saida por referencia );  
Você não pode zoar nenhuma das 3 notas de entrada. Quem chamar sua função não vai te dar esse direito. E você pode muito bem querer chamar com constantes, como em 
 
float maior1 = 0; float maior2 = 0; maioresnotas( 5.5, 3., 6.7, &maior1, &maior2 );  
E aí nem vai compilar seu programa. E fica menos prático. Observe os dados. São 3 notas. Só 3 notas. Só precisa isolar a menor. Então se a primeira for menor que a segunda já sabe uma das que vai retornar, certo? Certamente vai retornar a segunda.
 
É matemática, não C/C++/C#

Então
se a primeira nota é maior que a segunda as maiores são 1 e 3 ou 1 e 2  se a segunda é maior que a primeira então as maiores são 2 e 3 ou 2 e 1 São 3 if. Álgebra de Boole, o George Boole. Que deu nome ao Boolean.  
Na prática isso:
 
void maiores_notas( float nota1, float nota2, float nota3, // entrada por valor float* maior1, float* maior2 // saida por referencia ) { if (nota1 > nota2) { *maior2 = nota1; if (nota3 > nota2) *maior1 = nota3; else *maior1 = nota2; } else { *maior2 = nota2; if (nota3 > nota1) *maior1 = nota3; else *maior1 = nota1; }; return; };  
Como testar?
 
No mundo "sério" chamam isso de test unit:
 
void testa(float nota1, float nota2, float nota3) { float maior1 = 0; float maior2 = 0; maiores_notas( nota1, nota2, nota3, &maior1, &maior2); printf("\tNotas: %f, %f e %f\n\tMaiores: %f e %f\n", nota1, nota2, nota3, maior1, maior2); return; };  
E main() pode testar as 6 possíveis condições: 
 
int main(void) { testa(1., 2., 3.); testa(1., 3., 2.); testa(2., 1., 3.); testa(2., 3., 1.); testa(3., 1., 2.); testa(3., 2., 1.); };  
e mostrar
 
Notas: 1.000000, 2.000000 e 3.000000 Maiores: 3.000000 e 2.000000 Notas: 1.000000, 3.000000 e 2.000000 Maiores: 2.000000 e 3.000000 Notas: 2.000000, 1.000000 e 3.000000 Maiores: 3.000000 e 2.000000 Notas: 2.000000, 3.000000 e 1.000000 Maiores: 2.000000 e 3.000000 Notas: 3.000000, 1.000000 e 2.000000 Maiores: 2.000000 e 3.000000 Notas: 3.000000, 2.000000 e 1.000000 Maiores: 2.000000 e 3.000000  
O programa "todo"
 
E se fosse retornar as duas notas?
 
Algo simples assim:
 
typedef struct { float maior1; float maior2; } Duas_notas;  
E a função poderia retornar isso por valor mesmo, dado o contexto e o tamanho super modesto da estrutura
 
Duas_notas maiores_notas( float nota1, float nota2, float nota3);  
A função mudaria em umas linhas
 
Duas_notas maiores_notas( float nota1, float nota2, float nota3) { Duas_notas maiores; if (nota1 > nota2) { maiores.maior2 = nota1; if (nota3 > nota2) maiores.maior1 = nota3; else maiores.maior1 = nota2; } else { maiores.maior2 = nota2; if (nota3 > nota1) maiores.maior1 = nota3; else maiores.maior1 = nota1; }; return maiores; };  
Só isso. O uso é mais simples:
 
void testa(float nota1, float nota2, float nota3) { Duas_notas tst = maiores_notas(nota1, nota2, nota3); printf("\tNotas: %f, %f e %f\n\tMaiores: %f e %f\n", nota1, nota2, nota3, tst.maior1, tst.maior2); return; };  
Claro, o resultado é o mesmo. Isso é tão comum que em C++ tem uma classe pair e se pode declarar
 
pair<float><float> Duas_notas;  
 
 

Na placa tem em geral um bloco com 4 conectores: power on, reset, hd led pwr led.
E o gabinete tem os 4 conectores... Só isso.
LED SW é o LED que fica aceso quando a máquina está ligada.  HD LED ;e o que pisca quando tem atividade de disco PWR SW é o que liga no botão de força REST SW é o que liga no botão de reset  

Você tem experiência com essas coisas? Está invertendo os papéis. Você usaria isso para acessar por exemplo um desktop windows ou outro Linux a partir do SUSE...
 
O viewer é o cliente. Precisa instalar algum servidor na máquina e confirar. Seja ele o TeamViewer, o VNC server, um servidor RDP, configurar o acesso remoto via X-Wndows, um tunel X-Windows via SSH, qualquer coisa.
 
Mas tem que fazer alguma.

Não existe tal coisa. Essas linguagens são diferentes. Bem diferentes.
 
Postou um programa em C.
 
 
O mais comum: o ponteiro aponta para algo que não é o que você imaginava. O fato de não ser NULL nada garante exceto isso.
 
De volta ao seu programa
 
Em especial por estar aprendendo, não deve programar desse modo. Está tentando implementar uma lista ligada, imagino. 
 
Escreva em torno dos dados e não misture as coisas. Uma lista é uma lista. E dentro da lista tem zero ou mais nós. E dentro de cada nó pode ou não ter um dado. Uma lista é um container. Um nó é um container. Um nó não é uma lista, um Banco não é uma lista.
 
Considere:

Não use acentos. Em variáveis, em strings ou em comentários, a menos que o enunciado exija. Não vai aprender nada e só vai ter problemas
Ao usar uma estrutura de dados, como uma lista encadeada, entenda que uma estrutura é um container. Até tem esse nome em C++. Em java são chamadas coleções. Se programar uma estrutura dessas como se fosse um elemento com um ponteiro dentro só vai trabalhar mais e à toa. Em geral uma estrutura tem nós e cada nó tem uma referência a um dado. evite retornar void: em geral é um desperdício. Muitas vezes um erro. Use alguma ordem em suas funções, como a ordem alfabética por exemplo. Vai gostar disso quando seu programa tiver 50 funções ao invés de umas poucas. Muitos IDE mostram uma lista das funções, em geral na ordem em que foram declaradas, de modo que você pode clicar no nome e o editor vai direto para o código. E se estiverem em ordem é claro que você só ganha. Nunca use variáveis globais. Isso é um pesadelo e sempre vai cair na sua cabeça. Em geral é proibido em empresas e escolas. Não declare NADA fora de main(). Em geral, inicialize todas as variáveis. Nunca leia valores do teclado para alimentar seu programa antes dele estar rodando. Só vai te atrasar e não acrescenta absolutamente nada. Use constantes, use funções que retornam a estrutura preenchida. Ao terminar os  testes aí sim incorpore a leitura.  Ler de arquivos é muito mais simples e seguro e fácil de reproduzir. Não há razão para ficar parado em frene a tela minutos inventando nomes de campos e coisas assim: o efeito é que vai acabar não testando direito porque é difícil controlar e repetir testes. Alinhe seu código com algum critério. Evite longas linhas com mais de 60 colunas. Se seu programa tem um menu, entenda que o menu() deve mostrar as opções e ler e retornar a opção. Um void menu() é um desperdício. não use fflush(): isso só está definido para fluxos de saída. Em alguns compiladores pode até funcionar, mas é um sinal de fez algo errado scanf() foi escrita para ler entrada formatada. Não use para ler do teclado, que claramente não é entrada formatada. Só vai dar mais trabalho. Muito mais trabalho. Ao usar scanf() ou alguma função da família, como fscanf() entenda que ela retorna um valor. E teste. É ingênuo deixar o programa seguir sem testar. Não existe "lixo de teclado": necessidades assim na entrada indicam apenas que não entendeu bem o que está lendo e o que é a entrada via teclado, free form: o usuário pode digitar qualquer coisa e é o seu programa que tem que se virar O teclado tem ao menos 105 teclas de liberdade e o usuário pode digitar qualquer coisa

Ainda sobre esse programa:
 
Se você vai implementar uma P Q usando um Heap, e é uma escolha natural, e se tem essas funções 
 
int build_max_heap(int[], int); int max_heapify(int[], int, int);  
Então "pelo livro" faltam essas 
 
int extract_max(int[], int); int heapsort(int[], int); int insert(int, int[], int);  
No seu caso não é uma escolha natural, é apenas a expressão do enunciado.
 
Só que heap é uma estrutura self-healing: ela se ajusta sózinha. E extract_max() por exemplo pode ser só:
 
int extract_max(int heap[], int tamanho) { if (tamanho <= 0) return INT_MIN; // seria um erro int n = heap[1]; heap[1] = heap[tamanho]; tamanho -= 1; build_max_heap(heap, tamanho); return n; }; // extract_max  
Claro que int[ ] podia ser ELEMENTO* e extract_max() retornaria ELEMENTO ou ELEMENTO*, sem inventar. E continuaria com umas 5 linhas.
 
E insert()?
 
int insert(int elem, int heap[], int tamanho) { heap[++tamanho] = elem; build_max_heap(heap, tamanho); return 0; }; // insert()  
Pois é: 3 linhas. Tanto faz int[] ou ELEMENTO*
 
E o heapsort()?
 
int hp_heapsort(int heap[], int tamanho) { while (tamanho > 1) heap[tamanho--] = extract_max(heap, tamanho); return 0; }; // heapsort()  
Apenas duas linhas. E uma é o return. Podia retornar void porque heapsort() funciona in-place. Mais uma vez tanto faz se é int[] ou ELEMENTO* ou qualquer coisa.
 
E a fila de prioridade, onde entra?
 
A P Q tem essas funções: 
 
int insert(Elem*, P Q*); Elem max(P Q*); Elem extract_max( P Q*); int increase_key(Elem*, P Q*, Key);  
E ao usar um heap vai implementar a fila usando apenas as funções do heap. Nada mais. E elas se encaixam muito bem e por isso sempre se implementa P Q usando Heap. 
 
E não há ponteiros praticamente em lugar nenhum.
Se olhar para as funções que criou em seu programa vai ver como tudo fica simples ao considerar a existência da infra-estrutura do heap: a mágica do encapsulamento.
 
Exemplos em seu programa
 
Inserir
 
bool inserirElemento(PFILA f, int id, float prioridade);  
Meio b3st@ esse lance de prioridade ser um float hein? Mas não faz diferença. Essa estrutura toda que recebeu é bem rudimentar...
 
Se a fila é implementada em um Heap, e Heap oferece 
 
int insert(ELEMENTO Elem, ELEMENTO* Heap, int size);  
Como está na lista, então inserir é trivial.

Outro:
 
int removerElemento(ELEMENTO* elem, PFILA fila);  
Como a fila é um Max_Heap cada possível sub-conjunto da fila é um Max_Heap, por definição. Então você pode localizar o elemento na fila e usar extract_max() a partir dele e ele vai sumir da fila e reajustar tudo.
 
Outro:

Mudar prioridades. Não faz diferença aumentar ou diminuir. Num max_heap não está previsto diminuir, mas continua sendo um max_heap. Então pode localizar o elemento, copiar, excluir do heap com extract_max() e inserir com inserir() e passando a nova chave --- prioridade. É mais rápido e seguro. Não se manipula um heap diretamente como fez em seu programa. Uma alteração no heap() é realizada em logN operações recursivas. Muito rápido. 
 
No resto do programa não há qualquer menção a Heap ou Max_Heap. Apenas dentro das funções de P Q estão as chamadas às funções de manipulação de Heap. 
 
Não precisa nem sequer compilar as funções de Heap de novo. Basta o #include como faz com printf() por exemplo. E depois que a P Q funcionar pode usar em seus programas as funções de P Q sem se preocupar nem com P Q nem com Heap. O encapsulamento de novo.
 
E como costurar o programa, a P Q  o Heap?
 
Um algoritmo viável é usar uma estrutura tipo argc/argv de main() para alocar o Heap. deve dar certo já que sempre dá certo no sistema. E na construção se usam dois parâmetros: um tamanho inicial e um incremento. ex: 50 e 100. Então aloca um heap para 50 ponteiros para ELEMENTO na criação da fila e sempre que ele se esgotar se aloca MAIS 100 e corrige o tamanho: 50/150/250/350... Um Heap e não uma P Q. E mantem isso atualizado nos metadados da estrutura, claro.
 
O que é a P Q? um vetor. Num dado momento tem um certo número de elementos alocados e um certo número de elementos em uso.
 
Para a P Q  não é preciso usar ponteiros. E nem para o Heap. Apenas acontece que o Heap é alocado dinâmicamente e esses são os ponteiros. A fila usa índices para o Heap. O Heap usa índices para achar os elementos. Se o Heap for alocado estaticamente não há um ponteiro sequer.
 
Como destruir a P Q?
 
Nada especial: chama extract_max() até ela ficar vazia e apaga a estrutura, retornando NULL para invalidar o ponteiro...
 
Mais um exemplo:
 
Essa estrutura
 
typedef struct st_ex { int id; int posicao; float prioridade; } ELEMENTO, * PONT; typedef float Key; typedef ELEMENTO Dado; typedef struct { Dado* x; Key k; // prioridade } Elemento; typedef struct { unsigned incremento; unsigned limite; unsigned tamanho; Elemento** E; // max_heap } P Q, S;  
Provavelemente serviria para envolver seus dados e resolver seu programa de um modo bem simples, com funções de poucas linhas e fáceis de ler e alterar. E ficaria com as funções  tanto de heap quanto de p q para o futuro.
 
É preciso escrever P e Q separados porque o software b0b1nh0 desse forum troca p q por "porque" mesmo que sejam variáveis dentro de um programa. Genial!!!

Usei essa nomenclatura para poder ficar igual ao livro :). Só não usei os nomes em maiúscula porque em C não faria sentido...

JSON é um formato trivial, e por isso tem tanto sucesso. Você pode ler o texto e cadastrar em sua própria classe, em um mapa por exemplo. Ou uma classe personalizada. Ou objetos steam
Mas se já está usando essa biblioteca pode ver um exemplo completo na documentação da própria em https://nlohmann.github.io/json/api/basic_json/parse/
 
Não procurou lá?
 
Não é muito diferente de Python. Se usar um mapa em C++ é igualzinho, na verdade.
 
Se usar o exemplo como está na documentação, pode ver que usando "filtered" pode extrair apenas essa parte "listinginfo"
 
 

Não, não há um programa para isso.
 
E há incontáveis maneiras.
 
No entanto o mais simples é montar uma classe para os dados e no construtor montar as estruturas todas a partir dos dados. Isso se eu entendi a ideia porque o programa não faz uso daquelas coisas saudáveis conhecidas por comentários descritivos
e não foi escrito de modo especialmente legível nem bem alinhado. 
 
 
 

para somar os índices você pode escrever linha + coluna, a soma dos índices...
 
declare as variáveis de controle dentro do for. É assim desde 89. E antes não era assim porque demorou muito para o comitê afinal aprovar isso na linguagem. E estamos  no final de 2020.
 
É muito importante reduzir o escopo das variáveis. Se elas só fazem sentido dentro do loop use declare no for

Se quer fazer isso enquanto ele digita então precisa ler o texto sem mostrar na tela e ir inserindo a pontuação correta conforme ele digita. É simples mas chato pra c@c3t3. Mas é o esperado. Se quer fazer assim avise e te explico melhor

Digitar os números grudados para o programa formatar depois sempre vai parecer amador. De todo modo se quer fazer apenas isso basta usar as especificações certas no printf() ou montar a string arrumadinha usando sprintf(). CPF deve ser char[11] então o que quer é usar recortar e colar e escrever algo assim:
 
#include <stdio.h> int main(void) { const char* c = "12345678987"; char CPF[15] = {' '}; sprintf(CPF, "%c%c%c.%c%c%c.%c%c%c-%c%c", c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8], c[9], c[10] ); printf("cpf: DE '%s' para '%s'\n", c, CPF); return 0; }  
que mostra
 
cpf: DE '12345678987' para '123.456.789-87'  

Se quer fazer isso enquanto ele digita então precisa ler o texto sem mostrar na tela e ir inserindo a pontuação correta conforme ele digita. É simples mas chato pra c@c3t3. Mas é o esperado. Se quer fazer assim avise e te explico melhor

Digitar os números grudados para o programa formatar depois sempre vai parecer amador. De todo modo se quer fazer apenas isso basta usar as especificações certas no printf() ou montar a string arrumadinha usando sprintf(). CPF deve ser char[11] então o que quer é usar recortar e colar e escrever algo assim:
 
#include <stdio.h> int main(void) { const char* c = "12345678987"; char CPF[15] = {' '}; sprintf(CPF, "%c%c%c.%c%c%c.%c%c%c-%c%c", c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8], c[9], c[10] ); printf("cpf: DE '%s' para '%s'\n", c, CPF); return 0; }  
que mostra
 
cpf: DE '12345678987' para '123.456.789-87'  

Se quer fazer isso enquanto ele digita então precisa ler o texto sem mostrar na tela e ir inserindo a pontuação correta conforme ele digita. É simples mas chato pra c@c3t3. Mas é o esperado. Se quer fazer assim avise e te explico melhor

Digitar os números grudados para o programa formatar depois sempre vai parecer amador. De todo modo se quer fazer apenas isso basta usar as especificações certas no printf() ou montar a string arrumadinha usando sprintf(). CPF deve ser char[11] então o que quer é usar recortar e colar e escrever algo assim:
 
#include <stdio.h> int main(void) { const char* c = "12345678987"; char CPF[15] = {' '}; sprintf(CPF, "%c%c%c.%c%c%c.%c%c%c-%c%c", c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8], c[9], c[10] ); printf("cpf: DE '%s' para '%s'\n", c, CPF); return 0; }  
que mostra
 
cpf: DE '12345678987' para '123.456.789-87'  

Em muitas classes os construtores são como formulários apenas e então essa notação é muito mais compacta e legível, e não existe ambiguidade, como você mesmo mostrou: então não precisa escrever tanto. Menos chance  de errar, menos this. menos java  

Não, não existe. E você pode usar os mesmos nomes.

Isso vem sendo feito há décadas. Acha que vai fazer algo mais simples e viável do que o Unix e o Windows por exemplo tem desde os '80?
 
Sem ser original, crie uns op-codes e uma máquina virtual que roda seus programas, como o P-Code dos anos '70 no USCD pSystem. Ou algo que rode na JVM que possa rodar em outras máquinas, como é em java de todo modo. Ou como é o managed code no Windows
 
 

@Midori você não disse que alvo usou para chamar make
 
$(EXEC) : $(OBJFILES) $(CXX) $(CXXFLAGS) -o $(EXEC)  
Nessa linha acrescente $? que vai expandir para a lista de dependências:
 
$(EXEC) : $(OBJFILES) $(CXX) -o $(EXEC) $(LDLIBS) $?  
mas como cada programa tem uma história, na hora do link pode ser mais flexível e simples usar uma alvo para cada programa, para poder colocar a lista de bibliotecas com total controle. E listar uma a um ou grupo a grupo como dependência --- pré-requisito --- de all,  algo assim:
 
CXX = g++ #LDLIBS = -lwsqlite3-3.0 `wx-config --libs` CXXFLAGS = -c -Wall -Wextra OBJFILES = controle.o janela.o aplicativo.o EXEC = programa OBJS = $(.cpp=.o) all: programa programa : $(OBJFILES) $(CXX) -o $(EXEC) $(LDLIBS) $? %.o : %.cpp $(CXX) $(CXXFLAGS) $< clean: rm -f $(OBJFILES) $(EXEC)  
porque all pode incluir centenas de programas e cada um vai ter sua necessidade de bibliotecas. Por grupo a grupo eu quero dizer que pode ter um alvo que atualiza todos os programas que usam sqlite por exemplo. Um grupo para todas as unit-tests, coisas assim... E usar esse nome de grupo como dependência de all.
 
 
E muitas vezes um .h pode ser dependência para um .cpp porque pode ter constantes dentro...

Poste algo que alguém possa compilar e testar, quando for o caso de um programa e não uma dúvida conceitual.
 
Seu programa não está bom. Vai dar muito trabalho assim.
Use funções e agrupe seus dados em estruturas mais expressivas. Um cadastro tem itens. Um certo número de itens. Então crie uma estrutura para os pacientes, e uma estrutura para o cadastro onde tem pacientes dentro.  Use argumentos para suas funções e passe os endereços dessas estruturas para as funções. Processe os dados na memória. Leia no início, grave no final.  Em especial se está começando não grave sobre seus próprios dados no disco. Se der um erro vai ficar sem nada.

@Lucca Rodrigues Eu te mostrei a maneira de fazer isso naquele programa de menus que postei semanas atrás, em  C e C++
 
E não é scanf(). 
 
scanf formated input - esse é o objetivo de scanf(). Não deveria ser usada para algo que não fosse entrada formatada.
 
 
Não é que funcionou. A vírgula passa a fazer parte do conjunto  tudo que está entre colchetes
 
 
Não, não há. O '^'  só é processado como tal no início. E não tem um inversor.
 
 
O Windows lê do teclado em um modo chamado ENABLE_LINE_INPUT,  COOKED MODE no Unix, Linux Android MacOS. Desse modo o programa só recebe algo da leitura ao aparecer um ENTER na entrada. 
 
E para caso como esse de filtros já pode ser tarde para o programa reagir.
 
Então pode desligar esse modo e ler via fgetc() sabendo que vai receber letra a letra... E aí é trivial reagir a cada letra que entra já que elas vem uma por vez...
 
Ou use a técnica que te expliquei quando dos menus, usando as funções de mais baixo nível.

O zero indica que é um valor em octal.
 
 C foi escrita para o Unix, em um computador PDP-11 da Digital. E a Digital usava octal e ASCII. A IBM usava Hexadecimal e  EBCDIC. 
 
Então por exemplo \33 é o ESCAPE cujo código é 27 em decimal. Ou 1B em hexa. Mas como o padrão é octal se você quer hexadecimal tem que usar \x1b. Decisão de Dennis Ritchie e Ken Thompson provavelmente  
 
Claro que 
033 é \33 e é o mesmo que \033 e não \x33: 27 = 3x8 + 4 e não 51 que seria 3x16 + 3 011 é o mesmo que \011 que é 1x8 + 1 = 9 É a definição e está no manual: começa por zero é octal.
 
Você ia ter uma surpresa maior se usasse A= 09, já que o compilador ia dar erro.
 
Resumo do resumo, lembrando do ensino fundamental e C/C++:
 
12 é doze, decimal 012 é uma constante octal 10 em decimal e pode escrever também \12 ou \012 0x12 é uma constante hexadecimal e vale 18 em decimal. E pode escrever \x12 um byte pode ir até 0377 octal ou 0xFF hexa ou 256. Tanto faz escrever 0xDD ou 0xdD ou 0xdd A constante hexa mais sinistra é 0xDEAD que vale 57005 😬
 
 

Depois que entender o problema acho que vai terminar isso num instante.
 
Apenas escreva em torno dos dados.
 
Exemplo:
 
123000 1 1200 0 1000000 5 12333 2  
Esse é o arquivo de entrada. Faça um programa que leia isso e mostre o maior e menor valor. É metade do seu problema
 
A tabela de descontos você já mostrou. Veja essa:
 
const float fator[] = { 0., 0.082, 0.164, 0.246, 0.368, 0.5 };  
Não é a mesma coisa? fator[4] = 50%... 
 
Um programa de 5 comandos, para uma casa de 100 mil
 
#include <iomanip> #include <iostream> using namespace std; int main(void) { const float fator[] = { 0., 0.082, 0.164, 0.246, 0.368, 0.5 }; unsigned N = sizeof(fator)/sizeof(float); std::cout << N << " coeficientes de desvalorização\n"; double preco = 100'000; std::cout << "para uma casa que custe " << preco << " eis os valores finais:\n"; for( int i=0; i<N; i+= 1) std::cout << std::fixed << std::setprecision(2) << std::setw(-8) << i << " ..... " << preco*(1-fator[i]) << "\t[ " << fator[i]*100. << "% ]\n"; return 0; }  
E olha o que aparece
 
6 coeficientes de desvalorização para uma casa que custe 100000 eis os valores finais: 0 ..... 100000.00 [ 0.00% ] 1 ..... 91800.00 [ 8.20% ] 2 ..... 83600.00 [ 16.40% ] 3 ..... 75400.00 [ 24.60% ] 4 ..... 63200.00 [ 36.80% ] 5 ..... 50000.00 [ 50.00% ]  
Código mesmo é só uma linha
 
double preco_final = preco*(1-fator[i]);  
onde 'i' é claro o fator que leu do arquivo.