arfneto

? Eu já te mostrei dois. Seguindo as janelas e criando o Snapshot Rodou os dois? O que não conseguiu fazer?

Não consegui associar o que perguntou com a lógica do seu programa. No programa tem um menu convencional. Na pergunta você diz que quer entrar os valores em grupos de 3? De todo modo, você só tem 7 produtos: Crie uma imagem do formulário no programa, simples assim. 7 itens são 7 quantidades. Pode ser um simples char ticket[7] apenas. Começa com tudo zero e conforme o cara vai escolhendo você atualiza o carrinho. Ao final você mostra. Se quer que ele possa usar algo mais dinâmico apenas use letras para o produto ao invés de números e na hora de ler a opção aceite um linha toda. Se vier 'A' até 'G' você aceita como o menu convencional, de 'A' para cachorro quente e 'G' para refrigerante. Mas se o cara digitar C3 D2 você entende o óbvio e soma no pedido 3 X-Bacon 2 2 Misto. Quando o cara finalizar a compra você emite o ticket. O normal.

Onde entra o Visual Studio, um IDE, nessa história? Não entra. É só uma função adicionado 3 minutos depois O pai é apenas isso: um processo que gerou o Thread que criou a janela. E o nome não é o nome dele mas sim o nome do executável, o arquivo que gerou o processo. ModuleBaseAddress é, como imagina, um endereço. adicionado 13 minutos depois Para uma lista de módulos de um processo o caminho eu já te disse qual é: CreateToolhelp32Snapshot HANDLE CreateToolhelp32Snapshot( DWORD dwFlags, DWORD th32ProcessID ); E lá tem todos os módulos associados ao processo. E aí você chama GetModuleInformation BOOL GetModuleInformation( HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb ); Você rodou este programa que te mostrei?

Essa parte ainda não foi traduzida, mas está descrito aqui: https://docs.microsoft.com/pt-br/windows/win32/sysinfo/handles-and-objects Uma janela é uma janela, não importa como foi escrita. Tem um Handle. Fica num desktop. Que tem um Handle. Ela tem um Handle e foi criada por um processo. Um thread de um processo, que tem um pai. E então tem um Handle também. E o Handle leva a uma estrutura que descreve o processo. E lá está o nome do executável que criou a janela. Um Handle é um int. Rode esse programa em sua máquina #pragma once #include <windows.h> #include <tlhelp32.h> #include <tchar.h> #include <psapi.h> #include "stdio.h" #include "stdlib.h" int CALLBACK agente(HWND, LPARAM); int main(int argc, char** argv) { DWORD flags = 0; int inherit = 0; ACCESS_MASK access = READ_CONTROL; HDESK desktop = OpenInputDesktop(flags, inherit, access); if (desktop == NULL) return -1; EnumDesktopWindows(desktop, agente, 0); return 0; }; // main() int CALLBACK agente(HWND H, LPARAM P) { char buffer[512]; DWORD pai; LPDWORD pId = &pai; int n = GetWindowTextLengthA(H); char* titulo = malloc(1 + n); GetWindowTextA(H, titulo, 1 + n); DWORD window_thread = GetWindowThreadProcessId(H, pId); ACCESS_MASK access = PROCESS_QUERY_INFORMATION | PROCESS_VM_READ; HANDLE hProcess = OpenProcess(access, FALSE, pai); if (hProcess == NULL) return -1; n = GetProcessImageFileNameA(hProcess, buffer, 512); if (n <= 0) return -2; char* p = buffer; for (int i = n; i > 1; i-=1) { if (buffer[i] != '\\') continue; p = buffer + i + 1; break; } // for() if (strlen(titulo) > 0) printf("Window thread: %8d\ttitulo: '%s'\n\tpai:%8d\tExe: '%s'\n", window_thread, titulo, pai, p); else printf("Window thread: %8d\tpai:%8d\tExe: '%s'\n", window_thread, pai, p); free(titulo); return 1; }; // agente() Ele segue esse caminho que eu expliquei. Deve ajudar a entender. O que faz o programa? identifica o desktop e para cada janela vê o tamanho do titulo da janela. Pode ser zero. E lê o título da janela abre o processo que criou a janela encontra o pai dele identifica o executável mostra os dados na tela E poste seu código como está pra eu poder ver se entendo o que falta.

