kgin

@RenanDias92 Mas os valores tem que ser gerados aleatoriamente ou o programa poderia aceitar que o usuário digitasse qualquer numero menos os números anteriores?

Você já fez alguma coisa?

2 horas atrás, souza souza00 disse:

acho que voce nao entendeu a minha duvida, eu so quero saber o porque ele ta dando o erro que eu postei o print,

Olha aqui no meu compilador

Que está basicamente dizendo que na linha 189 do arquivo calc.cpp

	while(value > 0)
		convert(value % 10, digits, (*count)++);
		value = value / 10;
	}

Seu while está sem a chave do bloco '{'

e que na linha 123 do mesmo arquivo (calc.cpp) você está utilizando uma variável chamada digit no loop for que não foi declarada

	for(digit = 0; digit < 8; digit++){
		
   numeros[x] = num % 10;
   num /= 10;
  }

e que a sua função

void CpuSthefani::converterIntToDigits(int value, Digit *digits, int *count)

você não fechou o bloco da função com a chave '}'

@souza souza00 Pra mim esse seu código não tem salvação, mas se vocẽ ainda quiser tentar recuperar a maior parte dos erros estão no método

void CpuSthefani::converterIntToDigits(int value, Digit *digits, int *count)

na linha 118 do arquivo calc.cpp.

Você não fechou o método com a chave } nem utilizou um bloco {} no while, e no for você está utilizando um ponteiro para contar deveria se uma variável do tipo inteira (int).

Eu fiz um código demonstrado um display em C (avisando novamente eu não sei C++) talvez seja útil.

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

/* Informações internas do display */
/* Seria os campos privados do objeto */
struct info_display
{
    int max_buffer;
    char *buffer;
};

/* Metodos do objeto */

void limpaDisplay(struct info_display *display);
/* 
 * Limpa todos os caracteres no display
 */

void iniciaDisplay(struct info_display *display, int max_caracteres);
/*
 * Inicia o display com a quantidade de caracteres suportados
 */

void atualizaDisplay(struct info_display *display);
/*
 * Mostra o display para o usuario
 */

void adicionaCaractereDisplay(struct info_display *display, char caractere);
/*
 * Coloca caracteres no display
 */

void apagaUltimoCaractereDisplay(struct info_display *display);
/*
 * Remove o ultimo caractere adicionado no display
 */

void liberaDisplay(struct info_display *display);
/*
 * Apaga a memoria reservada para o display
 */

int main(void)
{
    struct info_display display;
    iniciaDisplay(&display, 10);

    printf("Primeira atualizacao\n");

    adicionaCaractereDisplay(&display, '1');
    adicionaCaractereDisplay(&display, '3');
    adicionaCaractereDisplay(&display, '7');
    atualizaDisplay(&display);

    printf("Segunda atualizacao\n");

    apagaUltimoCaractereDisplay(&display);
    adicionaCaractereDisplay(&display, 'C');
    atualizaDisplay(&display);

    printf("Terceira atualizacao\n");

    limpaDisplay(&display);
    atualizaDisplay(&display);
    
    liberaDisplay(&display);
    return(0);
}

void limpaDisplay(struct info_display *display)
{
    int contador = 0;
    for (contador = 0; contador < display->max_buffer; contador++)
    {
        display->buffer[contador] = '\0';
    }
}

void iniciaDisplay(struct info_display *display, int max_caracteres)
{
    /* Reserva a quantidade caracteres maxíma do display */
    display->buffer = malloc(sizeof(*display->buffer)*display->max_buffer);

    /* Se foi possivel reservar memoria então limpa o display */
    if (display->buffer != NULL) {
        display->max_buffer = max_caracteres;
        limpaDisplay(display);
    } else {
        display->buffer = NULL;
    }
}

