API tools faq
paste
Advertisement
Mateus_Costa

Banco simples em C

Mateus_Costa
Jul 5th, 2019
314
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 38.03 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <ctype.h>
  5.  
  6. /*
  7.  * Tamanho dos vetores de estruturas
  8.  */
  9. #define DEPOSITOS_TAM       500
  10. #define SAQUES_TAM          500
  11. #define ENTRADAS_TAM        500
  12. #define SAIDAS_TAM          500
  13. #define PAGAMENTOS_TAM      500
  14. #define CLIENTES_TAM        500
  15. #define CONTAS_TAM          500
  16.  
  17. /*
  18.  * Macros para definições de valores referente as funcionalidades
  19.  */
  20. #define QUANT_LETRAS_NOME_NUMERO_CONTA  3 /* Quantidade de letras para formação do número da conta */
  21. #define MIN_TAMANHO_NOME                3
  22. #define MAX_TAMANHO_NOME                255
  23.  
  24. #define MIN_VALOR_DEPOSITO          1.0
  25. #define MAX_VALOR_DEPOSITO          5000.0
  26. #define MIN_VALOR_SAQUE             2.0
  27. #define MAX_VALOR_SAQUE             5000.0
  28. #define MIN_VALOR_TRANSFERENCIA     1.0
  29. #define MAX_VALOR_TRANSFERENCIA     5000.0
  30.  
  31.  
  32.  
  33. typedef struct cliente_t Cliente;
  34. typedef struct banco_t Banco;
  35. typedef struct deposito_t Deposito;
  36. typedef struct saque_t Saque;
  37. typedef struct transferencia_t Transferencia;
  38. typedef struct pagamento_t Pagamento;
  39. typedef struct conta_t Conta;
  40.  
  41.  
  42.  
  43. /* ------------------------------------------------------------------------------- */
  44. /*  Cliente                                                                        */
  45. /* ------------------------------------------------------------------------------- */
  46. struct cliente_t
  47. {
  48.     char* cpf;
  49.     char* rg;
  50.     char* nome_completo; /* nome e sobrenome */
  51. };
  52.  
  53. /** Cria e retorna um Cliente */
  54. Cliente* cria_cliente(const char* cpf, const char* rg, const char* nome_completo);
  55.  
  56. /** Deleta um Cliente */
  57. Cliente* deleta_cliente(Cliente* cliente);
  58.  
  59. /** Retorna o cpf de um Cliente */
  60. const char* cliente_pega_cpf(Cliente* cliente);
  61.  
  62. /** Retorna o nome de um Cliente */
  63. const char* cliente_pega_nome(Cliente* cliente);
  64. /* ------------------------------------------------------------------------------- */
  65.  
  66.  
  67.  
  68. /* ------------------------------------------------------------------------------- */
  69. /*  Banco                                                                          */
  70. /* ------------------------------------------------------------------------------- */
  71. struct banco_t
  72. {
  73.     Cliente* clientes[CLIENTES_TAM];
  74.     Conta* contas[CONTAS_TAM];
  75.     size_t clientes_quant;
  76.     size_t contas_quant;
  77. };
  78.  
  79. /** Cria e retorna um Banco */
  80. Banco* cria_banco();
  81.  
  82. /** Deleta um Banco */
  83. Banco* deleta_banco(Banco* banco);
  84.  
  85. /**
  86.  * Busca por um Cliente com base no cpf no Banco. Retorna NULL
  87.  * se nenhum Cliente for encontrado.
  88.  */
  89. Cliente* banco_busca_cliente(Banco* banco, const char* cpf);
  90.  
  91. /** Verifica com base no nome e cpf se um Cliente está cadastrado no banco */
  92. int banco_cliente_existe(Banco* banco, Cliente* cliente);
  93.  
  94. /** Adiciona um Cliente ao Banco */
  95. void banco_adiciona_cliente(Banco* banco, Cliente* cliente);
  96.  
  97. /**
  98.  * Remove um Cliente do Banco com base no cpf. Retorna 1 para uma
  99.  * exclusão bem sucedida.
  100.  */
  101. int banco_remove_cliente(Banco* banco, const char* cpf);
  102.  
  103. /**
  104.  * Busca por uma Conta com base no numero no Banco. Retorna NULL
  105.  * se nenhuma Conta for encontrada.
  106.  */
  107. Conta* banco_busca_conta(Banco* banco, const char* numero);
  108.  
  109. /** Verifica com base no número se uma Conta está cadastrada no banco */
  110. int banco_conta_existe(Banco* banco, Conta* conta);
  111.  
  112. /** Adiciona uma Conta ao Banco */
  113. void banco_adiciona_conta(Banco* banco, Conta* conta);
  114.  
  115. /**
  116.  * Remove uma Conta do Banco com base no numero. Retorna 1 para uma
  117.  * exclusão bem sucedida.
  118.  */
  119. int banco_remove_conta(Banco* banco, const char* numero);
  120. /* ------------------------------------------------------------------------------- */
  121.  
  122.  
  123.  
  124. /* ------------------------------------------------------------------------------- */
  125. /*  Deposito                                                                       */
  126. /* ------------------------------------------------------------------------------- */
  127. struct deposito_t
  128. {
  129.     double valor;
  130. };
  131.  
  132. /** Cria e retorna um Deposito */
  133. Deposito* cria_deposito(const double valor);
  134.  
  135. /** Deleta um Deposito */
  136. void deleta_deposito(Deposito* deposito);
  137.  
  138. /** Imprime os membros de um Deposito */
  139. void imprime_deposito(Deposito* deposito);
  140. /* ------------------------------------------------------------------------------- */
  141.  
  142.  
  143.  
  144. /* ------------------------------------------------------------------------------- */
  145. /*  Saque                                                                          */
  146. /* ------------------------------------------------------------------------------- */
  147. struct saque_t
  148. {
  149.     double valor;
  150. };
  151.  
  152. /** Cria e retorna um Saque */
  153. Saque* cria_saque(const double valor);
  154.  
  155. /** Deleta um Saque */
  156. void deleta_saque(Saque* saque);
  157.  
  158. /** Imprime os membros de um Saque */
  159. void imprime_saque(Saque* saque);
  160. /* ------------------------------------------------------------------------------- */
  161.  
  162.  
  163.  
  164. /* ------------------------------------------------------------------------------- */
  165. /*  Transferencia                                                                  */
  166. /* ------------------------------------------------------------------------------- */
  167. struct transferencia_t
  168. {
  169.     double valor;
  170. };
  171.  
  172. /** Cria e retorna uma Transferencia */
  173. Transferencia* cria_transferencia(const double valor);
  174.  
  175. /** Deleta uma Transferencia */
  176. void deleta_transferencia(Transferencia* transferencia);
  177.  
  178. void imprime_transferencia(Transferencia* transferencia);
  179. /* ------------------------------------------------------------------------------- */
  180.  
  181.  
  182.  
  183. /* ------------------------------------------------------------------------------- */
  184. /*  Pagamento                                                                      */
  185. /* ------------------------------------------------------------------------------- */
  186. struct pagamento_t
  187. {
  188.     char* codigo_barra;
  189.     double valor;
  190. };
  191.  
  192. /** Cria e retorna um Pagamento */
  193. Pagamento* cria_pagamento(const char* codigo_barra, const double valor);
  194.  
  195. /** Deleta um Pagamento */
  196. void deleta_pagamento(Pagamento* pagamento);
  197.  
  198. /** Imprime os membros de um Pagamento */
  199. void imprime_pagamento(Pagamento* pagamento);
  200. /* ------------------------------------------------------------------------------- */
  201.  
  202.  
  203.  
  204. /* ------------------------------------------------------------------------------- */
  205. /*  Conta                                                                          */
  206. /* ------------------------------------------------------------------------------- */
  207. struct conta_t
  208. {
  209.     char* numero;
  210.     Cliente* cliente;
  211.     Deposito* depositos[DEPOSITOS_TAM];
  212.     Saque* saques[SAQUES_TAM];
  213.     Transferencia* entradas[ENTRADAS_TAM];
  214.     Transferencia* saidas[SAIDAS_TAM];
  215.     Pagamento* pagamentos[PAGAMENTOS_TAM];
  216.     size_t depositos_quant; /* quantidade de Depositos alocados */
  217.     size_t saques_quant; /* quantidade de Saques alocados */
  218.     size_t entradas_quant; /* quantidade de Transferencias (entradas) alocadas */
  219.     size_t saidas_quant; /* quantidade de Transferencias (saidas) alocadas */
  220.     size_t pagamentos_quant; /* quantidade de Pagamentos alocados */
  221.     double saldo;
  222. };
  223.  
  224. /** Cria e retorna uma Conta para um Cliente existente */
  225. Conta *cria_conta(Cliente* cliente);
  226.  
  227. /** Deleta uma Conta */
  228. Conta *deleta_conta(Conta* conta);
  229.  
  230. /** Registra um Deposito em uma Conta */
  231. void conta_adiciona_deposito(Conta* conta, Deposito* deposito);
  232.  
  233. /** Registra um Saque em uma Conta */
  234. void conta_adiciona_saque(Conta* conta, Saque* saque);
  235.  
  236. /** Registra uma entrada (Transferencia) em uma Conta */
  237. void conta_adiciona_entrada(Conta* conta, Transferencia* entrada);
  238.  
  239. /** Registra uma saida (Transferencia) em uma Conta */
  240. void conta_adiciona_saida(Conta* conta, Transferencia* saida);
  241.  
  242. /** Registra uma Pagamento em uma Conta */
  243. void conta_adiciona_pagamento(Conta* conta, Pagamento* pagamento);
  244.  
  245. /** Altera o saldo de uma Conta */
  246. void conta_altera_saldo(Conta* conta, const double saldo);
  247.  
  248. /** Retorna o numero de uma Conta */
  249. const char* conta_pega_numero(Conta* conta);
  250.  
  251. /** Retorna o saldo de uma Conta */
  252. const double conta_pega_saldo(Conta* conta);
  253.  
  254. /** Imprime os registros de uma Conta */
  255. void conta_imprime_registros(Conta* conta);
  256. /* ------------------------------------------------------------------------------- */
  257.  
  258.  
  259.  
  260. /* ------------------------------------------------------------------------------- */
  261. /*  Lógica das operações                                                           */
  262. /* ------------------------------------------------------------------------------- */
  263. /*
  264.  * Validação
  265.  */
  266.  
  267. /** Validação SIMPLES para CPF. Retorna 1 se for válido e 0 para inválido */
  268. int valida_cpf(const char* cpf);
  269.  
  270. /** Validação SIMPLES para RG. Retorna 1 se for válido e 0 para inválido */
  271. int valida_rg(const char* rg);
  272.  
  273. /** Verifica se um nome completo é válido sem case-sensitive. Retorna 1 se for válido e 0 para inválido */
  274. int valida_nome_completo(const char* nome_completo);
  275.  
  276. /** Verifica se um depósito é válido. Retorna 1 se for válido e 0 para inválido */
  277. int valida_deposito(const double valor);
  278.  
  279. /** Verifica se um saque é válido para uma Conta. Retorna 1 se for válido e 0 para inválido */
  280. int valida_saque(Conta* conta, const double valor);
  281.  
  282. /** Verifica se uma transferência é válida para uma Conta. Retorna 1 se for válido e 0 para inválido */
  283. int valida_transferencia(Conta* conta_origem, const double valor);
  284.  
  285. /** Verifica se um pagamento é válido para uma Conta. Retorna 1 se for válido e 0 para inválido */
  286. int valida_pagamento(Conta* conta, const double valor);
  287.  
  288. /*
  289.  * Operações
  290.  */
  291. /** Cadastra um Cliente no Banco */
  292. int cadastra_cliente(Banco* banco, const char* cpf, const char* rg, const char* nome_completo);
  293.  
  294. /** Abre uma Conta no Banco */
  295. int abre_conta(Banco* banco, const char* cpf);
  296.  
  297. /** Realiza um Deposito para uma conta */
  298. int realiza_deposito(Banco* banco, const char* numero_conta, const double valor);
  299.  
  300. /** Realiza um Saque para uma conta */
  301. int realiza_saque(Banco* banco, const char* numero_conta, const double valor);
  302.  
  303. /** Realiza uma Transferencia entre duas contas */
  304. int realiza_transferencia(Banco* banco, const char* numero_origem, const char* numero_destino, const double valor);
  305.  
  306. /** Realiza um Pagamento para uma conta */
  307. int realiza_pagamento(Banco* banco, const char* numero_conta, const char* codigo_barra, const double valor);
  308.  
  309. /** Imprime o saldo de uma conta */
  310. int imprime_saldo(Banco* banco, const char* numero_conta);
  311.  
  312. /** Imprime o extrato de uma conta */
  313. int imprime_extrato(Banco* banco, const char* numero_conta);
  314. /* ------------------------------------------------------------------------------- */
  315.  
  316.  
  317.  
  318. /* ------------------------------------------------------------------------------- */
  319. /*  Assinatura de funções para I/O                                                 */
  320. /* ------------------------------------------------------------------------------- */
  321. /*
  322.  * Menus baseados no Banco
  323.  */
  324. void menu_principal(Banco* banco);
  325. /* ------------------------------------------------------------------------------- */
  326.  
  327.  
  328.  
  329. int main(void)
  330. {
  331.     Banco *banco = cria_banco();
  332.     menu_principal(banco);
  333.     banco = deleta_banco(banco);
  334.     return 0;
  335. }
  336.  
  337.  
  338.  
  339. /* ------------------------------------------------------------------------------------- */
  340. /*  Funções de Cliente                                                                   */
  341. /* ------------------------------------------------------------------------------------- */
  342. Cliente* cria_cliente(const char* cpf, const char* rg, const char* nome_completo)
  343. {
  344.     Cliente* cliente = malloc(sizeof *cliente);
  345.     /* Alocando espaço para o comprimento exato da string + o caractere terminador ('\0') */
  346.     cliente->cpf = malloc((strlen(cpf) + 1) * sizeof(char));
  347.     cliente->rg = malloc((strlen(rg) + 1) * sizeof(char));
  348.     cliente->nome_completo = malloc((strlen(nome_completo) + 1) * sizeof(char));
  349.     /* Copiando as strings dos parâmetros para as da struct */
  350.     strcpy(cliente->cpf, cpf);
  351.     strcpy(cliente->rg, rg);
  352.     strcpy(cliente->nome_completo, nome_completo);
  353.  
  354.     return cliente;
  355. }
  356.  
  357. Cliente* deleta_cliente(Cliente* cliente)
  358. {
  359.     /* Desalocando a memória dos membros para não ocorrer vazamento de memória */
  360.     free(cliente->cpf);
  361.     free(cliente->rg);
  362.     free(cliente->nome_completo);
  363.  
  364.     /* Por fim deletamos o Cliente */
  365.     free(cliente);
  366.  
  367.     return NULL;
  368. }
  369.  
  370. const char* cliente_pega_cpf(Cliente* cliente)
  371. {
  372.     return cliente->cpf;
  373. }
  374.  
  375. const char* cliente_pega_nome(Cliente* cliente)
  376. {
  377.     return cliente->nome_completo;
  378. }
  379. /* ------------------------------------------------------------------------------------- */
  380.  
  381.  
  382.  
  383. /* ------------------------------------------------------------------------------------- */
  384. /*  Funções de Banco                                                                     */
  385. /* ------------------------------------------------------------------------------------- */
  386. Banco* cria_banco()
  387. {
  388.     Banco* banco = malloc(sizeof *banco);
  389.     banco->clientes_quant = 0;
  390.     banco->contas_quant = 0;
  391.     return banco;
  392. }
  393.  
  394. Banco* deleta_banco(Banco* banco)
  395. {
  396.     /* Exclusão em cascata */
  397.     int i;
  398.     for(i = 0; i < banco->clientes_quant; i++)
  399.     {
  400.         deleta_cliente(banco->clientes[i]);
  401.     }
  402.     for(i = 0; i < banco->contas_quant; i++)
  403.     {
  404.         deleta_conta(banco->contas[i]);
  405.     }
  406.     free(banco);
  407.     return NULL;
  408. }
  409.  
  410. Cliente* banco_busca_cliente(Banco* banco, const char* cpf)
  411. {
  412.     Cliente* cliente = NULL;
  413.  
  414.     int i;
  415.     for(i = 0; i < banco->clientes_quant; i++)
  416.     {
  417.         if(strcasecmp(cliente_pega_cpf(banco->clientes[i]), cpf) == 0)
  418.         {
  419.             cliente = banco->clientes[i];
  420.             break;
  421.         }
  422.     }
  423.  
  424.     return cliente;
  425. }
  426.  
  427. int banco_cliente_existe(Banco* banco, Cliente* cliente)
  428. {
  429.     int i;
  430.     for(i = 0; i < banco->clientes_quant; i++)
  431.     {
  432.         /* busca baseada no cpf e no nome */
  433.         if(strcasecmp(cliente_pega_cpf(banco->clientes[i]), cliente_pega_cpf(cliente)) == 0 ||
  434.            strcasecmp(cliente_pega_nome(banco->clientes[i]), cliente_pega_nome(cliente)) == 0)
  435.         {
  436.             return 1;
  437.         }
  438.     }
  439.  
  440.     return 0;
  441. }
  442.  
  443. void banco_adiciona_cliente(Banco* banco, Cliente* cliente)
  444. {
  445.     banco->clientes[banco->clientes_quant] = cliente;
  446.     banco->clientes_quant++;
  447. }
  448.  
  449. int banco_remove_cliente(Banco* banco, const char* cpf)
  450. {
  451.     int i;
  452.     size_t size = banco->clientes_quant;
  453.  
  454.     for(i = 0; i < size; i++)
  455.     {
  456.         if(strcasecmp(cliente_pega_cpf(banco->clientes[i]), cpf) == 0)
  457.         {
  458.             /* Deleta o Cliente para não ocorrer vazamento de memória */
  459.             deleta_cliente(banco->clientes[i]);
  460.             /* Reorganiza o vetor de Clientes */
  461.             int j;
  462.             for(j = i; j < size - 1; j++)
  463.             {
  464.                 banco->clientes[j] = banco->clientes[j + 1];
  465.             }
  466.             /* Decrementa em 1 o tamanho total do vetor */
  467.             banco->clientes_quant = banco->clientes_quant - 1;
  468.             /* Retorna uma exclusão bem sucedida */
  469.             return 1;
  470.         }
  471.     }
  472.     return 0;
  473. }
  474.  
  475. Conta* banco_busca_conta(Banco* banco, const char* numero)
  476. {
  477.     Conta* conta = NULL;
  478.  
  479.     int i;
  480.     for(i = 0; i < banco->contas_quant; i++)
  481.     {
  482.         if(strcasecmp(conta_pega_numero(banco->contas[i]), numero) == 0)
  483.         {
  484.             conta = banco->contas[i];
  485.             break;
  486.         }
  487.     }
  488.  
  489.     return conta;
  490. }
  491.  
  492. int banco_conta_existe(Banco* banco, Conta* conta)
  493. {
  494.     if(banco_busca_conta(banco, conta_pega_numero(conta)) == NULL)
  495.     {
  496.         return 0;
  497.     }
  498.  
  499.     return 1;
  500. }
  501.  
  502. void banco_adiciona_conta(Banco* banco, Conta* conta)
  503. {
  504.     banco->contas[banco->contas_quant] = conta;
  505.     banco->contas_quant++;
  506. }
  507.  
  508. int banco_remove_conta(Banco* banco, const char* numero)
  509. {
  510.     int i;
  511.     size_t size = banco->contas_quant;
  512.  
  513.     for(i = 0; i < size; i++)
  514.     {
  515.         if(strcasecmp(conta_pega_numero(banco->contas[i]), numero) == 0)
  516.         {
  517.             /* Deleta a Conta para não ocorrer vazamento de memória */
  518.             deleta_conta(banco->contas[i]);
  519.             /* Reorganiza o vetor de Contas */
  520.             int j;
  521.             for(j = i; j < size - 1; j++)
  522.             {
  523.                 banco->contas[j] = banco->contas[j + 1];
  524.             }
  525.             /* Decrementa em 1 o tamanho total do vetor */
  526.             banco->contas_quant = banco->contas_quant - 1;
  527.             /* Retorna uma exclusão bem sucedida */
  528.             return 1;
  529.         }
  530.     }
  531.     return 0;
  532. }
  533. /* ------------------------------------------------------------------------------------- */
  534.  
  535.  
  536.  
  537. /* ------------------------------------------------------------------------------------- */
  538. /*  Funções de Deposito                                                                  */
  539. /* ------------------------------------------------------------------------------------- */
  540. Deposito* cria_deposito(const double valor)
  541. {
  542.     Deposito* deposito = malloc(sizeof *deposito);
  543.     deposito->valor = valor;
  544.     return deposito;
  545. }
  546.  
  547. void deleta_deposito(Deposito* deposito)
  548. {
  549.     free(deposito);
  550. }
  551.  
  552. void imprime_deposito(Deposito* deposito)
  553. {
  554.     printf("Valor: %f\n", deposito->valor);
  555. }
  556. /* ------------------------------------------------------------------------------------- */
  557.  
  558.  
  559.  
  560. /* ------------------------------------------------------------------------------------- */
  561. /*  Funções de Saque                                                                     */
  562. /* ------------------------------------------------------------------------------------- */
  563. Saque* cria_saque(const double valor)
  564. {
  565.     Saque* saque = malloc(sizeof *saque);
  566.     saque->valor = valor;
  567.     return saque;
  568. }
  569.  
  570. void deleta_saque(Saque* saque)
  571. {
  572.     free(saque);
  573. }
  574.  
  575. void imprime_saque(Saque* saque)
  576. {
  577.     printf("Valor: %f\n", saque->valor);
  578. }
  579. /* ------------------------------------------------------------------------------------- */
  580.  
  581.  
  582.  
  583. /* ------------------------------------------------------------------------------------- */
  584. /*  Funções de Transferencia                                                             */
  585. /* ------------------------------------------------------------------------------------- */
  586. Transferencia* cria_transferencia(const double valor)
  587. {
  588.     Transferencia* transferencia = malloc(sizeof *transferencia);
  589.     transferencia->valor = valor;
  590.     return transferencia;
  591. }
  592.  
  593. void deleta_transferencia(Transferencia* transferencia)
  594. {
  595.     free(transferencia);
  596. }
  597.  
  598. void imprime_transferencia(Transferencia* transferencia)
  599. {
  600.     printf("Valor: %f\n", transferencia->valor);
  601. }
  602. /* ------------------------------------------------------------------------------------- */
  603.  
  604.  
  605.  
  606. /* ------------------------------------------------------------------------------------- */
  607. /*  Funções de Pagamento                                                                 */
  608. /* ------------------------------------------------------------------------------------- */
  609. Pagamento* cria_pagamento(const char* codigo_barra, const double valor)
  610. {
  611.     Pagamento* pagamento = malloc(sizeof *pagamento);
  612.     pagamento->codigo_barra = malloc((strlen(codigo_barra) + 1) * sizeof(char));
  613.     strcpy(pagamento->codigo_barra, codigo_barra);
  614.     pagamento->valor = valor;
  615.     return pagamento;
  616. }
  617.  
  618. void deleta_pagamento(Pagamento* pagamento)
  619. {
  620.     free(pagamento);
  621. }
  622.  
  623. void imprime_pagamento(Pagamento* pagamento)
  624. {
  625.     printf("Codigo de barra: %s, Valor: %f\n", pagamento->codigo_barra, pagamento->valor);
  626. }
  627. /* ------------------------------------------------------------------------------------- */
  628.  
  629.  
  630.  
  631. /* ------------------------------------------------------------------------------------- */
  632. /*  Funções de Conta                                                                     */
  633. /* ------------------------------------------------------------------------------------- */
  634. Conta *cria_conta(Cliente* cliente)
  635. {
  636.     Conta* conta = malloc(sizeof *conta);
  637.  
  638.     /* Aloca espaço suficiente para os digitos do CPF e as letras do nome */
  639.     conta->numero = malloc((strlen(cliente->cpf) + QUANT_LETRAS_NOME_NUMERO_CONTA + 1) * sizeof(char));
  640.  
  641.     /* Atribui o cliente a nova conta */
  642.     conta->cliente = cliente;
  643.  
  644.     /*
  645.      * Inicializa os membros da struct
  646.      */
  647.  
  648.     /* gerando o número da conta */
  649.     char letras[QUANT_LETRAS_NOME_NUMERO_CONTA + 1];
  650.     strncpy(letras, cliente->nome_completo, QUANT_LETRAS_NOME_NUMERO_CONTA);
  651.     letras[QUANT_LETRAS_NOME_NUMERO_CONTA] = '\0'; /* adicionando caractere terminador a string */
  652.     strcpy(conta->numero, cliente->cpf);
  653.     strcat(conta->numero, letras);
  654.  
  655.     conta->depositos_quant = 0;
  656.     conta->saques_quant = 0;
  657.     conta->entradas_quant = 0;
  658.     conta->saidas_quant = 0;
  659.     conta->pagamentos_quant = 0;
  660.     conta->saldo = 0.0;
  661.  
  662.     return conta;
  663. }
  664.  
  665. Conta *deleta_conta(Conta* conta)
  666. {
  667.     /* Exclusão em cascata das entidades fracas */
  668.     int i;
  669.     for(i = 0; i < conta->depositos_quant; i++)
  670.     {
  671.         deleta_deposito(conta->depositos[i]);
  672.     }
  673.     for(i = 0; i < conta->saques_quant; i++)
  674.     {
  675.         deleta_saque(conta->saques[i]);
  676.     }
  677.     for(i = 0; i < conta->entradas_quant; i++)
  678.     {
  679.         deleta_transferencia(conta->entradas[i]);
  680.     }
  681.     for(i = 0; i < conta->saidas_quant; i++)
  682.     {
  683.         deleta_transferencia(conta->saidas[i]);
  684.     }
  685.     for(i = 0; i < conta->pagamentos_quant; i++)
  686.     {
  687.         deleta_pagamento(conta->pagamentos[i]);
  688.     }
  689.     /* Por fim desalocamos a Conta */
  690.     free(conta);
  691.  
  692.     return NULL;
  693. }
  694.  
  695. void conta_adiciona_deposito(Conta* conta, Deposito* deposito)
  696. {
  697.     conta->depositos[conta->depositos_quant] = deposito;
  698.     conta->depositos_quant++;
  699. }
  700.  
  701. void conta_adiciona_saque(Conta* conta, Saque* saque)
  702. {
  703.     conta->saques[conta->saques_quant] = saque;
  704.     conta->saques_quant++;
  705. }
  706.  
  707. void conta_adiciona_entrada(Conta* conta, Transferencia* entrada)
  708. {
  709.     conta->entradas[conta->entradas_quant] = entrada;
  710.     conta->entradas_quant++;
  711. }
  712.  
  713. void conta_adiciona_saida(Conta* conta, Transferencia* saida)
  714. {
  715.     conta->saidas[conta->saidas_quant] = saida;
  716.     conta->saidas_quant++;
  717. }
  718.  
  719. void conta_adiciona_pagamento(Conta* conta, Pagamento* pagamento)
  720. {
  721.     conta->pagamentos[conta->pagamentos_quant] = pagamento;
  722.     conta->pagamentos_quant++;
  723. }
  724.  
  725. void conta_imprime_registros(Conta* conta)
  726. {
  727.     int i;
  728.  
  729.     printf("Saques:\n");
  730.     for(i = 0; i < conta->saques_quant; i++)
  731.     {
  732.         imprime_saque(conta->saques[i]);
  733.     }
  734.     printf("---------------\n");
  735.     printf("Depositos:\n");
  736.     for(i = 0; i < conta->depositos_quant; i++)
  737.     {
  738.         imprime_deposito(conta->depositos[i]);
  739.     }
  740.     printf("---------------\n");
  741.     printf("Transferencias (entradas):\n");
  742.     for(i = 0; i < conta->entradas_quant; i++)
  743.     {
  744.         imprime_transferencia(conta->entradas[i]);
  745.     }
  746.     printf("---------------\n");
  747.     printf("Transferencias (saidas):\n");
  748.     for(i = 0; i < conta->saidas_quant; i++)
  749.     {
  750.         imprime_transferencia(conta->saidas[i]);
  751.     }
  752.     printf("---------------\n");
  753.     printf("Pagamentos:\n");
  754.     for(i = 0; i < conta->pagamentos_quant; i++)
  755.     {
  756.         imprime_pagamento(conta->pagamentos[i]);
  757.     }
  758.     printf("---------------\n");
  759. }
  760.  
  761. void conta_altera_saldo(Conta* conta, const double saldo)
  762. {
  763.     conta->saldo = saldo;
  764. }
  765.  
  766. const char* conta_pega_numero(Conta* conta)
  767. {
  768.     return conta->numero;
  769. }
  770.  
  771. const double conta_pega_saldo(Conta* conta)
  772. {
  773.     return conta->saldo;
  774. }
  775. /* ------------------------------------------------------------------------------------- */
  776.  
  777.  
  778.  
  779. /* ------------------------------------------------------------------------------------- */
  780. /*  Funções para a lógica das operações                                                  */
  781. /* ------------------------------------------------------------------------------------- */
  782. /*
  783.  * Validação
  784.  */
  785. int valida_cpf(const char* cpf)
  786. {
  787.     /*
  788.      * Validação SIMPLES, apenas checa se possui uma quantidade
  789.      * mínima de caracteres e se todos os caracteres são numéricos.
  790.      */
  791.  
  792.     size_t size = strlen(cpf);
  793.  
  794.     if(size < 11)
  795.     {
  796.         return 0;
  797.     }
  798.  
  799.     int i;
  800.     for(i = 0; i < size; i++)
  801.     {
  802.         if(!isdigit(cpf[i]))
  803.         {
  804.             return 0;
  805.         }
  806.     }
  807.  
  808.     return 1;
  809. }
  810.  
  811. int valida_rg(const char* rg)
  812. {
  813.     /*
  814.      * Validação SIMPLES, apenas checa se possui uma quantidade
  815.      * mínima de caracteres e se todos os caracteres são numéricos.
  816.      */
  817.  
  818.     size_t size = strlen(rg);
  819.  
  820.     if(size < 1)
  821.     {
  822.         return 0;
  823.     }
  824.  
  825.     int i;
  826.     for(i = 0; i < size; i++)
  827.     {
  828.         if(!isdigit(rg[i]))
  829.         {
  830.             return 0;
  831.         }
  832.     }
  833.  
  834.     return 1;
  835. }
  836.  
  837. int valida_nome_completo(const char* nome_completo)
  838. {
  839.     size_t size = strlen(nome_completo);
  840.  
  841.     if(size < MIN_TAMANHO_NOME)
  842.     {
  843.         return 0; /* Não pode possuir menos que MIN_TAMANHO_NOME caracteres */
  844.     }
  845.  
  846.     if(size > MAX_TAMANHO_NOME)
  847.     {
  848.         return 0; /* Não pode possuir menos que MAX_TAMANHO_NOME caracteres */
  849.     }
  850.  
  851.     if(isspace(nome_completo[0]))
  852.     {
  853.         return 0; /* Espaço no começo do nome */
  854.     }
  855.  
  856.     if(isspace(nome_completo[size - 1]))
  857.     {
  858.         return 0; /* Espaço no final do nome */
  859.     }
  860.  
  861.  
  862.     /*
  863.      * Checando caracteres especiais e verificando se possui um sobrenome
  864.      */
  865.  
  866.     int valid = 0;
  867.  
  868.     int i;
  869.     for(i = 0; i < size; i++)
  870.     {
  871.         if(!isalpha(nome_completo[i]))
  872.         {
  873.             if(isspace(nome_completo[i]))
  874.             {
  875.                 if(isspace(nome_completo[i + 1]))
  876.                 {
  877.                     return 0; /* Nome inválido, mais de um espaço seguido! */
  878.                 }
  879.  
  880.                 valid = 1; /* Marca que encontrou um sobrenome válido */
  881.             }
  882.             else
  883.             {
  884.                 /* Se o caractere for um símbolo, verifica se é um símbolo válido. */
  885.                 if(!(nome_completo[i] == '-'))
  886.                 {
  887.                     return 0;
  888.                 }
  889.             }
  890.         }
  891.     }
  892.  
  893.     return valid;
  894. }
  895.  
  896. int valida_deposito(const double valor)
  897. {
  898.     if(valor < MIN_VALOR_DEPOSITO)
  899.     {
  900.         return 0;
  901.     }
  902.  
  903.     if(valor > MAX_VALOR_DEPOSITO)
  904.     {
  905.         return 0;
  906.     }
  907.  
  908.     return 1;
  909. }
  910.  
  911. int valida_saque(Conta* conta, const double valor)
  912. {
  913.     if(valor > conta_pega_saldo(conta))
  914.     {
  915.         return 0;
  916.     }
  917.  
  918.     if(valor < MIN_VALOR_SAQUE)
  919.     {
  920.         return 0;
  921.     }
  922.  
  923.     if(valor > MAX_VALOR_SAQUE)
  924.     {
  925.         return 0;
  926.     }
  927.  
  928.     return 1;
  929. }
  930.  
  931. int valida_transferencia(Conta* conta_origem, const double valor)
  932. {
  933.     if(valor > conta_pega_saldo(conta_origem))
  934.     {
  935.         return 0;
  936.     }
  937.  
  938.     if(valor < MIN_VALOR_TRANSFERENCIA)
  939.     {
  940.         return 0;
  941.     }
  942.  
  943.     if(valor > MAX_VALOR_TRANSFERENCIA)
  944.     {
  945.         return 0;
  946.     }
  947.  
  948.     return 1;
  949. }
  950.  
  951. int valida_pagamento(Conta* conta, const double valor)
  952. {
  953.     if(valor > conta_pega_saldo(conta))
  954.     {
  955.         return 0;
  956.     }
  957.  
  958.     if(valor <= 0.0)
  959.     {
  960.         return 0;
  961.     }
  962.  
  963.     return 1;
  964. }
  965.  
  966. /*
  967.  * Operações
  968.  */
  969. int cadastra_cliente(Banco* banco, const char* cpf, const char* rg, const char* nome_completo)
  970. {
  971.     Cliente* cliente = cria_cliente(cpf, rg, nome_completo);
  972.  
  973.     /* Verificamos se já existe um Cliente criado com esses dados */
  974.     if(banco_cliente_existe(banco, cliente))
  975.     {
  976.         deleta_cliente(cliente); /* deletamos para não ocorrer vazamento de memória */
  977.         return 0;
  978.     }
  979.  
  980.     banco_adiciona_cliente(banco, cliente);
  981.     return 1;
  982. }
  983.  
  984. int abre_conta(Banco* banco, const char* cpf)
  985. {
  986.     Cliente *cliente = banco_busca_cliente(banco, cpf);
  987.  
  988.     /* Se a busca retornou NULL, não existe um Cliente cadastrado com base nesse cpf */
  989.     if(cliente == NULL)
  990.     {
  991.         return 0;
  992.     }
  993.  
  994.     Conta* conta = cria_conta(cliente);
  995.  
  996.     /* Verificamos se já existe uma conta cadastrada */
  997.     if(banco_conta_existe(banco, conta))
  998.     {
  999.         deleta_conta(conta); /* deletamos para não ocorrer vazamento de memória */
  1000.         return 0;
  1001.     }
  1002.  
  1003.     banco_adiciona_conta(banco, conta);
  1004.     return 1;
  1005. }
  1006.  
  1007. int realiza_deposito(Banco* banco, const char* numero_conta, const double valor)
  1008. {
  1009.     if(!valida_deposito(valor))
  1010.     {
  1011.         return 0;
  1012.     }
  1013.  
  1014.     Conta* conta = banco_busca_conta(banco, numero_conta);
  1015.  
  1016.     /* Se a busca retornar NULL, a conta é inexistente! */
  1017.     if(conta == NULL)
  1018.     {
  1019.         return 0;
  1020.     }
  1021.  
  1022.     /* Adicionamos o valor do deposito ao saldo */
  1023.     conta_altera_saldo(conta, conta_pega_saldo(conta) + valor);
  1024.     /* Registramos o deposito na conta */
  1025.     conta_adiciona_deposito(conta, cria_deposito(valor));
  1026.  
  1027.     return 1;
  1028. }
  1029.  
  1030. int realiza_saque(Banco* banco, const char* numero_conta, const double valor)
  1031. {
  1032.     Conta* conta = banco_busca_conta(banco, numero_conta);
  1033.  
  1034.     /* Se a busca retornar NULL, a conta é inexistente! */
  1035.     if(conta == NULL)
  1036.     {
  1037.         return 0;
  1038.     }
  1039.  
  1040.     if(!valida_saque(conta, valor))
  1041.     {
  1042.         return 0;
  1043.     }
  1044.  
  1045.     /* Descontamos o valor do saque no saldo */
  1046.     conta_altera_saldo(conta, conta_pega_saldo(conta) - valor);
  1047.     /* Registramos o saque na conta */
  1048.     conta_adiciona_saque(conta, cria_saque(valor));
  1049.  
  1050.     return 1;
  1051. }
  1052.  
  1053. int realiza_transferencia(Banco* banco, const char* numero_origem, const char* numero_destino, const double valor)
  1054. {
  1055.     Conta* origem = banco_busca_conta(banco, numero_origem);
  1056.     Conta* destino = banco_busca_conta(banco, numero_destino);
  1057.  
  1058.     /* Se origem ou destino não existir, não é possível realizar uma transferência */
  1059.     if(origem == NULL || destino == NULL)
  1060.     {
  1061.         return 0;
  1062.     }
  1063.  
  1064.     /* Não permitir transferir para si mesmo */
  1065.     if(origem == destino)
  1066.     {
  1067.         return 0;
  1068.     }
  1069.  
  1070.     if(!valida_transferencia(origem, valor))
  1071.     {
  1072.         return 0;
  1073.     }
  1074.  
  1075.     /* Alteramos o saldo das contas origem e destino */
  1076.     conta_altera_saldo(origem, conta_pega_saldo(origem) - valor);
  1077.     conta_altera_saldo(destino, conta_pega_saldo(destino) + valor);
  1078.  
  1079.     /* Registramos as transferências nas contas origem e destino */
  1080.     conta_adiciona_saida(origem, cria_transferencia(valor));
  1081.     conta_adiciona_entrada(destino, cria_transferencia(valor));
  1082.  
  1083.     return 1;
  1084. }
  1085.  
  1086. int realiza_pagamento(Banco* banco, const char* numero_conta, const char* codigo_barra, const double valor)
  1087. {
  1088.     Conta* conta = banco_busca_conta(banco, numero_conta);
  1089.  
  1090.     /* Se a busca retornar NULL, a conta é inexistente! */
  1091.     if(conta == NULL)
  1092.     {
  1093.         return 0;
  1094.     }
  1095.  
  1096.     if(!valida_pagamento(conta, valor))
  1097.     {
  1098.         return 0;
  1099.     }
  1100.  
  1101.     /* Descontamos o valor do pagamento no saldo */
  1102.     conta_altera_saldo(conta, conta_pega_saldo(conta) - valor);
  1103.     /* Registramos o pagamento na conta */
  1104.     conta_adiciona_pagamento(conta, cria_pagamento(codigo_barra, valor));
  1105.  
  1106.     return 1;
  1107. }
  1108.  
  1109. int imprime_saldo(Banco* banco, const char* numero_conta)
  1110. {
  1111.     Conta* conta = banco_busca_conta(banco, numero_conta);
  1112.  
  1113.     /* Verificamos se a conta é inexistente */
  1114.     if(conta == NULL)
  1115.     {
  1116.         return 0;
  1117.     }
  1118.  
  1119.     printf("Saldo: %f\n", conta_pega_saldo(conta));
  1120.     return 1;
  1121. }
  1122.  
  1123. int imprime_extrato(Banco* banco, const char* numero_conta)
  1124. {
  1125.     Conta* conta = banco_busca_conta(banco, numero_conta);
  1126.  
  1127.     /* Verificamos se a conta é inexistente */
  1128.     if(conta == NULL)
  1129.     {
  1130.         return 0;
  1131.     }
  1132.  
  1133.     printf("=================================\n");
  1134.     printf("Numero da conta: %s\n", numero_conta);
  1135.     printf("--------------------\n");
  1136.     conta_imprime_registros(conta);
  1137.     printf("=================================\n");
  1138.     return 1;
  1139. }
  1140. /* ------------------------------------------------------------------------------------- */
  1141.  
  1142.  
  1143.  
  1144. /* ------------------------------------------------------------------------------- */
  1145. /*  Funções para I/O                                                               */
  1146. /* ------------------------------------------------------------------------------- */
  1147. /*
  1148.  * Menus
  1149.  */
  1150. void menu_principal(Banco* banco)
  1151. {
  1152.     int opcao;
  1153.  
  1154.     do{
  1155.         printf("------\n");
  1156.         printf("Operacoes\n");
  1157.         printf("------\n");
  1158.         printf("1. Cadastro de Cliente\n");
  1159.         printf("2. Cadastro de Conta\n");
  1160.         printf("3. Depositos\n");
  1161.         printf("4. Saque\n");
  1162.         printf("5. Transferencia\n");
  1163.         printf("6. Saldo\n");
  1164.         printf("7. Extrato\n");
  1165.         printf("8. Pagamento de Boleto\n");
  1166.         printf("0. Sair\n");
  1167.  
  1168.         setbuf(stdin, NULL);
  1169.         scanf("%d", &opcao);
  1170.  
  1171.         char cpf[32], rg[32], nome[256], conta_origem[32], conta_destino[32], codigo_barra[128];
  1172.         double valor;
  1173.  
  1174.         switch(opcao) {
  1175.         /*
  1176.          * 1. Cadastro de Cliente
  1177.          */
  1178.         case 1:
  1179.             do {
  1180.                 printf("CPF: ");
  1181.                 setbuf(stdin, NULL);
  1182.                 scanf("%s", cpf);
  1183.             }while(!valida_cpf(cpf));
  1184.  
  1185.             do {
  1186.                 printf("RG: ");
  1187.                 setbuf(stdin, NULL);
  1188.                 scanf("%s", rg);
  1189.             }while(!valida_rg(rg));
  1190.  
  1191.             do {
  1192.                 printf("Nome completo: ");
  1193.                 setbuf(stdin, NULL);
  1194.                 scanf("%[^\n]", nome);
  1195.             }while(!valida_nome_completo(nome));
  1196.  
  1197.             if(cadastra_cliente(banco, cpf, rg, nome))
  1198.             {
  1199.                 printf("Cliente cadastrado com sucesso!\n");
  1200.             }
  1201.             else
  1202.             {
  1203.                 printf("Nao foi possivel concluir o cadastro.\n");
  1204.             }
  1205.             break;
  1206.         /*
  1207.          * 2. Cadastro de Conta
  1208.          */
  1209.         case 2:
  1210.             printf("CPF do Cliente: ");
  1211.             setbuf(stdin, NULL);
  1212.             scanf("%s", cpf);
  1213.  
  1214.             if(abre_conta(banco, cpf))
  1215.             {
  1216.                 printf("Conta criada com sucesso!\n");
  1217.             }
  1218.             else
  1219.             {
  1220.                 printf("Nao foi possivel concluir o cadastro.\n");
  1221.             }
  1222.             break;
  1223.         /*
  1224.          * 3. Deposito
  1225.          */
  1226.         case 3:
  1227.             printf("Conta: ");
  1228.             setbuf(stdin, NULL);
  1229.             scanf("%[^\n]", conta_origem);
  1230.  
  1231.             printf("Valor: ");
  1232.             setbuf(stdin, NULL);
  1233.             scanf("%lf", &valor);
  1234.  
  1235.             if(realiza_deposito(banco, conta_origem, valor))
  1236.             {
  1237.                 printf("Operacao realizada com sucesso!\n");
  1238.             }
  1239.             else
  1240.             {
  1241.                 printf("Nao foi possivel realizar essa operacao. Certifique-se que as informacoes sao validas.\n");
  1242.                 printf("Valores permitidos: MIN: %f, MAX: %f\n", MIN_VALOR_DEPOSITO, MAX_VALOR_DEPOSITO);
  1243.             }
  1244.             break;
  1245.         /*
  1246.          * 4. Saque
  1247.          */
  1248.         case 4:
  1249.             printf("Conta: ");
  1250.             setbuf(stdin, NULL);
  1251.             scanf("%[^\n]", conta_origem);
  1252.  
  1253.             printf("Valor: ");
  1254.             setbuf(stdin, NULL);
  1255.             scanf("%lf", &valor);
  1256.  
  1257.             if(realiza_saque(banco, conta_origem, valor))
  1258.             {
  1259.                 printf("Operacao realizada com sucesso!\n");
  1260.             }
  1261.             else
  1262.             {
  1263.                 printf("Nao foi possivel realizar essa operacao. Certifique-se que as informacoes sao validas.\n");
  1264.                 printf("Valores permitidos: MIN: %f, MAX: %f\n", MIN_VALOR_SAQUE, MAX_VALOR_SAQUE);
  1265.             }
  1266.             break;
  1267.         /*
  1268.          * 5. Transferencia
  1269.          */
  1270.         case 5:
  1271.             printf("Origem: ");
  1272.             setbuf(stdin, NULL);
  1273.             scanf("%[^\n]", conta_origem);
  1274.  
  1275.             printf("Destino: ");
  1276.             setbuf(stdin, NULL);
  1277.             scanf("%[^\n]", conta_destino);
  1278.  
  1279.             printf("Valor: ");
  1280.             setbuf(stdin, NULL);
  1281.             scanf("%lf", &valor);
  1282.  
  1283.             if(realiza_transferencia(banco, conta_origem, conta_destino, valor))
  1284.             {
  1285.                 printf("Operacao realizada com sucesso!\n");
  1286.             }
  1287.             else
  1288.             {
  1289.                 printf("Nao foi possivel realizar essa operacao. Certifique-se que as informacoes sao validas.\n");
  1290.                 printf("Valores permitidos: MIN: %f, MAX: %f\n", MIN_VALOR_TRANSFERENCIA, MAX_VALOR_TRANSFERENCIA);
  1291.             }
  1292.             break;
  1293.         /*
  1294.          * 6. Saldo
  1295.          */
  1296.         case 6:
  1297.             printf("Conta: ");
  1298.             setbuf(stdin, NULL);
  1299.             scanf("%[^\n]", conta_origem);
  1300.  
  1301.             if(!imprime_saldo(banco, conta_origem))
  1302.             {
  1303.                 printf("Nao foi possivel realizar essa operacao.\n");
  1304.             }
  1305.             break;
  1306.         /*
  1307.          * 7. Extrato
  1308.          */
  1309.         case 7:
  1310.             printf("Conta: ");
  1311.             setbuf(stdin, NULL);
  1312.             scanf("%[^\n]", conta_origem);
  1313.  
  1314.             if(!imprime_extrato(banco, conta_origem))
  1315.             {
  1316.                 printf("Nao foi possivel realizar essa operacao.\n");
  1317.             }
  1318.             break;
  1319.         /*
  1320.          * 8. Pagamento de Boleto
  1321.          */
  1322.         case 8:
  1323.             printf("Conta: ");
  1324.             setbuf(stdin, NULL);
  1325.             scanf("%[^\n]", conta_origem);
  1326.  
  1327.             printf("Codigo de barra: ");
  1328.             setbuf(stdin, NULL);
  1329.             scanf("%s", codigo_barra);
  1330.  
  1331.             printf("Valor: ");
  1332.             setbuf(stdin, NULL);
  1333.             scanf("%lf", &valor);
  1334.  
  1335.             if(realiza_pagamento(banco, conta_origem, codigo_barra, valor))
  1336.             {
  1337.                 printf("Operacao realizada com sucesso!\n");
  1338.             }
  1339.             else
  1340.             {
  1341.                 printf("Nao foi possivel realizar essa operacao. Certifique-se que as informacoes sao validas.\n");
  1342.             }
  1343.             break;
  1344.         /*
  1345.          * 0. Sair
  1346.          */
  1347.         case 0:
  1348.             printf("Saindo do menu...\n");
  1349.             break;
  1350.         default:
  1351.             printf("Opcao invalida, tente novamente!\n");
  1352.         }
  1353.     }while(opcao != 0);
  1354. }
  1355. /* ------------------------------------------------------------------------------- */
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!