Use as estruturas do sistema. Elas vão funcionar para qualquer aplicação, qualquer framework e qualquer ferramenta.

Rodou o programa que te mostrei? crie um snapshot e um loop na lista de processos vai te mostrar o pId do processo que quer. Aí pode ver na lista daquele processo TODOS os handles d processo, incluindo as janelas abertas... É o caminho comum. Acho que todos os programas desse tipo fazem isso.

É claro. Ou vai pular uma linha quando mostrar na tela. Isso é o sentido de newline, '\n", Line Feed na tabela ASCII. Considere sempre a versão recursiva também. como eu te mostrei. Fora o fatorial acho que é o exemplo mais comum de todos.

Mas está achando ou não a janela? Testou o retorno de FindWindow? Use L"" para o título. Rodou o programa de que e falei? Procurar janelas pelo título não é seguro. Crie a lista de processos e encontre o que quer na lista. Use CreateToolhelp32Snapshot() como no exemplo do programa que eu escrevi

Não esqueceu algum dos headers apenas?

Entenda que se FindWindow não voltar com um Handle de nada adianta continuar... E o programa não testa.

Mas você nem testa se FindWindow() conseguiu um handle e segue adiante... Achar janelas pelo título é inseguro eu acho. Teste o retorno antes de seguir. acho que não está retornando o Handle. Meses atrás postei um programa aqui neste forum que levanta a lista de processos no Windows, usando uma técnica mais segura talvez: o simples de criar uma lista dos processos que estão rodando e percorrer a lista em busca do que precisa. Talvez ache mais seguro usar algo assim. Pode ver em Task List

continuando com o exemplo "azul\n" 'a' 'z' 'u' 'l' '\n' entenda que na verdade você quer copiar até 'l' e os índices começam de zero então 'l' é str[3] strlen() nesse caso vale 5 depois do '\n' tem um '\0' porque assim são as strings em C. Não há nada de especial em usar fgets(). Mas gets() não existe em compiladores da Microsoft e acho que da Intel então se for compilar em algum desses vai ter que alterar. A toa. fgets() tem em todas as plataformas e é mais esperta porque tem um parâmetro que limita o tamanho, como você usou. E então te dá uma segurança sobre a entrada que gets() não tem e por isso foi abandonada em muitos círculos. E GARANTE o newline no final então se você está copiando dados vai achar vantagem porque pode copiar linhas de um arquivo para outro usando pares fgets()/fputs() direto. Entenda que se você escrever char str[30]; str = gets(str); E o usuário digitar 30 letrinhas seu programa já era assim que ele teclar ENTER. Por isso essa função foi abandonada. E até abre uma porta para injeção de código por hackers, o tal buffer overflow. Mas se você escrever char str[30]; fgets(str, 30, stdin); E rodar aquele programa que te mostrei Digite uma palavra: sssssssssddddddddddllllllllllldddddddddddd Valor recebido: 'sssssssssddddddddddlllllllll' String ao contrario: 'lllllllllddddddddddsssssssss' Note que ele para de ler em 29 letrinhas e seu programa não cancela. E compila em qualquer plataforma, de bonus. Esqueça essas "recomendações" e NUNCA use gets(). Ou mesmo scanf() para esses casos de ler do teclado. leia letra a letra usando fgetc() leia linha a linha usando fgets() ou para ter real controle leia do buffer de teclado diretamente usando PeekConsoleInput() no Windows ou ioctl() no Linux. Não tem nada a ver. Em C as strings são terminadas por um zero. Acho que agora já entendeu isso. Seu enunciado aparentemente não exige ter uma string de saída: pede só para mostrar letra a string de entrada invertida. Então pode só mostrar letra a letra do fim para o começo e pronto, como no exemplo de @Midori. E como na função recursiva que eu mostrei. Só que você está criando uma nova string, contrario[] e depois usando '%s' no printf() para mostrar. E assim precisa ter um zero ao final da string. contrario[c + 1] = 0; contrario[c+1] é um char. Uma única letra. Se você vai copiar c caracteres, na posição (c+1) tem que ter um zero. É assim em C. Essa instrução só faz isso. Termina sua string de saída para você poder usar printf() com a máscara %s, uma string. Se você não colocar isso ele vai mostrar tudo que tiver na memória no momento , até achar um zero. Teste. A partir de 1990 passou a ser legal declarar variáveis dentro do for. Use a opção --std=c17 em seu compilador. ISO/IEC 9899:2018; it is known as C17 and is supported with -std=c17 or -std=iso9899:2017; the corrections are also applied with -std=c11, and the only difference between the options is the value of __STDC_VERSION__ Isso é prático e evita muitos efeitos colaterais. Foi esperado por muitos anos por quem escrevia software em C desde os 80 porque muitas vezes variáveis só existiam dentro de um loop, casos como o do seu programa