void atualizaDisplay(struct info_display *display)
{
    int contador;
    /* Mostra uma linha */
    for (contador = 0; contador < display->max_buffer; contador++) {
        putchar('-');
    }

    putchar('\n');

    /* Mostra o conteudo do display */
    printf("%s\n",display->buffer);

    /* Mostra uma linha */
    for (contador = 0; contador < display->max_buffer; contador++) {
        putchar('-');
    }

    putchar('\n');
}

void adicionaCaractereDisplay(struct info_display *display, char caractere)
{
    int contador;
    for (contador = 0; contador < display->max_buffer-1 && display->buffer[contador]; contador++);

    if (contador < display->max_buffer-1) {
        display->buffer[contador] = caractere;
        display->buffer[contador+1] = '\0';
    }
}

void apagaUltimoCaractereDisplay(struct info_display *display)
{
    int contador;
    for (contador = 0; display->buffer[contador]; contador++);

    if (contador > 0) {
        display->buffer[contador-1] = '\0';
    } else {
        display->buffer[contador] = '\0';
    }
}

void liberaDisplay(struct info_display *display)
{
    if (display->buffer != NULL) {
        free(display->buffer);
    }
}

Defina o que cada objeto em seu programa faz, e coloque cada um para fazer a sua tarefa com perfeição.

4 horas atrás, souza souza00 disse:

postei em forma de pasta porque precisa abrir os 3 algoritmos pra calculadora funcionar.

você pode postar no replit ou no onlineGDB que fica mais cômodo para  as pessoas visualizarem,

Agora vamos ao código eu não sei C++, mas eu acho que essa calculadora está com muitos objetos para uma calculadora.

Você já parou para pensar o que o objeto Cpu faz? esse objeto está fazendo serviço de outros como

virtual void setDisplay(Display * display) = 0;

Isso não deveria estar em Display? qual é o sentido de display ser configurado por outro objeto?

É aqui nesse trecho

virtual void setDecimalSeparator() = 0;

Pra que ter isso sendo que você poderia ter algo como

void addCharacterToDisplay(const character char);
void removeLastCharacterDisplay();

5 minutos atrás, Midori disse:

O tópico é sobre C

Eu sei que é, mas tudo que eu vejo os outros postarem parece que vem do C++.

6 minutos atrás, Midori disse:

mas como assim "tipificar estrutura"?

Acabei inventando palavra.

seria criar uma sinônimo ou alias, porque você acabou de criar uma estrutura pra que dar um nome que foge do escopo do proposito do mesmo?

Eu não sei se isso e alguma coisa do C++ ou porque eu ainda penso muito em pascal, mas pra mim não faz sentido tipificar uma estrutura.

typedef struct{
    int codigo;
    char descricao[50];
    char fornecedor[50];
    int quantidade;
    float preco_venda;
    float preco_compra;
}Produto;

Isso pra mim parece que meio que "oculta" o tipo, sendo que namespace de estruturas já são distintos de outros tipos de declaração em C.

outra coisa que eu acho estranho e fazer um cast quando está passando endereços(Ponteiros do tipo void) para ponteiros, o cast já não é automático? Ou em C++ e diferente?

prod = (Produto *)malloc(sizeof(Produto) * n);

Não seria melhor fazer assim?

prod = malloc(sizeof(*prod)*n);

Bem mais simples é claro.

Não seria melhor você postar o código?

Assim fica meio difícil de ajudar.

você teria que somar as notas dessa maneira.

    /* Soma todas as notas */
    for (contador = 0; contador < 10; contador++) {
        soma  = soma+notas[contador];
    }

troque a variável contador pela a variável que você estiver usando.

Depois e só dividir pela quantidade de notas.

    /* Tira a media */
    media = soma/10;

e mostrar

    /* Mostra a media nota */
    printf("a media e:%.2f", media);

tudo isso vai depois dessa linha

12 minutos atrás, casa1 disse:

soma = 0;

media = 0;

Apague o resto até o return()

Para exemplificar o que o @mauro_b disse, seria dessa maneira.

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

