kgin

26 minutos atrás, GustavoZN disse:

Desenvolver um programa para que o usuário possa realizar a digitação de dois números (número inicial e número final). Dentro de uma estrutura de repetição será preciso verificar se o número que está sendo alimentado é um número par ou ímpar. A checagem do número deverá ser feita em uma função a ser criada. A função é quem deverá verificar a informação recebida e retornar o status se é par ou ímpar. Dentro da estrutura de repetição será preciso exibir uma mensagem com o valor do número e mais uma frase dizendo se ele é par ou ímpar. Após o término da estrutura de repetição será preciso informar a quantidade total de números pares encontrados.>

Aqui.

checa_impar.com.zip

Funciona no windows e linux.

53 minutos atrás, devair1010 disse:

 o enunciado diz para verificar na listagem , já existente ,  de matriculas , e então não precisa pegar essas informações do usuário ,

Pois é, mas logo em seguida o enunciado diz

4 horas atrás, kgin disse:

Após ler essas listagens verifique quem são os alunos.

após ler essas listagens, ler de onde?

Ou só é para comparar o vetor já carregado?

Como eu disse o enunciado está meio vago, não explica muito bem o que é pra fazer.

59 minutos atrás, sthearc disse:

O Departamento de Computação deseja saber se existem alunos cursando, simultaneamente, as disciplinas D1 e D2. Existe disponível uma listagem com os números de matrículas dos alunos das duas disciplinas. Após ler essas listagens verifique quem são os alunos.

Eu não sei se entendi direito, mas você não deveria ler dois vetores do usuário?

Dessa maneira

    int d1[Q_ALUNOS], d2[Q_ALUNOS], quantidade_alunos = 0;
    int contador1, contador2;

    for (contador1 = 0; contador1 < Q_ALUNOS; contador1++) {
        printf("Digite o aluno da matricula [%d] da turma d1\n", contador1);
        scanf("%d%*c",&d1[contador1]);
    }

    for (contador1 = 0; contador1 < Q_ALUNOS; contador1++) {
        printf("Digite o aluno da matricula [%d] da turma d2\n", contador1);
        scanf("%d%*c",&d2[contador1]);
    }

Depois não seria só verificar os alunos?

1 hora atrás, sthearc disse:

Após ler essas listagens verifique quem são os alunos.

    for (contador1 = 0; contador1 < Q_ALUNOS; contador1++) {
        for (contador2 = 0; contador2 < Q_ALUNOS; contador2++) {
            if (d1[contador1] == d2[contador2]) {
                printf("O aluno %i esta matriculado na matricula [%d] da turma d1 e na matricula [%d] da turma d2\n", d1[contador1], contador1, contador2);
            }
        }
    }

Exemplo completo.

#include <stdio.h>


#define Q_ALUNOS 5


int main(void)
{
    int d1[Q_ALUNOS], d2[Q_ALUNOS], quantidade_alunos = 0;
    int contador1, contador2;

    for (contador1 = 0; contador1 < Q_ALUNOS; contador1++) {
        printf("Digite o aluno da matricula [%d] da turma d1\n", contador1);
        scanf("%d%*c",&d1[contador1]);
    }

    for (contador1 = 0; contador1 < Q_ALUNOS; contador1++) {
        printf("Digite o aluno da matricula [%d] da turma d2\n", contador1);
        scanf("%d%*c",&d2[contador1]);
    }

    for (contador1 = 0; contador1 < Q_ALUNOS; contador1++) {
        for (contador2 = 0; contador2 < Q_ALUNOS; contador2++) {
            if (d1[contador1] == d2[contador2]) {
                printf("O aluno %i esta matriculado na matricula [%d] da turma d1 e na matricula [%d] da turma d2\n", d1[contador1], contador1, contador2);
            }
        }
    }
    return(0);
}

Ao menos foi isso que eu entendi (o enunciado e meio vago também) .

31 minutos atrás, sthearc disse:

Olá, estou estudando programação em c++, então não sou muito boa, estou fazendo um exercício sem sucesso algum  

Qual seria o curso ou material que você está utilizando para aprender?

32 minutos atrás, sthearc disse:

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

Eu vejo essa linha em vários algoritmos aqui no fórum e isso me deixou curioso para saber de onde vem.

Agora vamos ao seu código, ele está correto só que você colocou o simbolo de igual "==" aqui