Está claro que a string de saída vai ter o mesmo tamanho que a de entrada. Mas do jeito que você escreveu precisa colocar um zero lá no fim de 'contrario' fgets() foi escrita para você poder ler e já copiar a string para outro lugar. Isso quer dizer que fgets() lê a string inteira, incluído o '\n' do final. Isso é bom, desde que você tenha lido o manual ou queira fazer o normal que é gravar em outro lugar com fputs() por exemplo. Aí você gosta de ter o '\n' lá porque se fgets() o tirasse você teria que por de volta linha por linha ou ia ficar tudo grudado na saída em uma linha só. Só que aqui você não pode copiar a partir do último valor em str[] porque é garantido que é um '\n', e isso é bom. Mesmo que não tenha um newline lá para ler fgets() vai colocar um automaticamente. Isso porque muitas vezes a última linha de um arquivo texto não tem o '\n'e aí ficaria um tratamento especial a toa. É mais simples assim e está escrito em todo manual que eu já vi até hoje. Como você só quer ler a string, não pode começar a inverter pela última posição dela. Exemplo: se a linha era 'azul\n' fgets() leu exatamente assim: 'a' 'z' 'u' 'l' '\n' E o primeiro que você quer copiar é o 'l' e a posição dele é (strlen(str) - 2). Esse é o maior problema de seu programa Você precisa terminar a string de saída com um zero. Uma string em C é isso. Você sabe que ela vai ter o mesmo comprimento da string de entrada, exceto o '\n' e então faça isso: coloque um zero lá ou não vai funcionar e vai imprimir um monte de lixo na tela até achar um zero... Algo simples assim resolve: int c = strlen(str) - 2; // primeiro indice a copiar contrario[c + 1] = 0; E você copia de str para contrario até c ser menor que zero Quando você mostra uma string que pode espaços sugiro sempre mostrar entre algum delimitador, afinal não dá pra ver os espaços. Algo simples como '%s' no printf() se você não está usando um compilador medieval pode declarar int i=0 dentro do for apenas para imprimir str[] você deve tirar o '\n'de lá. Pode usar o simples str[strlen(str) - 1] = 0; Compare com o EXEMPLO #include <stdio.h> main() { char str[30], contrario[30]; printf("Digite uma palavra: "); fgets(str, 30, stdin); int c = strlen(str) - 2; // primeiro indice a copiar contrario[c + 1] = 0; str[strlen(str) - 1] = 0; printf("\nValor recebido: '%s'\n", str); for (int i = 0; c >= 0; i+=1, c-=1 ) contrario[i] = str[c]; printf("String ao contrario: '%s'\n\n", contrario); } que mostra para 'azul' Digite uma palavra: azul Valor recebido: 'azul' String ao contrario: 'luza' adicionado 16 minutos depois Não seria justo não incluir o clássico exemplo de inverter a string usando recursão Veja que nesse caso só precisa de uma variável, a string em si. E precisa daquela jogada no final da entrada apenas para poder mostrar a string inicial sem pular de linha por causa do '\n' no final. #include <stdio.h> void inverte(char*); main() { char str[30]; printf("Digite uma palavra: "); fgets(str, 30, stdin); str[strlen(str) - 1] = 0; printf("\nValor recebido: '%s'\n", str); printf("String ao contrario: '"); inverte(str); printf("'\n"); }; void inverte(char* str) { if ((str[0] == 0) || (str[0] == '\n')) return; inverte(str + 1); printf("%c", *str); }; O resultado, claro, é o mesmo.