int main(void)
{
    char tabuleiro[10][10];
    int bombas[10*10];      /* Mesmo tamanho do tabuleiro */
    int linha, coluna;

    /* Inicia o tabuleiro */
    for (linha = 0; linha < 10; linha++) {
        for (coluna = 0; coluna < 10; coluna++) {
            tabuleiro[linha][coluna] = '-';         /* Marca como vazio */
        }
    }

    /* Inicia as bombas */
    for (linha = 0; linha < 10*10; linha++) {
        bombas[linha] = linha;
    }

    /* Inicia o gerador de numeros aletorios com a data e hora do sistema */
    srand(time(NULL));
    /* Embaralha o local das bombas */
    /* Utlizando o algoritomo Fisher–Yates */
    for (linha = 0; linha < 10*10; linha++) {
        int indice, temporario = bombas[linha];
        indice = rand()%(10*10);
        bombas[linha] = bombas[indice];
        bombas[indice] = temporario;
    }

    /* Coloca 20 bombas no tabuleiro */
    for (linha = 0; linha < 20; linha++) {
        /* bombas[linha]%10 = linha */
        /* bombas[linha]/10 = coluna */
        tabuleiro[bombas[linha]%10][bombas[linha]/10] = '*';
    }

    /* Mostra o tabuleiro */
    for (linha = 0; linha < 10; linha++) {
        for (coluna = 0; coluna < 10; coluna++) {
            printf("%c|", tabuleiro[linha][coluna]);
        }
        printf("\n");
    }
    getchar();
    return(0);
}

2 horas atrás, Rodney Junior disse:

 Eu estou com problema na leitura da descrição e do fornecedor, se eu coloco os números usando virgula para separar o preço ele não lê corretamente a parte de descrição e fornecedor nem o preço de venda, ai vira uma bagunça e sai errado, porém se eu coloco com ponto ele lê corretamente. Queria saber como corrigir isso pra ele executar normalmente tanto com um quanto com o outro

Se o seu sistema operacional estiver configurado para português e só você usar a função setlocale.

Exemplo

	setlocale(LC_ALL, "");

Vai configurar o programa para aceitar a região atual do sistema.

É o seu programa está muito mal organizado, e eu acho que está saindo fora do enunciado.

Aqui está pedindo para fazer uma função que sirva como menu.

Em 04/05/2021 às 00:33, Rodney Junior disse:

a. Procedimento para imprimir na tela um menu de opções, conforme abaixo, o qual lê do usuário a opção informada e a retorna:

Você escreveu o menu direto na função main() eu acho que está errado.

Eu recomendo você começar de novo!

Um exemplo inicial de como seria o programa seguindo o enunciado.

Exemplo no replit

6 horas atrás, AsafeBernardoOficial disse:

@kgin não postei o enunciado pelo medo de estar entregando a questão de bandeja, como sei que no fórum ninguém faz trabalho para outros, decidi só botar o problema específico que eu estava enfrentando no código.

Eu já vi essa mesma questão varias vezes aqui no fórum, então eu acho que a chance de alguém copiar logo o seu é baixa.

@AsafeBernardoOficial Você ainda está inicializando o vetor de uma forma que só e valida em C++.

6 horas atrás, AsafeBernardoOficial disse:

qtd_produto[5]={}

Coloque um 0 entre as chaves para ser valido em C.

O vetor total_itens[] não tem posições validas.

Eu recomendo você começar de novo.

Eu fiz um exemplo mas eu acho que ficou muito extenso para postar no fórum, então eu vou deixar no replit.

https://replit.com/@KGin/SandwichStore#main.c

Lembrei de alguns anos atrás que eu ligava esses monitores lcd na porta paralela do computador para mostrar algumas informações inúteis e alguns desenhos.

Desse jeito.

Não poderia ser ao invés de gerar essa sequencia aleatória você já tivesse um vetor com a sequencia de 1 a 9 depois e só embaralhar o vetor.

Exemplo.

O programa está rodando na janela de baixo, Eu não tinha nada para recordar a imagem