35 minutos atrás, sthearc disse:

 x[i] == '@';

Ao invés do simbolo de atribuição "="

	x[i] = '@';

Com isso resolve o problema.

Uma melhoria para o seu programa seria colocar o caractere de controle %*c no scanf

	scanf("%c%*c", &x[i]);

Por hora e melhor usar o %*c do que um espaço, ele com o tempo deixa as coisa um pouco complicadas e mais para frente e melhor usar fgets para ler a entrada.

outra melhoria seria colocar um loop a mais para mostrar a modificação do vetor.

dessa maneira

	for (i=0; i<tam; i++){
        printf("nova sequencia  %c \n", x[i]);
    }

Código consertado.

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

#define tam 5
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char** argv) {
   char x[tam];
    int i;

    for (i=0; i<tam; i++) {
        printf("Digite um caracter: ");
        scanf(" %c", &x[i]);
    }
    
    for (i=0; i<tam; i++){
        if (x[i]=='a'){
            x[i] = '@';
        }
    }

    for (i=0; i<tam; i++){
        printf("nova sequencia  %c \n", x[i]);
    }
    return 0;
}

Agora e só adicionar as outras vogais.

É você não está escrevendo nada na linguagem C++ tudo isso que você fez e em C.

@criatividade Qual seria o erro que você está recebendo?

por que ao meu ver o algoritmo está correto, mas você está usando uma biblioteca que o meu compilador não tem e provavelmente o seu também não deve ter.

19 minutos atrás, criatividade disse:

#include <conio.h>

essa biblioteca não e implementada mais desde o borland turbo c++(do sistema DOS) então o que eu fiz foi tirar ela e colocar a cstdio e trocar o getch() por getchar()

#include <iostream>
#include <cstdio>
#include <math.h>

using namespace std;

int X_elevado_a_Z(int X, int Z)
    {
        int i,potencia=1;
        for (i=1; i<=Z; i++)
            potencia = potencia*X;
        return (potencia);
    }
    int main ()
    {
        int a,b;
        cout << "Escreva X\n";
        cin >> a;
        cout << "\nEscreva Z\n";
        cin >> b;
        cout << "\n------------------------\nX elevado a Z = " << X_elevado_a_Z(a,b);
        getchar ();
    }

tá aí!

funcionando perfeitamente.

14 minutos atrás, isrnick disse:

Mas não reduz o código muito, a vantagem é que também funciona para tamanhos de velha maiores do que 3x3, mas esse é o tamanho padrão do jogo da velha.

Se a minha memoria não me falha (que com certeza ela falha) eu acho que isso serve para aquele jogo chines chamado go também.

Eu dei uma olha do seu código e a ideia e realmente a mesma, mas aquele código do devair o cara tava aprendendo e criptografia porque eu não entendi nada daquele código dele.

Poste o que você já fez para podermos ajudá-lo.

@Leanderson Pinheiro Poderia ser feito dessa maneira também.

int linhas, colunas, objeto, vezes;

    /* Checa as linhas */
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        vezes = 1;
        objeto = tabuleiro[linhas][0];
        for (colunas = 1; colunas < Q_COLUNAS; colunas++) {
            if (objeto == tabuleiro[linhas][colunas]) {
                vezes++;
            }
        }

        if ((vezes == Q_LINHAS)&&(objeto != TAB_VAZIO)) {
            return(objeto);
        }
    }

Código do exemplo.

#include <stdio.h>

#define Q_LINHAS 3
#define Q_COLUNAS 3

#define TAB_VAZIO 0
#define TAB_X 1
#define TAB_O 2
#define TAB_VELHA 3

void mostraTabuleiro(int tabuleiro[Q_LINHAS][Q_COLUNAS]);

int checaVitoria(int tabuleiro[Q_LINHAS][Q_COLUNAS]);

