C Trabalho em C que envolve criar Contas Bancárias

GustavoolegnA · 18 de março de 2020

O trabalho pede pra:

1 - Cadastrar contas(Somente número, não é necessário char)

2 - Depositar qualquer valor

3 - Sacar qualquer valor

4 - Transferir qualquer valor de uma conta para outra

5 - Listar todas as contas cadastradas com seus respectivos saldos

O problema é: O prazo final tá chegando e eu não sei como desenvolver uma função que armazene um usuário, o compare com pré-existentes e tenha todas as possibilidades que envolvem o dinheiro.

O que conseguir fazer foi um menu funcional, só falta todo o resto.

Por favor compartilhem seus conhecimentos em C comigo.

#include <stdio.h>

void MENU (){

    printf("1 - Cadastrar nova conta\n");
    printf("2 - Depositar valor\n");
    printf("3 - Sacar valor\n");
    printf("4 - Transferir valor de uma conta pra outra\n");
    printf("5 - Listar todas as contas criadas\n");
    printf("Digite a opcao que deseja prosseguir: ");
}
void RC(){//Registro de Conta

}

void LCR(){//Listar Contas Registradas 
    int numdecontas[10], i, j;

    if (numdecontas==0){
        printf("Não há contas registradas");
    }
    if (numdecontas>0){
        for(i=0; i<10; i++)
    {
        printf("As contas sao: %d", numdecontas[i]);
    }
    }


}

int main()
{
    int menu, contas[10], opções, F, i, j;
    float dinheiro;

    do{MENU();
    scanf("%d", &menu);
 
    switch(menu)
    {
        
    case 1://Cadastro
    
        printf("Digite o nome da conta: ");
        scanf("%d", &contas[0]);
        printf("Conta criada com sucesso, o que deseja fazer agora? \n");
        MENU();

    break;

    case 2://Depositar valor
    printf("putz2");
    break;

    case 3://Sacação
    printf("putz3");
    break;

    case 4://Transferização
    printf("putz4");
    break;

    case 5://Listação
    for(i=0; i<10; i++)
    {
        printf("%d = %d", i, contas[i]);
        
    }
    

    default://Retorno ao começo ou Finalizar
     printf("Opção indisponível\n");

     printf("1 - Voltar paras as opções passadas\n Qualquer outro número - Finalizar\n");
     scanf("%d", &F);
    }
    }while(F==1);

    
    
    return 0;
}

Ganz · 18 de março de 2020

Amigo, na questão de armazenar um usuário você pode diferenciá-los por numeração de ID.

arfneto · 18 de março de 2020

Você sabe escrever funções já que escreveu algumas aí.

Antes do programa em C defina o que vai fazer, ou a linguagem não vai te salvar. O enunciado é muito vago, ou você não postou a história toda

Se for só isso mesmo como descreveu, sugiro o mais simples:

defina um limite de contas, tipo as 10 que você declarou

    int menu, contas[10], opções, F, i, j;

crie também uma variável para o total atual de contas

	int total_atual_de_contas = 0;

crie um vetor de saldos, que vão claro corresponder às contas na tabela.
```
	int saldos[10];
```
Então se tiver duas contas por exemplo vai poder escrever

    conta[0] = 128;
    saldo[0] = 2500;

    conta[1] = 228;
    saldo[1] = 300;

O enunciado não fala em moeda em centavos nada. Então use inteiros e pronto.

Escreva uma função para cada opção e teste. Tire esse menu infeliz do programa por enquanto. isso só vai te f$%%a%. Use os valores direto em main até estar tudo certo.

Considere

O trabalho pede pra:

1 - Cadastrar contas(Somente número, não é necessário char)
2 - Depositar qualquer valor
3 - Sacar qualquer valor
4 - Transferir qualquer valor de uma conta para outra
5 - Listar todas as contas cadastradas com seus respectivos saldos

E veja como a vida pode ser simples

    int cadastro(int conta);
    int deposito(int conta, int valor);
    int saque(int conta, int valor);
    int transfere(int de, int para, int valor);
    int listar();

Retorne um valor tipo negativo quando sair algo errado em cada caso.

E veja como pode testar sem stress:

int main( int argc,m char** argv)
{
    listar(); // claro, teste listar sem nenhuma conta
    cadastro(12); // cria conta 12;
    deposito(12,150); // 150 na conta 12, claro
    saque(12,1300); // vai aceitar saldo negativo? devia estar no enunciado
    saque(12,100); // se nao esta assuma que nao pode ficar negativo
    cadastro(150); // cria outra conta
    deposito(150, 1000);
    transfere(150, 12, 999); // transfere da 150 para a 12
    listar();
};  // main()

Espero ter ajudado.