O programa mostra um vetor de 1 a 9 embaralhado, depois pede a jogado do jogador, e por fim comparar quantos números o jogador acertou.

Código do exemplo.

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

#define Q_NUMEROS 9

int main(void)
{
    int numeros[Q_NUMEROS], jogador[Q_NUMEROS], maquina[Q_NUMEROS];
    int contador, quantidade = 0;
    /* Inicia os vetores */
    for (contador = 0; contador < Q_NUMEROS; contador++) {
        numeros[contador] = contador+1;
        jogador[contador] = maquina[contador] = 0;
    }

    /* Gera os numeros do jogo */
    srand(time(NULL));
    for (contador = 0; contador < Q_NUMEROS; contador++) {
        /* Troca os numeros de posição no vetor */
        int indice = rand()%Q_NUMEROS, tmp = numeros[contador];
        numeros[contador] = numeros[indice];
        numeros[indice] = tmp;
    }

    /* Mostra o vetor */
    printf("Memorize os numeros!\n");
    for (contador = 0; contador < Q_NUMEROS; contador++) {
        printf("%i\n", numeros[contador]);
    }

    /* Coloque alguma coisa para fazer um atraso e apague a tela */

    /* Pega os numeros do jogador */
    printf("Digite a sequecia anterior\n");
    for (contador = 0; contador < Q_NUMEROS; contador++) {
        scanf("%i%*c", &jogador[contador]);
    }

    /* Conta a quantidade de acertos */
    for (contador = 0; contador < Q_NUMEROS; contador++) {
        if (numeros[contador] == jogador[contador]) {
            quantidade++;
        }
    }

    if (quantidade == Q_NUMEROS) {
        printf("voce ganhou!\nAcertou todos os numeros\n");
    } else {
        printf("voce perdeu!\nVoce acertou %i numeros\n", quantidade);
    }
    getchar();
    return(0);
}

Quando for postar o seu código fonte no fórum use o botão code <>, porque quase ninguém vai querer ajudar com o código assim.

@luarxx Isso envolve o próprio sistema de anti-cheat do jogo também, a maioria dos jogos de tiro (como COD, CS) tem sistemas anti-cheat para esse tipo de programa ou script.

Seria algo inútil se você não burlasse o sistema de anti-cheat do próprio jogo primeiro, que é uma coisa que eu suponho que você não consegue fazer.

Recomendo você usar aquela estrategia das antigas, compre um mouse com o DPI alto e aprenda a jogar!

Bah, tchê eu acho que dessa vez não deu!

kkkkk

4 horas atrás, Maria Cristina Oliveira disse:

Na idade dele eu só brincava de boneca.  

 

Creio eu que na sua época eletrônica digital não era uma coisa tão acessível kkkk.

@Diegolv Na minha opinião a parte mais difícil não é montar o hardware para isso, é sim programar o jogo em si.

Jogos como o super mario world tem mecânicas complicadas de reproduzir, como a distancia entre os inimigos e as colisões entre os objetos.

Eu recomendo você aprender a programar alguns jogos pequenos primeiro em uma maquina mais potente para só depois tentar entrar de cabeça nessa empreitada.

Outra ideia seria usar o vetor só para marcar se a esfera foi encontrada.

Exemplo em C:

#include <stdio.h>

#define Q_ESFERAS 7