int main(void)
{
    int vitoria;
    /* Velha */
    int tabuleiro1[Q_LINHAS][Q_COLUNAS] = {{1,2,1},
                                           {2,1,1},
                                           {1,2,2}};

    /* X */
    int tabuleiro2[Q_LINHAS][Q_COLUNAS] = {{1,2,1},
                                           {2,1,1},
                                           {1,2,1}};

    /* O */
    int tabuleiro3[Q_LINHAS][Q_COLUNAS] = {{2,2,1},
                                           {1,2,1},
                                           {1,2,2}};

    printf("\ntabuleiro 1\n");
    mostraTabuleiro(tabuleiro1);
    vitoria = checaVitoria(tabuleiro1);
    switch (vitoria) {
        case TAB_O:
            printf("Vitoria do O\n");
            break;

        case TAB_X:
            printf("Vitoria do X\n");
            break;

        case TAB_VELHA:
            printf("Deu velha!\n");
            break;

        default:
            printf("Ninguem ganhou ainda!\n");
    }

    printf("\ntabuleiro 2\n");
    mostraTabuleiro(tabuleiro2);
    vitoria = checaVitoria(tabuleiro2);
    switch (vitoria) {
        case TAB_O:
            printf("Vitoria do O\n");
            break;

        case TAB_X:
            printf("Vitoria do X\n");
            break;

        case TAB_VELHA:
            printf("Deu velha!\n");
            break;

        default:
            printf("Ninguem ganhou ainda!\n");
    }

    printf("\ntabuleiro 3\n");
    mostraTabuleiro(tabuleiro3);
    vitoria = checaVitoria(tabuleiro3);
    switch (vitoria) {
        case TAB_O:
            printf("Vitoria do O\n");
            break;

        case TAB_X:
            printf("Vitoria do X\n");
            break;

        case TAB_VELHA:
            printf("Deu velha!\n");
            break;

        default:
            printf("Ninguem ganhou ainda!\n");
    }

    getchar();
    return(0);
}

void mostraTabuleiro(int tabuleiro[Q_LINHAS][Q_COLUNAS])
{
    int linhas, colunas;
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        for (colunas = 0; colunas < Q_COLUNAS; colunas++) {
            if (colunas < Q_COLUNAS-1) {
                if (tabuleiro[linhas][colunas] == TAB_X) {
                    printf("X|");
                } else {
                    printf("O|");
                }
            } else {
                if (tabuleiro[linhas][colunas] == TAB_X) {
                    printf("X");
                } else {
                    printf("O");
                }
            }
        }
        putchar('\n');
    }
}

int checaVitoria(int tabuleiro[Q_LINHAS][Q_COLUNAS])
{
    int linhas, colunas, objeto, vezes;

    /* Checa as linhas */
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        vezes = 1;
        objeto = tabuleiro[linhas][0];
        for (colunas = 1; colunas < Q_COLUNAS; colunas++) {
            if (objeto == tabuleiro[linhas][colunas]) {
                vezes++;
            }
        }

        if ((vezes == Q_LINHAS)&&(objeto != TAB_VAZIO)) {
            return(objeto);
        }
    }

    /* Checa as colunas */
    for (colunas = 0; colunas < Q_COLUNAS; colunas++) {
        vezes = 1;
        objeto = tabuleiro[0][colunas];
        for (linhas = 1; linhas < Q_LINHAS; linhas++) {
            if (objeto == tabuleiro[linhas][colunas]) {
                vezes++;
            }
        }

        if ((vezes == Q_COLUNAS)&&(objeto != TAB_VAZIO)) {
            return(objeto);
        }
    }

    /* Checa a diagonal esquerda */
    /* X|_|_
     * _|X|_
     *  | |X
     */
    objeto = tabuleiro[0][0];
    vezes = 1;
    for (linhas = colunas = 1; linhas < Q_LINHAS || colunas < Q_COLUNAS; linhas++, colunas++) {
        if (objeto == tabuleiro[linhas][colunas]) {
            vezes++;
        }
    }

    if ((vezes == Q_LINHAS || vezes == Q_COLUNAS) && (objeto != TAB_VAZIO)) {
        return(objeto);
    }

    /* Checa a diagonal direita */
    /* _|_|X
     * _|X|_
     * X| |
     */
    objeto = tabuleiro[0][Q_COLUNAS-1];
    vezes = 1;
    for (linhas = 0, colunas = Q_COLUNAS-2; linhas < Q_LINHAS || colunas > 0; linhas++, colunas--) {
        if (objeto == tabuleiro[linhas][colunas]) {
            vezes++;
        }
    }

    if ((vezes == Q_LINHAS || vezes == Q_COLUNAS) && (objeto != TAB_VAZIO)) {
        return(objeto);
    }

    /* Checa se deu velha ou galo */
    vezes = 0;
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        for (colunas = 0; colunas < Q_COLUNAS; colunas++) {
            if (tabuleiro[linhas][colunas] == TAB_O || tabuleiro[linhas][colunas] == TAB_X) {
                vezes++;
            }
        }
    }

    if (vezes == (Q_LINHAS*Q_COLUNAS)) {
        return(TAB_VELHA);
    }

    /* Ninguém ganhou ainda */
    return(TAB_VAZIO);
}