Já li isso outras vezes. Não há essa equivalência. conio é uma biblioteca dos anos '80 que era parte dos compiladores da Borland --- hoje Embarcadero --- para windows e tem um modesto alcance. Eis os métodos de conio.h é só isso e tem essa idade aí. Não vejo razão para usar isso desde os anos '90. Eu era um usuário de curses, no Unix, antes do Windows. E por algum tempo usei ncurses. Em relação a conio é outro animal. Não há essa equivalência. Você já escreveu algo com ncurses? Tem alguma referência dessa suposta "equivalência"? Será apenas porque curses tem uma função getch()? ncurses tem noção de janelas, de overlap entre janelas, painéis, guarda imagem da tela e das janelas e serve para muitos propósitos. Por exemplo, eu escrevi um editor hex com curses. E um sistema de menus. curses é uma alternativa para uma interface de janelas em modo texto. E não havia interface gráfica em terminais de 24 linhas por 80 colunas, que era o normal na época. conio ficou popular quando saiu porque era uma maneira trivial de ler sem echo no windows, e acessar o buffer do teclado sem ter que ler o manual do Windows. No tempo em que existiam manuais das coisas. adicionado 32 minutos depois O modelo de programação de curses é o mesmo de SDL, GTK+, wxWidgets e Qt. Então é algo interessante para aprender hoje em dia, ainda mais com o interesse renovado nas aplicações de console nesses últimos tempos, com milhões de máquinas rodando aplicações passando do mundo real para a nuvem, no caminho inverso dos 80, quando elas saíram da "nuvem" dos mainframes para os "minicomputadores" e depois os PC. Ao usar um modelo você se acostuma com os outros.

e? Não entendi. Você vai gerar um calendário 2x6 como disse. Imagino que em um arquivo para poder salvar , confrir e imprimir. Não vejo interesse em mostrar isso na tela. E determinar o primeiro dia é algo distinto. O que eu te disse é que esse calendário que mostrou sequer tem as otimizações que normalmente se tem ao imprimir um calendário via programa: ele mantem 6 semanas para mês inclusive fevereiro, como está lá. 36x12 slots = 432 dias. Então você pode ler o seu próprio exemplo e escrever em cima do calendário, depois que usar qualquer meio para determinar o primeiro dia. Só isso. Não precisa de qualquer lógica.

Se você tem o gabarito --- e ele já te dá o conforto de ter seis semanas por mês --- apenas faça o programa ler o gabarito e simplesmente escrever em cima. Não precisa de qualquer lógica exceto saber em que dia começou o ano, o que o sistema te diz.