Depois que escrever isso você vê com quem pediu isso as condições reais: precisa de centavos? vai usar float. Aceita valores negativos nos saldos? Aceita valores negativos nos parâmetros? Essas coisas

E só depois põe esse menu de volta.

GustavoolegnA · 18 de março de 2020

@arfneto Obrigado pela ajuda.

O trabalho só fala sobre inteiros mesmo e não fala nada sobre aceitar valores negativos.

Por favor, poderia me explicar o que acontece aqui:

10 horas atrás, arfneto disse:

int cadastro(int conta);

int deposito(int conta, int valor);

int saque(int conta, int valor);

int transfere(int de, int para, int valor);

int listar();

10 horas atrás, arfneto disse:

int main( int argc,m char** argv)

{

listar(); // claro, teste listar sem nenhuma conta

cadastro(12); // cria conta 12;

deposito(12,150); // 150 na conta 12, claro

saque(12,1300); // vai aceitar saldo negativo? devia estar no enunciado saque(12,100); // se nao esta assuma que nao pode ficar negativo cadastro(150); // cria outra conta

deposito(150, 1000); transfere(150, 12, 999); // transfere da 150 para a 12 listar(); }; // main()

Eu tô no primeiro semestre de Ciência da Computação e não sou muito bom na linguagem C.

A função é pra ficar desse jeito? Falta algo?

int cadastro(int conta[10]){
   printf("Crie sua conta");
   scanf("%d", &conta[0]);
}

arfneto · 18 de março de 2020

13 horas atrás, GustavoolegnA disse:

do{MENU();

3 horas atrás, GustavoolegnA disse:

Por favor, poderia me explicar o que acontece aqui:

int cadastro(int conta);
int deposito(int conta, int valor);
int saque(int conta, int valor);
int transfere(int de, int para, int valor);
int listar();

Essas são as declarações das funções que você vai escrever para fazer as coisas...

Assim como você escreveu MENU() por exemplo...

void MENU ()
{
    printf("1 - Cadastrar nova conta\n");
    printf("2 - Depositar valor\n");
    printf("3 - Sacar valor\n");
    printf("4 - Transferir valor de uma conta pra outra\n");
    printf("5 - Listar todas as contas criadas\n");
    printf("Digite a opcao que deseja prosseguir: ");
};	// MENU() e uam funcao que você escreveu

// e depois em main() chamou assim

do
{
    MENU();
    scanf("%d", &menu);
    switch(menu)
    {
	...

3 horas atrás, GustavoolegnA disse:

A função é pra ficar desse jeito? Falta algo?

int cadastro(int conta[10])
{
   printf("Crie sua conta");
   scanf("%d", &conta[0]);
}

Está indo bem. Mas acho que não entendeu a parte de esquecer o menu e não ficar lendo coisas do teclado. Isso é perda de tempo. Está sobrando e faltando algo: o parâmetro é o número da conta a criar. E a tabela de contas e saldos vai estar declarada fora de main(), com acesso global. Só temos que cumprir o enunciado. Não precisa passar contas e/ou saldos como parâmetro. Só tem que resolver o exercício. Depois de testar as funções você chama MENU() e lê os valores do teclado. O scanf() para ler a conta vai estar fora. Exemplo:

    n = scanf("%d", conta);
    if ( n == 1 ) cadastro(conta); // muito mais simples

Se você deixar misturado não vai poder testar a criação das contas em separado da leitura. Por exemplo

	cadastro(100);

Cria a conta 100 e pronto. Depois que seu programa estiver funcionando você põe o infeliz do menu e as opções de leitura. Isso só atrasa a criação do programa. Quando você colocar o MENU() já vai saber que as funções todas estão funcionando.

Esse é um programa para quem está aprendendo, então é mais esperto declarar contas[] e saldos[] fora de main() assim qualquer função pode acessar os valores. São ditas variáveis globais.

Preste atenção na dinâmica disso: num primeiro momento

    listar();

Devia mostrar algo assim:

**** listar() *****
    Ainda nao tem contas abertas

Primeiro você escreve a função que lista as contas. Porque? Porque assim já pode chamar antes de abrir qualquer conta e ver se ela está funcionando, porque é o teste mais óbvio.

Vamos imaginar que você tem zero tempo pra fazer isso e tem que seguir com segurança. Então você abre no windows o bloco de notas e escreve um rascunho de como vai listar as contas

03 contas:

---------------------
##    conta     saldo
---------------------
01 12345678  12345678
02 12345678  12345678
03 12345678  12345678

fim da lista

Então vai ser assim. Escreve o código igualzinho:

int listar()
{
    printf("**** listar() *****\n");
    // tem alguma conta?
    if (total_atual_de_contas == 0)
    {
        printf("    Ainda nao tem contas abertas\n");
        return 0;
    };  // if()
    // entao tem pelo menos uma
    printf("\n%d contas\n\n", total_atual_de_contas);
    printf("---------------------\n");
    printf("##    conta     saldo\n");
    printf("---------------------\n");
    for (int i = 0; i < total_atual_de_contas; i = i + 1)
    {
        // lista a conta i
        printf("%2d: %8d %8d\n", i, contas[i], saldos[i]);
    };  // for()
    printf("\nfim da lista\n\n");
    return 0;
};  // listar()

Igualzinho. E usamos recortar e colar direto do bloco de notas para escrever os printf() com tudo alinhadinho. Só que não criamos as contas ainda. Falta escrever cadastro(). Mas pode ser bem simples:

int cadastro(int conta)
{
    printf("**** cadastro() *****\n");
    // abre uma conta dentro do limite de 10
    if (total_atual_de_contas > 9)
    {
        printf("Atingiu o limite de contas\n");
        return -1;
    };  // if()
    contas[total_atual_de_contas] = conta;
    saldos[total_atual_de_contas] = 0;
    total_atual_de_contas = total_atual_de_contas + 1;
    return 0;
};

Não precisa criar nada chique tipo struct{} para guardar as contas e saldos, float para os centavos, nada. Não está no enunciado e é cedo ainda. Apenas duas colunas como faria no papel. conta e saldo. E não caia na tentação de por em ordem. É cedo ainda. Não está no enunciado. E não precisa. Apenas olhe de uma em uma.

Claro que funciona. Veja esse main()

int main()
{
    listar();
    cadastro(105);
    cadastro(10);
    cadastro(1);
    listar();

    return 0;
};  // main()

Escreve main():

int main()
{
    listar();
    cadastro(105); // cria conta 105
    cadastro(10);
    cadastro(1);
    listar();

    return 0;
};  // main()

E olha o que mostra

**** listar() *****
    Ainda nao tem contas abertas
**** cadastro() *****
**** cadastro() *****
**** cadastro() *****
**** listar() *****

3 contas

---------------------
##    conta     saldo
---------------------
 0:      105        0
 1:       10        0
 2:        1        0

fim da lista

Esses printf() com ***** são só pra dar segurança quando você está aprendendo.

Eis o que importa

listar() funciona mesmo com zero contas
cadastro() põe as contas na tabela na ordem de criação, como a gente faria numa lista no papel.
listar() mostra certinho porque usamos o texto do bloco de notas para escrever os printf() nos espaços certinhos, certo?

E como seria uma transação na conta? Tipo um depósito?

Temos a lista de contas e então basta olhar uma a uma até achar a conta ou acabarem as contas. Se achou a conta soma o saldo na coluna correspondente. Nada mais. Algo assim:

int deposito(int conta, int valor)
{
    printf("**** deposito() *****\n");
    // para fazer um deposito precisa achar a conta
    // basta olhar a lista como se fosse no papel
    int pos = 0;    // vai ser a posicao da conta
    for (pos = 0; pos < total_atual_de_contas; pos = pos + 1)
    {
        if (contas[pos] == conta)
        {
            break; // achou entao sai do for loop
        };  // if()
    };  // for()
    // aqui tem duas possibilidades: ou pos e
    // igual ao total de contas e quer dizer que 
    // olhou todas e nao achou essa do deposito
    //
    // ou pos e a posicao da conta escolhida
    if (pos >= total_atual_de_contas)
    {
        // entao nao tinha essa
        printf("    Nao achou a conta %d\n", conta);
        return -1;
    };  // if()
    // entao pos e a posicao da conta. So fazer o deposito
    saldos[pos] = saldos[pos] + valor;
    return 0;
};  // deposito()

Não tem nem 15 linhas. Está cheio de comentários e então parece até maior. Eis o código normal:

int deposito(int conta, int valor)
{
    int pos = 0;    // vai ser a posicao da conta
    for (pos = 0; pos < total_atual_de_contas; pos = pos + 1)
        if (contas[pos] == conta)
            break; // achou entao sai do for loop
    if (pos >= total_atual_de_contas) return -1; // nao achou
    saldos[pos] = saldos[pos] + valor; // credito
    return 0;
};  // deposito()

Um novo main() para testar esse trem:

int main()
{
    listar();
    cadastro(105);
    cadastro(10);
    cadastro(1);
    listar();
    deposito(10, 100); // 100 reais na conta 10
    deposito(10, 125);
    deposito(18, 100); // essa nao existe
    deposito(1, 100);
    listar();
    return 0;
};  // main()

Pois é: faz uns depósitos e lista. Entende a diferença para usar um ,menu e ficar digitando?

Eis o resultado

**** listar() *****
    Ainda nao tem contas abertas
**** cadastro() *****
**** cadastro() *****
**** cadastro() *****
**** listar() *****

3 contas

---------------------
##    conta     saldo
---------------------
 0:      105        0
 1:       10        0
 2:        1        0

fim da lista

**** deposito() *****
**** deposito() *****
**** deposito() *****
    Nao achou a conta 18
**** deposito() *****
**** listar() *****

3 contas

---------------------
##    conta     saldo
---------------------
 0:      105        0
 1:       10      225
 2:        1      100

fim da lista

Entendeu a diferença? Em geral na prática é assim que se escreve e testa. Protótipos, funções separadas até onde possível. Rascunhos em texto ou formulários.

O seu programa com essas funções, por exemplo

#include <stdio.h>

// essas declaracoes avisam o compilador sobre as funcoes usadas 
// em main. Quais sao os parametros e o que elas retornam
// sao chamadas prototipos e e uma coisa muito esperta
// assim voce pode compilar seu programa ainda sem ter o codigo 
// dessas funcoes por exemplo
//
// imagine que tenha outro pessoal escrevendo essas coisas
// e vai entender: os prototipos permitem que você escreva 
// e compile o programa sem precisar do código todo
//
// e se for um codigo de terceiros voce nunca vai ver mesmo
// pense no caso de printf() por exemplo
// ela esta declarada nesse tal de stdio.h
//
// tudo que voce precisa saber e:
//
// int printf(const char *format, ...)
//

void LCR();
void MENU();
void RC();

int cadastro(int conta);
int deposito(int conta, int valor);
int listar();
int saque(int conta, int valor);
int transfere(int de, int para, int valor);

int total_atual_de_contas = 0;
int saldos[10];
int contas[10];

int main()
{
    listar();
    cadastro(105);
    cadastro(10);
    cadastro(1);
    listar();
    deposito(10, 100);
    deposito(10, 125);
    deposito(18, 100);
    deposito(1, 100);
    listar();
    return 0;
};  // main()

void LCR()
{
    //Listar Contas Registradas 
    int numdecontas[10], i;

    if (numdecontas == 0) {
        printf("Não há contas registradas");
    }
    if (numdecontas > 0) {
        for (i = 0; i < 10; i++)
        {
            printf("As contas sao: %d", numdecontas[i]);
        }
    }
};  // LCR()


void MENU()
{

    printf("1 - Cadastrar nova conta\n");
    printf("2 - Depositar valor\n");
    printf("3 - Sacar valor\n");
    printf("4 - Transferir valor de uma conta pra outra\n");
    printf("5 - Listar todas as contas criadas\n");
    printf("Digite a opcao que deseja prosseguir: ");
};  // MENU()


void RC()
{
    //Registro de Conta
};  // RC()


// as funcoes novas em ordem alfabetica

int cadastro(int conta)
{
    printf("**** cadastro() *****\n");
    // abre uma conta dentro do limite de 10
    if (total_atual_de_contas > 9)
    {
        printf("Atingiu o limite de contas\n");
        return -1;
    };  // if()
    contas[total_atual_de_contas] = conta;
    saldos[total_atual_de_contas] = 0;
    total_atual_de_contas = total_atual_de_contas + 1;
    return 0;
};


int deposito(int conta, int valor)
{
    printf("**** deposito() *****\n");
    // para fazer um deposito precisa achar a conta
    // basta olhar a lista como se fosse no papel
    int pos = 0;    // vai ser a posicao da conta
    for (pos = 0; pos < total_atual_de_contas; pos = pos + 1)
    {
        if (contas[pos] == conta)
        {
            break; // achou entao sai do for loop
        };  // if()
    };  // for()
    // aqui tem duas possibilidades: ou pos e
    // igual ao total de contas e quer dizer que 
    // olhou todas e nao achou essa do deposito
    //
    // ou pos e a posicao da conta escolhida
    if (pos >= total_atual_de_contas)
    {
        // entao nao tinha essa
        printf("    Nao achou a conta %d\n", conta);
        return -1;
    };  // if()
    // entao pos e a posicao da conta. So fazer o deposito
    saldos[pos] = saldos[pos] + valor;
    return 0;
};  // deposito()


int listar()
{
    printf("**** listar() *****\n");
    // tem alguma conta?
    if (total_atual_de_contas == 0)
    {
        printf("    Ainda nao tem contas abertas\n");
        return 0;
    };  // if()
    // entao tem pelo menos uma
    printf("\n%d contas\n\n", total_atual_de_contas);
    printf("---------------------\n");
    printf("##    conta     saldo\n");
    printf("---------------------\n");
    for (int i = 0; i < total_atual_de_contas; i = i + 1)
    {
        // lista a conta i
        printf("%2d: %8d %8d\n", i, contas[i], saldos[i]);
    };  // for()
    printf("\nfim da lista\n\n");
    return 0;
};  // listar()


int saque(int conta, int valor) { return 0; };
int transfere(int de, int para, int valor) { return 0; };