@Atomicsub7 Não sei se isso te ajuda, mas eu dei uma modificada nessa lista que eu tenho aqui

/* Lista encadeada generica */
#include <stdio.h>
#include <stdlib.h>

struct no_t
{
    int valor;
    struct no_t *anterior, *proximo;
};

struct lista_t
{
    struct no_t *inicio, *fim;
};

void
apagaNo(struct no_t **no);
/*
 * Apaga apenas um nó
 */

struct no_t
*criaNo(int valor);
/*
 * Cria um nó
 */

void
apagaLista(struct lista_t **lista);
/*
 * Apaga toda uma lista
 */

struct lista_t
*criaLista(void);
/*
 * Cria uma lista vazia
 */

struct no_t
*colocaNoInicio(struct lista_t *lista, int valor);
/*
 * Coloca um nó no inicio da lista e devolve o nó colocado
 */

struct no_t
*colocaNoFim(struct lista_t *lista, int valor);
/*
 * Coloca um nó no fim da lista e devolve o nó colocado
 */

int main(void)
{
    struct lista_t *lista = criaLista();
    struct no_t *no = NULL;

    colocaNoFim(lista, 10);
    colocaNoFim(lista, 11);
    colocaNoFim(lista, 12);
    colocaNoInicio(lista, 1);
    colocaNoInicio(lista, 2);
    colocaNoInicio(lista, 3);

    printf("Mostra a lista do comeco ao fim\n");
    no = lista->inicio;
    while (no != NULL) {
        printf("%d\n", no->valor);
        no = no->proximo;
    }

    printf("Mostra a lista do fim ao comeco\n");
    no = lista->fim;
    while (no != NULL) {
        printf("%d\n", no->valor);
        no = no->anterior;
    }

    apagaLista(&lista);
    return(0);
}

void
apagaNo(struct no_t **no)
{
    if (*no != NULL) {
        (*no)->anterior = (*no)->proximo = NULL;
        free(*no);
    }
    *no = NULL;
}

struct no_t
*criaNo(int valor)
{
    struct no_t *no = malloc(sizeof(*no));
    if (no != NULL) {
        no->anterior = no->proximo = NULL;
        no->valor = valor;
        return(no);
    }

    return(NULL);
}

void
apagaLista(struct lista_t **lista)
{
    if (*lista != NULL) {
        struct no_t *tmp = (*lista)->inicio;
        while (tmp != NULL) {
            struct no_t *aux = tmp->proximo;
            apagaNo(&tmp);
            tmp = aux;
        }
        (*lista)->inicio = (*lista)->fim = NULL;
        free(*lista);
    }

    (*lista) = NULL;
}

struct lista_t
*criaLista(void)
{
    struct lista_t *lista = malloc(sizeof(*lista));

    if (lista != NULL) {
        lista->inicio = lista->fim = NULL;
        return(lista);
    }
    return(NULL);
}


struct no_t
*colocaNoInicio(struct lista_t *lista, int valor)
{
    struct no_t *no = criaNo(valor);

    if (no != NULL) {
        if (lista->inicio == NULL) {
            lista->inicio = lista->fim = no;
        } else {
            lista->inicio->anterior = no;
            no->proximo = lista->inicio;
            lista->inicio = no;
        }
        return(no);
    }

    return(NULL);
}

struct no_t
*colocaNoFim(struct lista_t *lista, int valor)
{
    struct no_t *no = criaNo(valor);
    if (no != NULL) {
        if (lista->inicio == NULL) {
            lista->inicio = lista->fim = no;
        } else {
            lista->fim->proximo = no;
            no->anterior = lista->fim;
            lista->fim = no;
        }
        return(no);
    }

    return(NULL);
}

Eu não consegui compilar o seu algoritmo

Eu acho que seria melhor você postar o código completo, por que assim está meio difícil de entender o que está errado.

@Atomicsub7 Mas a entrada e fixa?

Digamos assim o usuário vai digitar x números na entrada?

1 hora atrás, Atomicsub7 disse:

preciso de um programa em C, que recebe o valor de uma carta se for maior que a anterior e colocado no fim da fila se for menor que a anterior é colocada no início 

eu cheguei a escrever esse código, se alguém puder dar aquele help

mas o que você quer fazer exatamente?

@Carolmarton você deveria começar assim ao invés de começar pelo menu

#include <stdio.h>

#define T_FRASE 6

char frase[T_FRASE];


void adiciona(void);

void imprime(void);

int main(void)
{
    adiciona();
    imprime();
    return(0);
}

void adiciona(void)
{
    printf("Digite alguma coisa de ate %d letras\n", T_FRASE-1);
    scanf("%[^\n]s", frase);	/* Recomendo usar fgets() para pegar uma string */
}

void imprime(void)
{
    printf("voce digitou %s\n", frase);
}

1 hora atrás, Carolmarton disse:

A)  Adicionar letras
void adicionar();
Um vetor de 5 posições deverá ser declarado em área global, bem como sua
dimensão. O usuário deve inserir todas as letras de uma vez, na chamada
deste módulo.

Se você começar por aqui e depois ir para

1 hora atrás, Carolmarton disse:

E)  Imprimir
void imprimir();
Imprime todos os elementos do vetor

Depois e só continuar fazendo as funções para no final fazer o menu.

esse exemplo no replit

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

45 minutos atrás, Carolmarton disse:

Um tempo atrás fiz esse, acredito que será mais o menos isso, só preciso colocar em módulos e incrementar o modulo contar, também preciso usar ponteiros no módulo contar, será minha maior dificuldade já que não peguei a manha de ponteiros ainda.

sim, é mais ou menos isso só que com caracteres.

para contar quantas as vogais e as consoantes não é tão difícil assim, faça algo mais ou menos assim.

void conta(int *vogais, int *consoantes)
{
    int contador;
    *vogais = *consoantes = '\0';
    for (contador = 0; frase[contador] != '\0'; contador++) {
        switch (frase[contador]) {
            case 'a':
            case 'A':
                (*vogais)++;
                break;

            case 'e':
            case 'E':
                (*vogais)++;
                break;
            
            case 'i':
            case 'I':
                (*vogais)++;
                break;

            case 'o':
            case 'O':
                (*vogais)++;
                break;

            case 'u':
            case 'U':
                (*vogais)++;
                break;

            default:
                if ((frase[contador] >= 'A' && frase[contador] <= 'Z') ||
                   (frase[contador] >= 'a' && frase[contador] <= 'z'))
                    (*consoantes)++;
        }
    }
}

Poste o que você já fez para nos podermos ajudá-lo.

poste o que você já fez para nos podermos ajudar.

@Um mero usuário Para você utilizar a ncurses você precisa iniciá-la primeiro dessa maneira.

	initscr(); 		/* Inicia a ncurses */

depois de iniciada você pode escrever ou pegar algo da saída padrão com as funções.

/* Funções de saida */
	printw();		/* Funciona igual a printf() */
	addch();
	addstr();

/* Funções de entrada */
	scanw();		/* Funciona igual a scanf() */
	getch();
	getstr();

você também não precisa incluir o cabeçalho stdio.h a ncurses inclui automaticamente ele e o termios.h.

Quando você utilizar uma das funções de saída (como printw()) você tem que utilizar a função refresh()

	refresh();		/* Atualiza as informções do terminal */

Quando o seu programa terminar você tem que chamar a função endwin()

	endwin(); 		/* Finaliza a ncurses */

Ela vai restaurar todas as cagadas que você fez com o termios.h, por isso eu não recomendo a solução do @Lucca Rodrigues porque ela mexe direto com as configurações do terminal.

Um programa básico com ncurses é assim.

#include <ncurses.h>

int main(void)
{
	initscr(); 		/* Inicia a ncurses */

	printw("Ola mundo!\n");

	refresh(); 		/* Atualiza o terminal */

	getchar(); 		/* Espera a tecla enter */

	endwin(); 		/* Finaliza a ncurses */
	return(0);
}

Para compilar você utiliza a linha de comando

gcc NOME_DO_ARQUIVO.c -o NOME_DO_EXECUTAVEL -Wall -lncurses

para um tutorial bem mais completo e detalhado de uma olhada nesse site.

https://tldp.org/HOWTO/NCURSES-Programming-HOWTO/

Boa sorte!

10 minutos atrás, TsunaY disse:

@kgin Não, a unica coisa que sei é que tem que usar Struct

Sim você vai ter que usar estruturas (struct) e vetores para fazer esse algoritmo.

você deveria fazer algo assim para começar

#include <stdio.h>


struct info_aluno
{
    char nome[60];
    int ira;
    int ano;
};


int main(void)
{
    struct info_aluno aluno;
    /* Pega as informações do aluno */
    printf("Digite o nome do aluno\n");
    fgets(aluno.nome, 60, stdin);

    printf("Digite o IRA do aluno\n");
    scanf("%d%*c", &aluno.ira);

    printf("Digite o ano de inicio da graduacao\n");
    scanf("%d%*c", &aluno.ano);

    /* Mostra as informações do aluno */
    printf("Nome do aluno:%s", aluno.nome);
    printf("IRA:%d\n", aluno.ira);
    printf("Ano:%d\n", aluno.ano);

    getchar();      /* Pausa o programa */
    return(0);
}

@TsunaY Mas assim fica meio difícil de ajudar, você já escreveu alguma coisa?

@TsunaY Qual seria a sua duvida?

1 minuto atrás, thefill disse:

E uma outra pergunta, o que seria esse "IRA"? Poderia me explicar?

índice de rendimento acadêmico (IRA).

@Leoprog você já estudou alguma coisa sobre a linguagem C?

eu fiz um pedaço do que está pedindo para você ter uma ideia de como é.

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

//-------------------------------------------------------------
// Protótipos das funções
int menu();

// As funções abaixo devem imprimir o resultado das operações
// realizadas com os números passados por parâmetro.
void soma(int num1, int num2);
void subtracao(int num1, int num2);
void multiplicacao(int num1, int num2);
void divisao(int num1, int num2);

// Imprime a tabuada conforme exercícios anteriores
void tabuada(int inicio, int fim);

//-------------------------------------------------------------
// Função main
int main()
{
    int num1, num2;
    int opcao = 0;


    opcao = menu();
    printf("voce selecionou a opcao: %d\n", opcao);

    printf("digite o primeiro numero da operacao\n");
    scanf("%d%*c", &num1);

    printf("digite o segundo numero da operacao\n");
    scanf("%d%*c", &num2);

    switch (opcao) {
        case 1:
            soma(num1, num2);
            break;

        case 2:
            subtracao(num1, num2);
            break;

        case 4:
            multiplicacao(num1, num2);
            break;
    }


    // Utilizar o laço while para executar enquanto
    // não seja digitada a opção sair.

    // Criar um menu utilizando a variavel opção para escolher
    // Qual função deverá chamar.

    // Solicitar os dois numeros que serão passados por parâmetro

    return 0;
}

//-------------------------------------------------------------
// Implementação da função menu

int menu(){

    int opcao;  // Declara a variável que será utilizado dentro da função

    // Imprime as opções do menu.
    printf("01 - Soma\n");
    printf("02 - Subtracao\n");
    printf("03 - Divisao\n");
    printf("04 - Multiplicacao\n");
    printf("05 - Tabuada\n");
    printf("09 - Sair\n\n");


    printf("Informe a opcao: ");    // Solicita a opção.
    scanf("%d",&opcao);             // Lê o valor digitado pelo usuário.

    return opcao;                   // Retorna o valor para quem chamou
                                    // a função menu.
}

//-------------------------------------------------------------
// Implementar as demais funções conforme os protótipos apresentados.

void soma(int num1, int num2){
    printf("A soma dos numeros informados eh: %d", num1 + num2);
}

void subtracao(int num1, int num2){
    printf("A subtracao dos numeros informados eh: %d", num1 - num2);
}

void multiplicacao(int num1, int num2){
    printf("A multiplicacao dos numeros informados eh: %d", num1 * num2);
}

Depois e só completar o resto das operações e colocar o loop while na função main()

@Leoprog Qual seria a sua duvida?

poste o enunciado para nos podermos te ajudar melhor.

2 horas atrás, Um mero usuário disse:

só nao entendi o que aquelas bibliotecas (ctype.h e unistd.h) fazem...

ctype trabalha com caracteres, faz conversões de maiúscula para minuscula (e vice versa), checa se um caractere e um numero ou um gráfico (caracteres gráficos !,@,°,E,...).

já o unistd está aí só para dar um delay com a função usleep (eu poderia ter usado sleep() também).