Seu programa já tem mais de 400 linhas e está bastante complicado. Notei também que tem apenas 4 linhas de comentário e nenhuma função. Nada disse sobre ter um livro No programa temos matriz, matriz_quartos, vetor, vetor2, matriz_quartos_fase2, fase3, fase4 e fase5. Parece uma representação mais complicada que o necessário. E em torno de 40 loops for() para controlar o jogo. Espero que dê certo assim, mas pode ser um caminho mais difícil. Exemplo Essa estrutura fase[ ][ ] abaixo representa as 5 fases do jogo como descrito, usando um '-' para marcar "quartos" não existentes na fase, e acho que bastaria para controlar todo o jogo char fase[5][8] = { { // fase 1 'x', 'x', ' ', 'g', 'r', ' ', 'x', 'x' }, { // fase 2 ' ', 'x', 'x', 'x', 'x', 'c', ' ', ' ' }, { // fase 3 ' ', 'x', 'x', ' ', ' ', ' ', '-', '-' }, { // fase 4 ' ', ' ', ' ', 'x', 'r', 'x', '-', '-' }, { // fase 5 ' ', ' ', ' ', 'q', '-', '-', '-', '-' } };

Entendeu isso? Você tem um livro? Entendeu isso? De volta ao programa: A implementação é bem simples. Trata-se apenas de controlar o jogo e não do jogo em si. Deve se concentrar em 3 partes: a representação dos quartos e atribuição dos hóspedes. A noção de "ao lado" parece envolver apenas esquerda e direita e não um quarto acima ou abaixo do outro. E o mapa é mínimo e muda de uma fase para outra. Então pode ser mais simples usar apenas uma lista de quartos. Deve escolher também uma maneira de mostrar o mapa na tela que seja legível. a maneira de ler a opção do jogador. Pode usar scanf() e ler todos os valores de uma vez usando as letras da legenda mesmo. Ou ler linhas com fgets() e tratar o que veio. Ou mesmo ler letra a letra para cada caso. uma maneira de conferir se uma configuração é legal ou não. Pode ser uma função como int legal(Mapa* m, char fase); onde você passa o mapa e a fase e ela retorna 1 se tal mapa é legal --- não viola nenhuma regra

Acho que tem problemas com o ambiente e a localização dos includes apenas. Confirmou que está tudo presente?

Li seu programa. Parece muito complicado assim. Minha sugestão é usar funções e arquivos para simplificar um pouco. Se não se lembra disso ou não estudou ainda sugiro o simples: estude isso em algum livro. Imagino que seu curso adote um. Se não adota é uma pena. E aí sugiro que você adote um. É importante. E algum site de referência. De volta ao programa Escreva apenas a primeira fase. A cada fase vai ficar tudo mais fácil para você porque vai se acostumar com a mecânica da linguagem C e a mecânica do jogo. E ficará ais fácil de voltar atrás se o seu modelo pra o jogo não estiver bom. Não entendi a progressão do jogo. Podia explicar melhor a primeira fase? Eis as regras de um modo mais compacto: Num hotel os hospedes sao CAO, GATO, QUEIJO, OSSO e RATO E a atribuicao dos quartos segue as seguintes regras: - O RATO nao pode ficar ao lado do GATO - O CAO nao pode ficar ao lado do OSSO - O GATO nao pode ficar ao lado do CAO - O QUEIJO nao pode ficar ao lado do rato Legenda para os "hospedes" no Mapa: G C R O Q com o significado esperado Celulas com X representam quartos indisponiveis. Sao 5 fases sequenciais obrigatorias. Acho que podia deixar isso como uma legenda pra ser mostrada com uma tecla. E preparar um desenho para o tabuleiro, no próprio IDE, antes de tentar programar.

Parece que não consegui me fazer entender... Isso era um exemplo de que é possível escrever simplesmente loops sem escrever funções ou repetir o código em C. E sem usar for, loop ou do. Mas era isso: um exemplo de que era possível e até legível. Dos tempos em que se programava muito em Assembler e o código era assim... passou = 0; fase1: // codido da fase if ( passou ) goto fase2 // prepara reinicio na fase 1 ... goto fase1; fase2: ... É só isso. Não estou recomendando que ninguém escreva isso. Só disse que é possível usar um único trecho de código, manter legível e fazer funcionar, mesmo sem esses comandos. De modo semelhante uma função também é isso: empilha os argumentos, marca o endereço de retorno, vai para o endereço da função, recupera os argumentos, executa o código da função e retorna para a linha seguinte à linha que chamou a função. Vou ver seu programa de novo, agora com essa confirmação. . . Em C++ seria mais fácil, mas está ok escrever isso em C adicionado 5 minutos depois Eu me lembrava disso mas depois fiquei confuso. Tem um enunciado mais preciso em relação às regras?

Em C ou C++? Que linguagem vai usar? São muito diferentes. Eu já perguntei isso e você não respondeu

oh... Isso é só um exemplo de como ter as fases dentro de um código só sem usar funções. Não é algo que facá sentido. Desculpe. Não. Essas coisas que terminam por dois pontos são declarações. Se chamam labels. Poste seu programa pra gente ajudar. Sabe escrever funções? Sabe o que é uma classe já? Leu o que eu disse sobre classes? Provavelmente esse é o caminho mais simples. Essa linguagem foi escrita para facilitar essas coisas, a abstração de modelos como o do seu jogo. Poste o código e te ajudo a escrever uma classe para este jogo

Talvez ache mais interessante continuar com isso lendo uma linha e interpretando o resultado. Incluir opções na calculadora nesse formato não vai te ensinar muita coisa, se alguma. É apenas mais do mesmo. e um menu é pouco interessante para programar ou para usar como calculadora. Isso pode ser mais interessante para aprender: aceite algumas variáveis, de uma letra só pra simplificar. E atue de acordo enquanto o programa está no ar, lendo expressões como A = 12 B 12 + 3 B = A C = 12 + 3 A = C + 5 * 3 Pode achar mais interessante para aprender

Eu pretendia ter dito NÃO implica em repetir várias vezes o mesmo código. My bad.