int main(void)
{
    int esferas[Q_ESFERAS];
    int contador, quantidade_esferas = 0, esfera, esferas_pegas = 0;

    /* Inicia as esferas */
    for (contador = 0; contador < Q_ESFERAS; contador++) {
        esferas[contador] = 0;
    }

    /* Pega a quantidade de esferas */
    scanf("%i%*c", &quantidade_esferas);

    /* Pega as esferas */
    for (contador = 0; contador < quantidade_esferas; contador++) {
        scanf("%i%*c", &esfera);
        if (esfera >= 1 && esfera <= 7) {
            esferas[esfera-1] = 1;
        }
    }

    /* Conta a quantidade de esferas pegas */
    for (contador = 0; contador < Q_ESFERAS; contador++) {
        if (esferas[contador]) {
            esferas_pegas++;
        }
    }

    /* Mostra as esferas pegas */
    for (contador = 0; contador < Q_ESFERAS; contador++) {
        if (esferas[contador]) {
            printf("%i ", contador+1);
        }
    }

    if (esferas_pegas == Q_ESFERAS) {
        printf("\nSaia Shenlong e realize o meu desejo\n");
    } else {
        printf("\nNao encontramos todas\n");
    }

    getchar();
    return(0);
}

programação não é difícil, o problema para a maioria dos brasileiros é que principalmente na linguagem C não tem muito material em português.

Outro problema meio que grande pra mim é que a maioria (não sei se é por preguiça) das pessoas utiliza um compilador de C++ para C que a principio resolve o problema, mas com o tempe se torna o problema.

Poste o enunciado para nós podermos entender melhor o algoritmo.

Se você utiliza um display lcd e alguns botões em um pic, eu acho que seja possível Fazer o que você quer.

Exemplo:https://youtu.be/MqgDtsCpD2Y

É em um arduino, mas dá para adaptar para o pic.

@devair1010 Não acho que alguém aqui se importe com isso, mas o seu código não é compatível com C por causa da inicialização de variáveis.

48 minutos atrás, devair1010 disse:

float cr1{}, cr2{}, cr3{}, cr4{};

As chaves só são validas em C++

@Andrielli Não sei portugol, mas eu acho que seria algo assim.

	resultado = (B+M+R)\3
      escreva(resultado)

Se eu entendi bem você pegou 3 números, e quer tirar a media entre eles?

Não seria só somar os 3 números e dividir por 3?

59 minutos atrás, Kyul disse:

AVISO: vetores (arrays) na linguagem C e C++ são ponteiros constantes. Matrizes, especificamente, são um vetor de ponteiros (array of pointers). Acredito que essa informação não mude de compilador para compilador. Por este motivo, no retorno da função, a matriz original é alterada.

Experimente fazer o seguinte:

Seu exemplo está errado!

Direto do livro C completo e total pagina 92.

Citação

Uma matriz(unidimensional) é uma coleção de variáveis do mesmo tipo que é referenciada por um nome comum.
Um elemento especifico em uma matriz é acessado por meio de um índice. em C, todas as matrizes consistem em
posições contíguas na memória. o endereço mais baixo corresponde ao primeiro elemento e o mais alto,
ao último elemento. Matrizes podem ter de uma a várias dimensões. A matriz mais comum em C é a string,
que é simplesmente uma matriz de caracteres terminadas por um nulo. Essa abordagem a strings dá a C maior
poder e eficiência que às outras linguagens.

Recomendo ler a sessão sobre ponteiros também.

Um exemplo "correto".

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

int (*devolve(void))[4]
{
    int (*matriz)[4] = malloc(sizeof(int[4][4]));
    int linhas, colunas, contador = 0;
    for (linhas = 0; linhas < 4; linhas++) {
        for (colunas = 0; colunas < 4; colunas++) {
            matriz[linhas][colunas] = contador;
            contador++;
        }
    }
    return(matriz);
}

int main(void)
{
    int (*ponteiro)[4], linhas, colunas;
    /* Pega a matriz alocada dinamicamente */
    ponteiro = devolve();
    /* Mostra a matriz */
    for (linhas = 0; linhas < 4; linhas++) {
        for (colunas = 0; colunas < 4; colunas++) {
            printf("%i|", ponteiro[linhas][colunas]);
        }
        putchar('\n');
    }
    /* Espera a tecla enter */
    getchar();
    /* Apaga a matriz */
    free(ponteiro);
    return(0);
}

Creio eu que esse meu exemplo deva sanar qualquer duvida sobre ponteiros e matrizes.

Poste o que você já fez.