Uma alternativa se você utilizar linux seria a ncurses.

exemplo

#include <ncurses.h>
#include <ctype.h>
#include <unistd.h>

struct vetor2
{
    int x, y;
};

int main(void)
{
    int tecla;
    struct vetor2 vetor = {1, 1};
    initscr();      /* inicia a ncurses */
    noecho();       /* Não deixa o caractere pressionado aparecer */
    cbreak();       /* Não espera que seja pressionado enter */
    do {
        clear();    /* Apaga a tela */
        printw("Utilize as teclas WASD para se mover, e X para sair\n");
        tecla = getch();    /* pega uma tecla */
        
        switch (toupper(tecla)) {
            case 'A':
                if (vetor.x > 0) {
                    vetor.x--;
                } else {
                    vetor.x = 79;
                }
                break;
                
            case 'D':
                if (vetor.x < 79) {
                    vetor.x++;
                } else {
                    vetor.x = 0;
                }
                break;
                
            case 'W':
                if (vetor.y > 0) {
                    vetor.y--;
                } else {
                    vetor.y = 20;
                }
                break;
                
            case 'S':
                if (vetor.y < 20) {
                    vetor.y++;
                } else {
                    vetor.y = 0;
                }
                break;
        }
        
        move(vetor.y, vetor.x);
        printw("#");
        
        refresh();  /* Atualiza a tela */
        usleep(50000);  /* Faz uma pausa de 50 msec */
    } while (toupper(tecla) != 'X');
    endwin();       /* finaliza a ncurses */
    return(0);
}

para ver o funcionamento do programa.

https://onlinegdb.com/m-r5HCBGB

Não seria melhor você deixar a função de cadastrar só para cadastrar?

Dessa maneira.

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

struct dados_produto
{
    int id;
    int quantidade;
    float preco;
};

void
salvarCadastro(struct dados_produto *produto);

int
cadastraProduto(struct dados_produto *produto);

int main(void)
{
    struct dados_produto produto;
    if (cadastraProduto(&produto)) {
        char opcao;
        printf("id:%d\n", produto.id);
        printf("quantidade:%d\n", produto.quantidade);
        printf("preco:%.2f\n", produto.preco);
        printf("Salvar cadastro no arquivo\n");
        printf("S\\N\n");
        scanf("%c%*c", &opcao);

        if (opcao == 'S' || opcao == 's') {
            salvarCadastro(&produto);
            printf("Cadastro salvo no arquivo\n");
        }
    } else {
        printf("Cadastro descartado\n");
    }
    getchar();
    return(0);
}

void
salvarCadastro(struct dados_produto *produto)
{
    int contador;
    char buffer[256];
    FILE *arq = fopen("Cadastros.csv", "r+");
    if (arq == NULL) {
        arq = fopen("Cadastros.csv", "w+");
        if (arq == NULL) {
            perror("Nao foi possivel de criar ou ler o arquivo");
            exit(EXIT_FAILURE);
        }
    }

    /* Pula todos os cadastros */
    do {
        fgets(buffer, 256, arq);
    } while (!feof(arq));

    /* Salva o cadastro */
    fprintf(arq, "%d,%d,%.2f\n", produto->id, produto->quantidade, produto->preco);

    fflush(arq);

    fclose(arq);
}

int
cadastraProduto(struct dados_produto *produto)
{
    struct dados_produto tmp;
    char opcao;
    do {
        printf("Digite o id do produto\n");
        scanf("%d%*c", &tmp.id);
        printf("Digite a quantidade de produtos\n");
        scanf("%d%*c", &tmp.quantidade);
        printf("Digite o preco do produto\n");
        scanf("%f%*c", &tmp.preco);

        printf("O cadastro esta correto\n");
        printf("S\\N\n");
        scanf("%c%*c", &opcao);
        if (opcao == 'S' || opcao == 's') {
            *produto = tmp;
            printf("Cadastro feito com sucesso!\n");
            return(1);
        }

        printf("Cadastrar novamente?\n");
        printf("S\\N\n");
        scanf("%c%*c", &opcao);
    } while (opcao == 'S' || opcao == 's');
    return(0);
}

Assim fica mais simples para remover um cadastro depois.

Tudo que você coloca no header (.h) em c vai ser visível quando você incluir em outro arquivo, então sim você colocar suas estruturas e declarações de funções e variáveis no .h se você quiser que seja visível.