João Victor Simonassi

Preciso criar um app que tenha uma área livre para uma criança escrever. Depois, o aplicativo deve falar o que está escrito. Fiz a parte do desenho, criei um método que tira um print da View onde o desenho está e estou passando o bitmap para uma api do Firebase. Está funcionando, mas a api foi feita para ler o texto de documentos, não de escrita à mão e ele acaba não reconhecendo na maioria das vezes. Uma alternativa pra resolver é usar OCR: https://cloud.google.com/vision/docs/handwriting?hl=pt-br , mas sinceramente, estou começando agora no android e não faço ideia de como implementar isso no meu code. Pelo menos, não com a documentação deles. Projeto completo: https://github.com/jsimonassi/Maquina-de-segredos MainActivity: public class MainActivity extends AppCompatActivity { private Button btn_limpar; private Button btn_falar; private TextView texto; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); FirebaseApp.initializeApp(this); btn_limpar = findViewById(R.id.btn_clear); btn_falar = findViewById(R.id.Id_falar); texto = findViewById(R.id.id_textoLido); btn_limpar.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { MainFragment.dv.clearDrawing(); } }); btn_falar.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { Bitmap bitmap = screenShot(MainFragment.dv); //Tira print do fragmento FirebaseVisionImage image = FirebaseVisionImage.fromBitmap(bitmap); FirebaseVisionTextRecognizer detector = FirebaseVision.getInstance() .getOnDeviceTextRecognizer(); detector.processImage(image).addOnSuccessListener(new OnSuccessListener<FirebaseVisionText>() { @Override public void onSuccess(FirebaseVisionText firebaseVisionText) { String resultado = firebaseVisionText.getText(); texto.setText(resultado); Toast.makeText(getApplicationContext(),"sucesso",Toast.LENGTH_LONG).show(); } }).addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { Toast.makeText(getApplicationContext(),"falha",Toast.LENGTH_LONG).show(); } }); } }); } public Bitmap screenShot(View view) { Bitmap bitmap = Bitmap.createBitmap(view.getWidth(), view.getHeight(), Bitmap.Config.ARGB_8888); Canvas canvas = new Canvas(bitmap); view.draw(canvas); return bitmap; } } Fragment que cria a View pro desenho: public class MainFragment extends Fragment { static DrawingView dv; private Paint mPaint; private Context context; @Override public void onAttach(Context context) { this.context = context; super.onAttach(context); } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { dv = new DrawingView(context); mPaint = new Paint(); mPaint.setAntiAlias(true); mPaint.setDither(true); mPaint.setColor(Color.DKGRAY); mPaint.setStyle(Paint.Style.STROKE); mPaint.setStrokeJoin(Paint.Join.ROUND); mPaint.setStrokeCap(Paint.Cap.ROUND); mPaint.setStrokeWidth(7); return dv; } public class DrawingView extends View { public int width; public int height; private Bitmap mBitmap; private Canvas mCanvas; private Path mPath; private Paint mBitmapPaint; Context context; private Paint circlePaint; private Path circlePath; public DrawingView(Context c) { super(c); context = c; mPath = new Path(); mBitmapPaint = new Paint(Paint.DITHER_FLAG); circlePaint = new Paint(); circlePath = new Path(); circlePaint.setAntiAlias(true); circlePaint.setColor(Color.BLUE); circlePaint.setStyle(Paint.Style.STROKE); circlePaint.setStrokeJoin(Paint.Join.MITER); circlePaint.setStrokeWidth(4f); } @Override protected void onDraw(Canvas canvas) { super.onDraw(canvas); canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint); canvas.drawPath(mPath, mPaint); canvas.drawPath(circlePath, circlePaint); } private float mX, mY; private static final float TOUCH_TOLERANCE = 4; private void touch_start(float x, float y) { mPath.reset(); mPath.moveTo(x, y); mX = x; mY = y; } private void touch_move(float x, float y) { float dx = Math.abs(x - mX); float dy = Math.abs(y - mY); if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) { mPath.quadTo(mX, mY, (x + mX) / 2, (y + mY) / 2); mX = x; mY = y; circlePath.reset(); circlePath.addCircle(mX, mY, 30, Path.Direction.CW); } } private void touch_up() { mPath.lineTo(mX, mY); circlePath.reset(); // commit the path to our offscreen mCanvas.drawPath(mPath, mPaint); // kill this so we don't double draw mPath.reset(); } @Override public boolean onTouchEvent(MotionEvent event) { float x = event.getX(); float y = event.getY(); switch (event.getAction()) { case MotionEvent.ACTION_DOWN: touch_start(x, y); invalidate(); break; case MotionEvent.ACTION_MOVE: touch_move(x, y); invalidate(); break; case MotionEvent.ACTION_UP: touch_up(); invalidate(); break; } return true; } protected void clearDrawing() { dv.setDrawingCacheEnabled(false); dv.onSizeChanged(dv.width, dv.height, dv.width, dv.height); dv.invalidate(); dv.setDrawingCacheEnabled(true); } @Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { super.onSizeChanged(w, h, oldw, oldh); dv.width = w; dv.height = h; mBitmap = Bitmap.createBitmap(dv.width, dv.height, Bitmap.Config.ARGB_8888); mCanvas = new Canvas(mBitmap); } } } Qualquer ajuda é bem vinda. Desde já, grato!

Estou tentando resolver o seguinte exercício: https://www.urionlinejudge.com.br/judge/pt/problems/view/2287 Já desenvolvi esta parte, mas acredito que não tenha ido pelo caminho certo. n = int(input()) inicio = 0 meio = 10 fim = 16 num = [] letra = [] cont = 0 x = [] a = [None] * (2 * n) b = [None] * (2 * n) c = [None] * (2 * n) d = [None] * (2 * n) e = [None] * (2 * n) senha = [None] * 6 for i in range(n): x += input().split() print(x) num += x[inicio:meio] letra += x[meio:fim] inicio += 16 meio += 16 fim += fim print(num) print(letra) k = 0 while k < len(num): print(k) x = num[k] print(x) a[cont] = num[k] a[cont + 1] = num[k+1] b[cont] = num[k+2] b[cont + 1] = num[k+3] c[cont] = num[k+4] c[cont + 1] = num[k+5] d[cont] = num[k+6] d[cont + 1] = num[k+7] e[cont] = num[k+8] e[cont + 1] = num[k+9] cont += 2 k += 10 E agora eu não faço ideia de como fazer a comparação. Outra dúvida é se teria alguma forma de atribuir várias informações a um objeto, como por exemplo, chamar "a" e automaticamente fazer referencia aos dois números que fazem parte do elemento a. Como numa Struct em C ou uma Classe em Java. Teria alguma forma de fazer isso no Python? Os professores da faculdade só explicaram até matrizes, mas acredito que esta informação ajudaria a resolver este problema e inúmeros outros problemas que tenho que resolver na mesma linha de raciocínio

Boa tarde! Estou analisando o comportamento da memória ao armazenar e representar diferentes tipos de variáveis e estou com algumas dúvidas. Neste programa o objetivo é mostrar o valor de x em inteiro, hexadecimal, inteiro sem sinal, caracter correspondente a tabelas ascII e octal. #include <stdio.h> int main () { int x = 112; printf("%d %x %u %c %o\n", x, x, x, x, x); return 0; } As saídas neste caso funcionam certinho, mas ao alterar o valor para -112, por exemplo, recebo as seguintes saídas: "-112 ffffff90 4294967184 É 37777777620" Queria entender de onde veio esses números. Acredito que seja alguma conta simples, mas não consegui entender a relação deles com o -112. (Fora o primeiro caso, é claro!) Outra dúvida é em relação a este código: #include <stdio.h> void dump (void *p, int n) { unsigned char *p1 = p; while (n--) { printf("Endereco %p - %02x\n", p1, *p1); p1++; } } int main (void) { float i = 24; dump(&i, sizeof(i)); return 0; } Na saída eu tenho o endereço de memória em que a variável foi armazenada e o valor em hexadecimal armazenado naquele byte. Com variáveis do tipo inteiro, char, short int... Tudo ocorreu como esperado, mas ao executar uma variável do tipo float, os valores em hexadecimal passaram longe de ser o "24", informado na função principal. Eu sei que está correto, mas não estou conseguindo enxergar a lógica do ponto flutuante. Se alguém tiver alguma ideia do que são essas saídas, da essa força aí por favor. Outra coisa interessante é que ao atribuir valores negativos a variável i, acontece exatamente a mesma coisa do primeiro código mencionado no tópico. Acho que respondendo a primeira, já deve ser mais tranquilo de entender aqui. Desde já, obrigado.

Boa noite! Preciso da opinião de alguém que já trabalhe na área de desenvolvimento ou algo do tipo. Estudo Ciência da Computação na faculdade Anhanguera em Niterói e estou no 4º período. Consegui uma vaga para um estágio de Delphi e .Net em uma empresa muito bacana, só que justamente agora também recebi a notícia de que fui aprovado na Universidade Federal Fluminense (Que era um sonho desde o início do ensino médio) e que eu estava tentando entrar já faz tempo! Gostaria da opinião de vocês sobre o que fazer! Tenho 18 anos e acho que por ser novo, vale a pena largar tudo e começar do zero em uma nova universidade, mas que tenha um ensino de qualidade (O da Anhanguera acho bem fraco, particularmente), contudo, na UFF o horário é integral, então provavelmente vou ter que abrir mão do estágio na área. E aí? Uma faculdade de nome é tão importante assim pra conseguir um emprego futuramente ou é melhor optar pela experiência na área, mesmo que seja em um estágio? Tenho na Anhanguera uma bolsa de 100% pelo ProUni, então em nenhuma das faculdades eu vou pagar mensalidade. A diferença seria o ensino e o "nome" da instituição. Sei que faculdade só da a direção e tal e a gente tem que se virar pra estudar sozinho, mas enfim, o que vocês acham? Realmente não sei o que fazer.

Galera, estou desenvolvendo um programa de vendas e encontrei o seguinte problema. Toda vez que realizo uma venda um arquivo txt é criado e uma variável vai incrementando o valor (Ex, pedido1.txt, pedido2.txt...). Comecei declarando essa variável local, dentro da função venda dados, só que toda vez que eu saia da função e precisava retornar pra criara uma nova venda, essa variável voltava ao seu valor inicial e eu não conseguia gerar o txt, porque outro já tinha sido criado com o mesmo nome. Passei ela pra global, pra tentar corrigir, mas não funcionou também. Alguém tem alguma ideia de como resolver? Segue o código: #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <conio.h> #include <locale.h> #include <windows.h> #define BUFFER 64 #define acima 72 // Comandos do teclado pela tabela asc #define abaixo 80 #define esc 27 #define enter 13 FILE *arquivo; // ponteiro para apontar o txt das vendas. int volta = 0, conta = 0, ped = 1; // Variável para armazenar a lista de pedidos. É DECLARADA DE FORMA GLOBAL porque SE DECLARAR DENTRO DA FUNÇÃO, SEMPRE QUE VOLTARMOS PELO WHILE, ELA VAI VOLTAR A SER 1. // Estrutura da lista declarada para armazenar dados. typedef struct lista { char *nome; float preco; int cod; float valor; struct lista *proximo; } Dados; //Prototipo das funcoes de manuseio dos dados. Dados *inicia_dados(char *nome, float preco, int cod); Dados *insere_dados(Dados *dados, char *nome, float preco, int cod); void exibe_dados(Dados *dados); void busca_dados(Dados *dados, int chave); Dados *deleta_dados(Dados *dados); int checa_vazio(Dados *dados); void venda_dados(Dados *dados, FILE *arquivo, int volta, int conta, int ped); // Prototipo das funcoes do menu. void insere(void); void exibe(void); void busca(void); void deleta(void); void venda(void); // Inicializa a estrutura de dados principal. Dados *principal = NULL; //************************************************************** FUNÇÃO INICIA_DADOS (STRUCT) ************************************************************************* // Cria a nova lista apontando o proximo no para NULL. Dados *inicia_dados(char *nome, float preco, int cod) { Dados *novo; novo = (Dados *)malloc(sizeof(Dados)); novo->nome = (char *)malloc(strlen(nome)+1); strncpy(novo->nome, nome, strlen(nome)+1); novo->preco = preco; novo->cod = cod; novo->proximo = NULL; return novo; } //************************************************************** FUNÇÃO INSERE_DADOS (STRUCT) ************************************************************************* // Como a lista nao esta mais vazia, apontamos o proximo no para lista anterior. Dados *insere_dados(Dados *dados, char *nome, float preco, int cod) { Dados *novo; novo = (Dados *)malloc(sizeof(Dados)); novo->nome = (char *)malloc(strlen(nome)+1); strncpy(novo->nome, nome, strlen(nome)+1); novo->preco = preco; novo->cod = cod; novo->proximo = dados; return novo; } //************************************************************** FUNÇÃO EXIBE_DADOS ************************************************************************* // Percorre todos os campos da lista e imprime ate o ponteiro proximo chegar em NULL. void exibe_dados(Dados *dados) { fprintf(stdout, "Cadastro:\n\n"); fprintf(stdout, "------------------------\n"); for (; dados != NULL; dados = dados->proximo) { fprintf(stdout, "Nome do produto: %s\n", dados->nome); fprintf(stdout, "Código do produto: %d\n", dados->cod); fprintf(stdout, " R$: %4.2f reais \n", dados->preco); fprintf(stdout, "------------------------\n "); } printf("Pressione uma tecla para continuar."); getch(); } //************************************************************** FUNÇÃO BUSCA_DADOS ************************************************************************* // Percorre a lista comparando o nome com a chave. void busca_dados(Dados *dados, int chave) { int achou = 0; fprintf(stdout, "Cadastro:\n\n"); for (; dados != NULL; dados = dados->proximo) { if (dados->cod == chave) { printf("------------------------\n"); printf("Nome do produto: %s\n", dados->nome); printf("Código do produto: %d\n", dados->cod); printf("R$ %4.2f reais \n", dados->preco); printf("------------------------\n"); achou++; } } if (achou == 0) printf("Nenhum resultado encontrado.\nPressione uma tecla para continuar.\n"); else printf("Foram encontrados %d registros. \nPressione uma tecla para continuar.\n", achou); } //************************************************************** FUNÇÃO DELETA_DADOS ************************************************************************* // Deleta o ultimo registro inserido. Dados *deleta_dados(Dados *dados) { Dados *novo; novo = dados->proximo; free(dados->nome); free(dados); fprintf(stdout, "O ultimo registro inserido foi deletado com sucesso.\n"); Sleep(1); return novo; } //************************************************************** FUNÇÃO CHECA_VAZIO ************************************************************************* // apenas checa se a struct aponta pra NULL. int checa_vazio(Dados *dados) { if (dados == NULL) { fprintf(stdout, "Lista vazia!\n"); Sleep(1000); main(); } else return 0; } //************************************************************** FUNÇÃO VENDA_DADOS ************************************************************************* void venda_dados(Dados *dados, FILE *arquivo, int volta, int conta, int ped) { int qnt, chave, produto = 1; // Conta vai marcar o número de pedidos na fila float valor =0, preco; char cmd[256]; do{ int achou = 0; // é declarada aqui, porque se não mesmo que um produto não estivesse cadastrado ele continuaria a venda Dados *b_dados = dados; // Ponteiro para resetar o for. O For, depois de executado para no item escolhido, logo, é como se ignora-se todos os itens antes do escolhido if (!checa_vazio(principal)) { //teste se tá vazio, como na função busca, mas tudo em uma função só fprintf(stdout, "\n Digite o código do produto: \n--> "); scanf("%d", &chave); printf("\n Cadastro:\n"); for ( ; dados != NULL; dados = dados->proximo) { if (dados->cod == chave) { printf(" ------------------------\n"); printf(" Nome do produto: %s\n", dados->nome); printf(" Código do produto: %d\n", dados->cod); printf(" R$ %4.2f reais \n", dados->preco); printf(" ------------------------\n"); achou++; break; } } if (achou == 0) printf("Nenhum resultado encontrado."); else{ printf("\n\n Foram encontrados %d registros. \n\n", achou); conta++; //adiciona o número do pedido .txt printf(" Quantidade: "); scanf("%d", &qnt); arquivo = fopen("pedido.txt","a"); //criando arquivo .txt if(arquivo == NULL) printf("Erro ao se comunicar com o servidor da cozinha!"); // não conseguiu salvar o .TXT else { fprintf(arquivo," Pedido número: %d", conta); fprintf(arquivo,"\n\n-------------------------\n"); fprintf(arquivo," NOME: %s \n", dados->nome); // Vai escrever isso no .txt fprintf(arquivo," QUANTIDADE: %d\n", qnt); fprintf(arquivo,"-------------------------\n"); } fclose(arquivo); sprintf(cmd,"rename pedido.txt pedido%d.txt", ped);//muda o nome do pedido, assim, a cada nova venda é criado um novo .txt system(cmd); valor = valor + (dados->preco * qnt); // variável acumulativa printf("\n Valor total R$: %4.2f", valor); } dados = b_dados;// Reseta o for printf("\n\n Digite 1 para adicionar outro produto a venda, ou 0 para sair "); scanf("%d", &volta); if (volta == 1) { ped++;// incrementa o valor do pedido, para mudar os txt subsequentes. ENTRA AQUI, porque SE FOR ADICIONAR MAIS UM PRODUTO, NÃO CRIAR UM NOVO TXT DE PEDIDO produto++;// volta a 1 sempre, toda vez que sai da função printf("\n\n**************** PRODUTO 0%d ****************\n", produto); } else if(volta == 0) main(); //volta pra main }// chave do if lá em cima }while(volta == 1); } //************************************************************** FUNÇÃO INSERE ************************************************************************* /* Obtem os dados necessarios para chamar as funcoes de manuseio de dados. */ void insere(void) { char *nome; int cod; float preco; nome = (char *)malloc(BUFFER); printf("\n Digite o nome do produto: "); scanf("%s", nome); printf("\n Digite o código do produto: "); scanf("%d", &cod); printf("\n Digite o preço: "); scanf("%f", &preco); printf("\n\n PRODUTO CADASTRADO!"); if (principal == NULL) principal = inicia_dados(nome, preco, cod); else principal = insere_dados(principal, nome, preco, cod); } //************************************************************** FUNÇÃO EXIBE ************************************************************************* void exibe(void) { if (!checa_vazio(principal)) exibe_dados(principal); } //************************************************************** FUNÇÃO BUSCA ************************************************************************* void busca(void) { int chave; if (!checa_vazio(principal)) { printf("Digite o código do produto: \n--> "); scanf("%d", &chave); busca_dados(principal, chave); getch(); } } //************************************************************** FUNÇÃO DELETA ************************************************************************* void deleta(void) { if (!checa_vazio(principal)) principal = deleta_dados(principal); } //************************************************************** FUNÇÃO VENDA ************************************************************************* void venda(void){ // venda_dados(principal, arquivo); venda_dados(principal, arquivo, volta, conta, ped); } //************************************************************* FUNÇÕES DA SETA ************************************************************************** inicio01() { system("cls"); printf("\n ------ Menu Principal --------\n"); printf(" \n"); printf(" --> Nova venda \n"); printf(" Cadastrar produto \n"); printf(" Exibir produtos \n"); printf(" Buscar produto \n"); printf(" Deletar Dados \n"); printf(" Sair \n"); printf(" -------------------------------"); int ch; ch=getch(); if (ch==enter) { system("cls"); printf("\t NOVA VENDA\n\n"); venda();//Chama a função sleep(1000); } if (ch==224) ch=getch(); if (ch==acima) inicio06(); else if (ch==abaixo) inicio02(); else inicio01(); } //************************************************************** INÍCIO 02 *********************************************************************** inicio02() { system("cls"); printf("\n ------ Menu Principal --------\n"); printf(" \n"); printf(" Nova venda \n"); printf(" --> Cadastrar produto \n"); printf(" Exibir produtos \n"); printf(" Buscar produto \n"); printf(" Deletar Dados \n"); printf(" Sair \n"); printf(" -------------------------------"); int ch; ch=getch(); if (ch==enter) { system("cls"); printf("\t CADASTRO DE PRODUTOS\n\n"); insere(); Sleep(1000); } else if (ch==224) ch=getch(); if (ch==acima) inicio01(); else if (ch==abaixo) inicio03(); else inicio02(); } //************************************************************** INÍCIO 03 *********************************************************************** inicio03() { system("cls"); printf("\n ------ Menu Principal --------\n"); printf(" \n"); printf(" Nova venda \n"); printf(" Cadastrar produto \n"); printf(" --> Exibir produtos \n"); printf(" Buscar produto \n"); printf(" Deletar Dados \n"); printf(" Sair \n"); printf(" -------------------------------"); int ch; ch=getch(); if (ch==enter) { system("cls"); printf("\t EXIBIR PRODUTOS\n\n"); exibe(); Sleep(1000); } else if (ch==224) ch=getch(); if (ch==acima) inicio02(); else if (ch==abaixo) inicio04(); else inicio03(); } //************************************************************** INÍCIO 04 *********************************************************************** inicio04() { system("cls"); printf("\n ------ Menu Principal --------\n"); printf(" \n"); printf(" Nova venda \n"); printf(" Cadastrar produto \n"); printf(" Exibir produtos \n"); printf(" --> Buscar produto \n"); printf(" Deletar Dados \n"); printf(" Sair \n"); printf(" -------------------------------"); int ch; ch=getch(); if (ch==enter) { system("cls"); printf("\t BUSCA DE PRODUTOS\n\n"); busca(); Sleep(1000); } else if (ch==224) ch=getch(); if (ch==acima) inicio03(); else if (ch==abaixo) inicio05(); else inicio04(); } //************************************************************** INÍCIO 05 *********************************************************************** inicio05() { system("cls"); printf("\n ------ Menu Principal --------\n"); printf(" \n"); printf(" Nova venda \n"); printf(" Cadastrar produto \n"); printf(" Exibir produtos \n"); printf(" Buscar produto \n"); printf(" --> Deletar Dados \n"); printf(" Sair \n"); printf(" -------------------------------"); int ch; ch=getch(); if (ch==enter) { system("cls"); printf("\t DELETAR DADOS\n\n"); deleta(); Sleep(1000); } else if (ch==224) ch=getch(); if (ch==acima) inicio04(); else if (ch==abaixo) inicio06(); else inicio05(); } //************************************************************** INÍCIO 06 *********************************************************************** inicio06() { system("cls"); printf("\n ------ Menu Principal --------\n"); printf(" \n"); printf(" Nova venda \n"); printf(" Cadastrar produto \n"); printf(" Exibir produtos \n"); printf(" Buscar produto \n"); printf(" Deletar Dados \n"); printf(" --> Sair \n"); printf(" -------------------------------"); int ch; ch=getch(); if (ch==enter) { exit(0); } else if (ch==224) ch=getch(); if (ch==acima) inicio05(); else if (ch==abaixo) inicio01(); else inicio06(); } //************************************************************** FUNÇÃO MAIN ************************************************************************* int main() { setlocale(LC_ALL, "Portuguese"); system("color 4E"); system("cls"); while(1) inicio01(); return 0; }

Estou tentando desenvolver um programa de vendas. Cada venda gerada será salva em um .txt. O objetivo era ler esses .txt de outro programa. A primeira parte da criação da venda já está praticamente toda pronta e abaixo segue o código do programa que vai ler os arquivos: #include <stdio.h> #include <stdlib.h> #include <locale.h> #include <windows.h> #include <pthread.h> void *cronometro(void *dados) { int seg, min = 0; char info [50], ped, nome_arquivo[20]; int contador=1, fim, errno; FILE *arq; system("color 20"); for(min=00; min<=60; min++) { for(seg=00; seg<=60; seg++) { sleep(1); system("cls"); sprintf(nome_arquivo, "pedido%d.txt", contador); //SPRINTf é utilizado para usar a variável na busca do arquivo. Printa o nome do arquivo no vetor "NOME_ARQUIVO". arq = fopen(nome_arquivo, "r"); if(arq == NULL) printf("\nNenhum novo pedido na fila"); while((fgets(info, sizeof(info), arq)) !=NULL) printf(" %s", info); fclose(arq); printf("\n TEMPO DE ESPERA DO CLIENTE: %dm%ds \n\n Tecle <ENTER> para finalizar o prepapro. ", min, seg); fflush(stdout); } if (min==1) system("color 60"); else if(min==2) system("color 47"); } return NULL; } int main() { setlocale(LC_ALL, "portuguese"); int volta; do{ pthread_t thr_id; if((errno=pthread_create(&thr_id, NULL, cronometro, NULL))!=0) { fprintf(stderr, "\nErro %d na criacao da thread. Abortando.\n", errno); return 1; } scanf("*[^\n]%*1[\n]"); pthread_cancel(thr_id); printf("\n PEDIDO FINALIZADO COM SUCESSO!\n"); printf("\n Digite 1 para atualizar a lista de pedidos: "); scanf("%d", &volta); }while(volta==1); return 0; } Os arquivos serão salvos com o nome de "pedido%d.txt" e ali virá uma variável de forma que a cada nova venda, um novo arquivo seja criado. Dessa forma eu posso pegar depois os arquivos independentes, como descrito no código. O que queria fazer agora era um marcador de tempo que mudasse a cor do console dependendo da demora no preparo do produto, contudo, preciso também usar um scanf ou algo do tipo pra que o usuário informe que o produto está terminado e um novo arquivo apareça na tela. Pesquisando, achei esse link: https://www.vivaolinux.com.br/topico/C-C++/Cronometro Fiz algumas adaptações e meio que funcionou, mas agora o thread não para de executar para que o usuário informe que o produto está pronto. Alguém tem alguma ideia de como resolver o problema?

Funcionou direitinho! Muito obrigado cara, salvou aqui rs.

Muito obrigado! Funcionou perfeitamente. Só mais uma dúvida. Como faço para resetar o ponteiro? Entendi como funciona e o que ocasionou o problema no for, mas não sei como montar a sintaxe em si. dados->proximo =NULL; ?

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <conio.h> #include <locale.h> #include <windows.h> #define BUFFER 64 FILE *arquivo; // ponteiro para armazenar as compras. /* Estrutura da lista declarada para armazenar dados. */ typedef struct lista { char *nome; float preco; int cod; float valor; // char *obs; verificar VARIÁVEL PARA ARMAZENAR TEXTO || QUERIA COLOCAR MAIS UM CAMPO NO CADASTRO, MAS AINDA TIVE ALGUNS PROBLEMAS E DEIXEI ASSIM mesmo POR ENQUANTO struct lista *proximo; } Dados; /* Prototipo das funcoes de manuseio dos dados. */ Dados *inicia_dados(char *nome, float preco, int cod/*,char *obs*/); Dados *insere_dados(Dados *dados, char *nome, float preco, int cod/*, char *obs*/); void exibe_dados(Dados *dados); void busca_dados(Dados *dados, int chave); Dados *deleta_dados(Dados *dados); int checa_vazio(Dados *dados); /* Prototipo das funcoes do menu.*/ void insere(void); void exibe(void); void busca(void); void deleta(void); /* Inicializa a estrutura de dados principal. */ Dados *principal = NULL; //************************************************************** FUNÇÃO INICIA_DADOS (STRUCT) ************************************************************************* /* Cria a nova lista apontando o proximo no para NULL. */ Dados *inicia_dados(char *nome, float preco, int cod/*, char *obs*/) { Dados *novo; novo = (Dados *)malloc(sizeof(Dados)); novo->nome = (char *)malloc(strlen(nome)+1); strncpy(novo->nome, nome, strlen(nome)+1); novo->preco = preco; novo->cod = cod; // novo->obs = obs; /* novo->nome = (char*)malloc(strlen(obs)+1); strncpy(novo->obs, obs, strlen(obs)+1);*/ novo->proximo = NULL; return novo; } //************************************************************** FUNÇÃO INSERE_DADOS (STRUCT) ************************************************************************* /* Como a lista nao esta mais vazia, apontamos o proximo no para lista anterior. */ Dados *insere_dados(Dados *dados, char *nome, float preco, int cod/*, char *obs*/) { Dados *novo; novo = (Dados *)malloc(sizeof(Dados)); novo->nome = (char *)malloc(strlen(nome)+1); strncpy(novo->nome, nome, strlen(nome)+1); novo->preco = preco; novo->cod = cod; /* novo->nome = (char*)malloc(strlen(obs)+1); strncpy(novo->obs, obs, strlen(obs)+1);*/ novo->proximo = dados; return novo; } //************************************************************** FUNÇÃO EXIBE_DADOS ************************************************************************* /* Percorre todos os campos da lista e imprime ate o ponteiro proximo chegar em NULL. */ void exibe_dados(Dados *dados) { fprintf(stdout, "Cadastro:\n\n"); fprintf(stdout, "------------------------\n"); for (; dados != NULL; dados = dados->proximo) { fprintf(stdout, "Nome do produto: %s\n", dados->nome); fprintf(stdout, "Código do produto: %d\n", dados->cod); fprintf(stdout, " R$: %4.2f reais \n", dados->preco); // fprintf(stdout, " Anotações: %s \n", dados->obs); fprintf(stdout, "------------------------\n "); } printf("Pressione uma tecla para continuar."); getch(); } //************************************************************** FUNÇÃO BUSCA_DADOS ************************************************************************* /* Percorre cada ponta comparando o nome com a chave. */ void busca_dados(Dados *dados, int chave) { int achou = 0; fprintf(stdout, "Cadastro:\n\n"); for (; dados != NULL; dados = dados->proximo) { if (dados->cod == chave) { fprintf(stdout, "------------------------\n"); fprintf(stdout, "Nome do produto: %s\n", dados->nome); fprintf(stdout, "Código do produto: %d\n", dados->cod); fprintf(stdout, "R$ %4.2f reais \n", dados->preco); // fprintf(stdout, " Anotações: %s \n", dados->obs); fprintf(stdout, "------------------------\n"); achou++; } } if (achou == 0) fprintf(stdout, "Nenhum resultado encontrado.\nPressione uma tecla para continuar.\n"); else fprintf(stdout, "Foram encontrados %d registros. \nPressione uma tecla para continuar.\n", achou); getch(); } //************************************************************** FUNÇÃO DELETA_DADOS ************************************************************************* /* Deleta o ultimo registro inserido. */ Dados *deleta_dados(Dados *dados) { Dados *novo; novo = dados->proximo; free(dados->nome); free(dados); // free(dados->obs); VOU DEIXAR DE COMENTÁRIO porque É UM PONTEIRO fprintf(stdout, "O ultimo registro inserido foi deletado com sucesso.\\n"); Sleep(1); return novo; } //************************************************************** FUNÇÃO CHECA_VAZIO ************************************************************************* /* apenas checa se a lista é NULL ou nao. */ int checa_vazio(Dados *dados) { if (dados == NULL) { fprintf(stdout, "Lista vazia!\n"); Sleep(1); return 1; } else return 0; } //************************************************************** FUNÇÃO VENDA_DADOS ************************************************************************* void venda_dados(Dados *dados, FILE *arquivo) { int achou = 0, volta, qnt, conta = 0, chave; // Conta vai marcar o número de pedidos na fila float valor =0, preco; do{ if (!checa_vazio(principal)) { fprintf(stdout, "Digite o código do produto: \n--> "); scanf("%d", &chave); printf("\nCadastro:\n"); for ( ; dados != NULL; dados = dados->proximo) { if (dados->cod == chave) { printf("------------------------\n"); printf("Nome do produto: %s\n", dados->nome); printf("Código do produto: %d\n", dados->cod); printf("R$ %4.2f reais \n", dados->preco); // fprintf(stdout, " Anotações: %s \n", dados->obs); printf("------------------------\n"); achou++; } } if (achou == 0) printf("Nenhum resultado encontrado.\nPressione uma tecla para continuar.\n"); else{ printf("Foram encontrados %d registros. \n\n", achou); conta++; //adiciona 1 pedido no .txt printf(" Quantidade: "); scanf("%d", &qnt); arquivo = fopen("pedido.txt", "w"); //criando arquivo .txt if(arquivo == NULL) printf("Erro ao se comunicar com o servidor da cozinha!"); // não conseguiu salvar o .TXT else { fprintf(arquivo,"Pedidos na fila: %d\n\n", conta); fprintf(arquivo,"-------------------------\n"); fprintf(arquivo," NOME: %s \n", dados->nome); // Vai escrever isso no .txt fprintf(arquivo," QUANTIDADE: %d\n", qnt); fprintf(arquivo,"-------------------------"); } valor = valor + ((dados->preco) * qnt); printf("Valor total = %4.2f", valor); } printf("\nDigite 1 para adicionar outro produto a venda, ou 0 para sair "); scanf("%d", &volta); }// chave do if lá em cima }while(volta == 1); } //************************************************************** FUNÇÃO INSERE ************************************************************************* /* Obtem os dados necessarios para chamar as funcoes de manuseio de dados. */ void insere(void) { char *nome; int cod; float preco; // char *obs; nome = (char *)malloc(BUFFER); // obs = (char*)malloc(BUFFER); printf("\n Digite o nome do produto: "); scanf("%s", nome); // TESTAR printf("\n Digite o código do produto: "); scanf("%d", &cod); printf("\n Digite o preço: "); scanf("%f", &preco); /*printf(stdout, "Anotações sobre o produto(Ex: Ingredientes, modo de preparo...): "); scanf("%d", &obs); fprintf(stdout, "\n");*/ printf("\n\n PRODUTO CADASTRADO!"); if (principal == NULL) principal = inicia_dados(nome, preco, cod/*, obs*/); else principal = insere_dados(principal, nome, preco, cod/*, obs*/); } //************************************************************** FUNÇÃO EXIBE ************************************************************************* void exibe(void) { if (!checa_vazio(principal)) exibe_dados(principal); } //************************************************************** FUNÇÃO BUSCA ************************************************************************* void busca(void) { int chave; if (!checa_vazio(principal)) { printf("Digite o código do produto: \n--> "); scanf("%d", &chave); busca_dados(principal, chave); getch(); } } //************************************************************** FUNÇÃO DELETA ************************************************************************* void deleta(void) { if (!checa_vazio(principal)) principal = deleta_dados(principal); } //************************************************************** FUNÇÃO VENDA ************************************************************************* void venda(void){ venda_dados(principal, arquivo); } //************************************************************** FUNÇÃO MAIN ************************************************************************* int main() { int escolha; do { setlocale(LC_ALL, "Portuguese"); system("color 4E"); system("cls"); printf("\n\t LANCHONETE \n\n"); printf(" Nova venda ---------- [1] \n"); printf(" Cadastrar produto --- [2] \n"); printf(" Exibir produtos ----- [3] \n"); printf(" Buscar produto ------ [4] \n"); printf(" Deletar Dados ------- [5] \n"); printf(" Sair ---------------- [6] \n"); printf("\n Escolha uma opção: "); scanf("%d", &escolha); system("cls"); if(escolha == 1){ printf("\t NOVA VENDA\n\n"); venda(); } else if(escolha == 2){ printf("\t CADASTRO DE PRODUTOS\n\n"); insere(); Sleep(1); } else if(escolha == 3){ printf("\t EXIBIR PRODUTOS\n\n"); exibe(); } else if(escolha == 4){ printf("\t BUSCA DE PRODUTOS\n\n"); busca(); } else if(escolha == 5){ printf("\t DELETAR DADOS\n\n"); deleta(); } else if(escolha == 6) exit(0); else{ printf("Digite uma opcao valida!\n"); Sleep(1); } } while (escolha > 0); /* Loop Principal. */ return 0; } adicionado 58 minutos depois

Boa tarde! Estou desenvolvendo um programa na faculdade que cadastra produtos e depois realiza uma venda. Esta venda é salva em .txt e será usada posteriormente em outro programa. Entretanto, estou com algumas dificuldades. Segue parte do código onde se encontram os problemas: void venda_dados(Dados *dados, FILE *arquivo) { int achou = 0, volta, qnt, conta = 0, chave; // Conta vai marcar o número de pedidos na fila float valor =0, preco; do{ if (!checa_vazio(principal)) { printf("Digite o código do produto: \n--> "); scanf("%d", &chave); printf("\nCadastro:\n"); for ( ; dados != NULL; dados = dados->proximo) { if (dados->cod == chave) { printf("------------------------\n"); printf("Nome do produto: %s\n", dados->nome); printf("Código do produto: %d\n", dados->cod); printf("R$ %4.2f reais \n", dados->preco); printf("------------------------\n"); achou++; } } if (achou == 0) printf("Nenhum resultado encontrado.\nPressione uma tecla para continuar.\n"); else{ printf("Foram encontrados %d registros. \n\n", achou); conta++; //adiciona 1 pedido no .txt printf(" Quantidade: "); scanf("%d", &qnt); arquivo = fopen("pedido.txt", "a"); //criando arquivo .txt if(arquivo == NULL) printf("Erro ao se comunicar com o servidor da cozinha!"); // não conseguiu salvar o .TXT else { fprintf(arquivo,"Pedidos na fila: %d\n\n", conta); fprintf(arquivo,"-------------------------\n"); fprintf(arquivo," NOME: %s \n", dados->nome); // Vai escrever isso no .txt OU PELO MENOS DEVERIA fprintf(arquivo," QUANTIDADE: %d\n", qnt); fprintf(arquivo,"-------------------------"); } valor = valor + ((dados->preco) * qnt); // CÁLCULO NÃO FUNCIONA printf("Valor total = %4.2f", valor); } printf("\nDigite 1 para adicionar outro produto a venda, ou 0 para sair "); scanf("%d", &volta); }// chave do if lá em cima }while(volta == 1); } O programa compila e executa corretamente (Lembrando que essa é só a função que está com problema), mas quando executo, acontece o seguinte: 1° problema: Na linha "fprintf(arquivo," NOME: %s \n", dados->nome);" o programa para de funcionar. Se eu tirar o apontamento "dados->nome", funciona tranquilo. O ponteiro " *arquivo " usado como argumento na função foi declarado globalmente lá em cima.; 2° problema: Na linha da variável acumulativa "valor = valor + ((dados->preco) * qnt);" Acontece o mesmo problema do apontamento (retirei a parte do arquivo em cima pra poder chegar a essa parte do código sem erros); 3° problema: Esse me parece ser um pouco mais simples, mas ainda não consegui resolver. Se eu ignorar os erros listados acima com um comentário ou algo do tipo, o produto é cadastrado, mas quando "volta = 1", indicando que eu quero adicionar mais um produto a venda, ou seja, retornando ao início do "do while" o programa me pede o código, mas não entre no "for". Não lista o nome do produto e cai direto na quantidade. É a primeira vez que estou trabalhando ponteiros nessa proporção e estou bem perdido. Qualquer coisa eu posso postar o código completo. Desde já, agradeço a ajuda.

É exatamente isso que eu quero fazer, só não sei como. Teria que declarar a variável do nome do tipo char por exemplo, aí eu usaria um ponteiro, pra poder pesquisar também por ela? Dá uma luz por favor.

#include <stdio.h> #include <stdlib.h> #include <conio.h> #include <windows.h> #include <locale.h> //CRIANDO A ESTRUTURA DO TIPO_LISTA struct Tipo_Lista { //Criando uma estrutura, vou poder usar variáveis do tipo lista, que irão suportar os dois itens abaixo int cod; // Código que vamos buscar, pesquisar, imprimir... struct Tipo_Lista *Prox; //O ponteiro vai conter toda a estrutura }; struct Tipo_Lista *Primeiro; //Aponta para o primeiro elemento inserido na lista struct Tipo_Lista *Ultimo; //Aponta para o último elemento inserido na lista //FUNÇÃO PARA CRIAR A LISTA VAZIA void FLVazia () { //Função para finalmente criar a lista vazia struct Tipo_Lista *aux; // Declaração de uma variável auxiliar do tipo lista ALOCA # TAMANHO DE aux = (struct Tipo_Lista*)malloc(sizeof(struct Tipo_Lista)); //alocando espaço na memória para "aux" com a função malloc ##### VARIÁVEL = (TIPO DO ARQUIVO/VARIÁVEL) MALLOC ( SIZEOF (TIPO DO ARQUIVO OU NOME DA VARIÁVEL) Primeiro = aux; Ultimo = Primeiro; //neste momento as três variáveis apontam para o local de origem da lista, o local de partida } //FUNÇÃO PARA INSERIR UM ELEMENTO void Insere (int x) { //x = ao novo elemento a inserir, no caso o "cod", declarado na primeira estrutura struct Tipo_Lista *aux; aux = (struct Tipo_Lista*)malloc(sizeof(struct Tipo_Lista)); aux->cod = x; // a seta (->) é porque nesse caso é um apontador. Se fosse um registrador normal, seria o "." Ultimo->Prox = aux; //Agora só a variável "Ultimo" faz ligação com "aux", que é o próximo item Ultimo = Ultimo->Prox; //"Ultimo" recebe a posição de memória do ultimo item que foi inserido ### Ele saiu da posição que se encontrava na função "FLVazia" aux->Prox = NULL; //Serve como condição de parada } //FUNÇÃO PARA IMPRIMIR void Imprime () { struct Tipo_Lista *aux; aux = Primeiro->Prox; //Recebe o "Primeiro.Prox", pra cair na segunda posição da fila. Só observar a primeira função! while(aux!= NULL) { // Enquanto a lista não chegar ao fim, ele fica dentro do laço printf("Item %d\n\n", aux ->cod); aux = aux->Prox; //IMPORTANTE! "aux" recebe o valor da próxima posição da lista. Desta forma, a lista pode andar. } } //FUNÇÃO PARA PESQUISAR void Pesquisa (int x) { // "x" vai ser o item que você quer procurar (ELE VAI SER COMPARADO COM TODOS OS ITENS DA LISTA) struct Tipo_Lista *aux;//De novo rs int flag = 0; //O "flag" vai dar apenas um apoio pra saberse ele acgou ou não o item. Não entendi porque o nome é FLAG, se a tradução é BANDEIRA aux = Primeiro->Prox; //Primeira posição de memória que tem um item inserido while(aux != NULL){//Repete testando os espaços da lista. Se encontrou, ele para de procurar. if(aux->cod == x){//Se ele encontrou o item "x" no espaço de memória "aux->cod", ele entra na condicionál printf("Achou o item %d", x); flag=1; //Flag vira um para que ele não caia naquele if láááá de baixo. aux = NULL; //aux = NULL para sair do while } else{ aux = aux->Prox; // Se ele não encontrou naquela posição (A que estava no if aqui em cima) ele anda uma posição e testa novamente. Se não, de novo... até o fim da lista. } } if(!flag){ //Percorreu a lista toda e não encontrou (LEMBRANDO QUE 0=VERDADEIRO E 1= FALSO) printf("Item %d, não se encontra na lista", x); } } main() { setlocale(LC_ALL, "portuguese"); FLVazia(); int opcao, volta; int a=0, codigo; while(1){ system("cls"); printf("\n\n ADICIONAR PRODUTO ------- [1]\n"); printf(" REMOVER PRODUTO ----------[2]\n"); printf(" VISUALIZAR PRODUTOS------ [3]\n"); printf(" PESQUISAR PRODUTOS------- [4]\n"); printf(" SAIR -------------------- [5]\n"); scanf("%d", &opcao); if(opcao == 1){ do{ printf("\nInforme o codigo do produto: "); scanf("%d", &codigo); Insere(codigo); printf("\nDeseja adicionar um novo produto? Sim = 1 ou Não = 0 \n\n"); scanf("%d", &volta); }while(volta == 1); } else if(opcao == 2) printf("Tô fazendo essa função ainda"); else if(opcao == 3){ Imprime(); } else if(opcao == 4) { printf("Digite o código do produto para pesquisa: "); scanf("%d", &codigo); Pesquisa(codigo); } else if(opcao == 5) exit(0); else printf("Opção inválida!"); system("pause"); } return 0; } Fala galera, estou tentando aprender sobre listas encadeadas, mas está complicado.Desenvolvi este código acima que cria uma lista de itens. O que gostaria de fazer agora é criar uma lista de cadastro de produtos. Por exemplo, para cada item adicionado eu tenha nome, código, preço... essas coisas, mas tudo em um item somente e repetir esse processo para cada item. Alguém tem alguma ideia de como fazer isso?

Fala galera! Estou desenvolvendo um sistema pra uma lanchonete (um trabalho da faculdade) e estou com diversos problemas para criar as listas encadeadas. O sistema consiste em cadastrar novos produtos e realizar uma venda somando o preço dos produtos escolhidos naquele instante. A parte de cadastrar os produtos está praticamente pronta, mas ainda estou com alguns problemas. Já a parte da soma dos produtos, eu não faço a mínima ideia do que fazer. Segue código: #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <conio.h> //clrscr #include <locale.h> #define BUFFER 64 /* Estrutura da lista declarada para armazenar nossos dados. */ typedef struct lista { char *nome; float preco; char *obs; struct lista *proximo; } Dados; /* Prototipo das funcoes de manuseio dos dados. */ Dados *inicia_dados(char *nome, float preco, char *obs); Dados *insere_dados(Dados *dados, char *nome, float preco, char *obs); void exibe_dados(Dados *dados); void busca_dados(Dados *dados, char *chave); Dados *deleta_dados(Dados *dados); int checa_vazio(Dados *dados); /* Prototipo das funcoes do menu.*/ void insere(void); void exibe(void); void busca(void); void deleta(void); /* Inicializa a estrutura de dados principal. */ Dados *principal = NULL; /* Cria a nova lista apontando o proximo no para NULL. */ Dados *inicia_dados(char *nome, float preco, char *obs) { Dados *novo; novo = (Dados *)malloc(sizeof(Dados)); novo->nome = (char *)malloc(strlen(nome)+1); strncpy(novo->nome, nome, strlen(nome)+1); //*************************************** novo->preco = preco; //*************************************** novo->obs = (char *)malloc(strlen(obs)+1); strncpy(novo->obs, obs, strlen(obs)+1); //*************************************** novo->proximo = NULL; return novo; } /* Como a lista nao esta mais vazia, apontamos o proximo no para lista anterior. */ Dados *insere_dados(Dados *dados, char *nome, float preco, char *obs) { Dados *novo; novo = (Dados *)malloc(sizeof(Dados)); novo->nome = (char *)malloc(strlen(nome)+1); strncpy(novo->nome, nome, strlen(nome)+1); novo->preco = preco; novo->obs = (char *)malloc(strlen(obs)+1); strncpy(novo->obs, obs, strlen(obs)+1); novo->proximo = dados; return novo; } /* Percorre todos os campos da lista e imprime ate o ponteiro proximo chegar em NULL. */ void exibe_dados(Dados *dados) { fprintf(stdout, "Cadastro:\n\n"); fprintf(stdout, "------------------------\n"); for (; dados != NULL; dados = dados->proximo) { fprintf(stdout, "Nome: %s\n", dados->nome); fprintf(stdout, "Idade: %d\n", dados->preco); fprintf(stdout, "Observações: %s\n", dados->obs); fprintf(stdout, "------------------------\n "); } printf("Pressione uma tecla para continuar."); getch(); } /* Percorre cada ponta comparando o nome com a chave. */ void busca_dados(Dados *dados, char *chave) { int achou = 0; fprintf(stdout, "Cadastro:\n\n"); for (; dados != NULL; dados = dados->proximo) { if (strcmp(chave, dados->nome) == 0) { fprintf(stdout, "------------------------\n"); fprintf(stdout, "Nome: %s\n", dados->nome); fprintf(stdout, "Preço: %d\n", dados->preco); fprintf(stdout, "Observações: %s\n", dados->obs); fprintf(stdout, "------------------------\n"); achou++;// muda o valor de achou } } if (achou == 0) fprintf(stdout, "Nenhum resultado encontrado.\nPressione uma tecla para continuar.\n"); else fprintf(stdout, "Foram encontrados %d registros. \nPressione uma tecla para continuar.\n", achou); sleep(1); getch(); } /* Deleta o ultimo registro inserido. */ Dados *deleta_dados(Dados *dados) { Dados *novo; novo = dados->proximo; free(dados->nome); free(dados); free(dados->obs); fprintf(stdout, "O ultimo registro inserido foi deletado com sucesso.\\n"); sleep(1); return novo; } /* apenas checa se a lista e NULL ou nao. */ int checa_vazio(Dados *dados) { if (dados == NULL) { fprintf(stdout, "Lista vazia!\\n"); sleep(1); return 1; } else return 0; } /* Obtem os dados necessarios para chamar as funcoes de manuseio de dados. */ void insere(void) { char *nome, obs; float preco; nome = (char *)malloc(BUFFER); obs = (char *)malloc(BUFFER); printf("\n\Nome do produto: \n----> "); scanf("%s", nome); printf("\nPreço do produto: \n----> "); scanf("%f", &preco); printf("\nObservações sobre o produto: (Ex: ingredientes, quantidade...)"); scanf("%s", obs); if (principal == NULL) principal = inicia_dados(nome, preco, obs); else principal = insere_dados(principal, nome, preco, obs); } void exibe(void) { if (!checa_vazio(principal)) exibe_dados(principal); } void busca(void) { char *chave; if (!checa_vazio(principal)) { chave = (char *)malloc(BUFFER); fprintf(stdout, "Digite o nome para buscar: \\n--> "); scanf("%s", chave); busca_dados(principal, chave); getch(); } } void deleta(void) { if (!checa_vazio(principal)) principal = deleta_dados(principal); } int main(void) { setlocale(LC_ALL,"portuguese"); int escolha, volta; do { system("cls"); printf("\n LANCHONETE\n\n"); printf(" NOVA VENDA ---------- [1]\n"); printf(" INSERIR PRODUTO ----- [2]\n"); printf(" MOSTRAR PRODUTOS ---- [3]\n"); printf(" BUSCAR PRODUTO ------ [4]\n"); printf(" EXCLUIR PRODUTO ----- [5]\n"); printf(" SAIR ---------------- [6]\n\n"); printf("\n\nEscolha uma opcao: "); scanf("%d", &escolha); if (escolha == 1) printf("EM CONSTRUÇÃO!");// Não tenho ideia do que fazer aqui else if(escolha == 2) insere(); else if (escolha ==2) exibe(); else if (escolha ==3) busca(); else if (escolha ==4) deleta(); else if (escolha ==5) exit(0); else { fprintf(stderr," Digite uma opcao valida!\\n"); sleep(1); } printf("\n\n Digite 1 para voltar ao menu, precione outra tecla para sair: "); scanf("%d", &volta); }while(volta == 1 ); /* Loop Principal. */ return 0; } Estou começando a trabalhar com essa questão de alocamento dinâmico agora e estou muito perdido. Desde já, agradeço.

@MassakiMsk Muito obrigado cara!

Olá galera! Preciso fazer um projeto para a faculdade que vai utilizar os conceitos de alocamento dinâmico de memória, usando listas encadeadas, pilha... essas coisas. Nunca trabalhei com algo desse tipo e buscando uns vídeos no youtube, fui fazendo o passo a passo conforme explicado. Segue o código: #include <stdio.h> #include <stdlib.h> #include <conio.h> #include <windows.h> //CRIANDO A ESTRUTURA DO TIPO_LISTA struct Tipo_Lista { //Criando uma estrutura, vou poder usar variáveis do tipo lista, que irão suportar os dois itens abaixo int cod; // Código que vamos buscar, pesquisar, imprimir... struct Tipo_lista *Prox; //O ponteiro vai conter toda a estrutura } struct Tipo_Lista *Primeiro; //Aponta para o primeiro elemento inserido na lista struct Tipo_Lista *Ultimo; //Aponta para o último elemento inserido na lista //FUNÇÃO PARA CRIAR A LISTA VAZIA void FLVazia () { //Função para finalmente criar a lista vazia struct Tipo_Lista *aux; // Declaração de uma variável auxiliar do tipo lista ALOCA # TAMANHO DE aux = (struct Tipo_Lista*)malloc(sizeof(struct Tipo_lista)); //alocando espaço na memória para "aux" com a função malloc ##### VARIÁVEL = (TIPO DO ARQUIVO/VARIÁVEL) MALLOC ( SIZEOF (TIPO DO ARQUIVO OU NOME DA VARIÁVEL) Primeiro = aux; Ultimo = Primeiro; //neste momento as três variáveis apontam para o local de origem da lista, o local de partida } //FUNÇÃO PARA INSERIR UM ELEMENTO void Insere (int x) { //x = ao novo elemento a inserir, no caso o "cod", declarado na primeira estrutura struct Tipo_Lista *aux; aux = (struct Tipo_Lista*)malloc(sizeof(struct Tipo_lista)); aux->cod = x; // a seta (->) é porque nesse caso é um apontador. Se fosse um registrador normal, seria o "." Ultimo->Proximo = aux; //Agora só a variável "Ultimo" faz ligação com "aux", que é o próximo item Ultimo = Ultimo->Prox; //"Ultimo" recebe a posição de memória do ultimo item que foi inserido ### Ele saiu da posição que se encontrava na função "FLVazia" aux->Prox = NULL; //Serve como condição de parada } //FUNÇÃO PARA IMPRIMIR void Imprime () { struct Tipo_Lista *aux; aux = Primeiro->Prox; //Recebe o "Primeiro.Prox", pra cair na segunda posição da fila. Só observar a primeira função! while(aux!= NULL) { // Enquanto a lista não chegar ao fim, ele fica dentro do laço printf("Item %d", aux ->cod); aux = aux->Prox; //IMPORTANTE! "aux" recebe o valor da próxima posição da lista. Desta forma, a lista pode andar. } } //FUNÇÃO PARA PESQUISAR void Pesquisa (int x) { // "x" vai ser o item que você quer procurar (ELE VAI SER COMPARADO COM TODOS OS ITENS DA LISTA) struct Tipo_Lista *aux;//De novo rs int = flag = 0; //O "flag" vai dar apenas um apoio pra saberse ele acgou ou não o item. Não entendi porque o nome é FLAG, se a tradução é BANDEIRA aux = Primeiro->Prox; //Primeira posição de memória que tem um item inserido while(aux != NULL){//Repete testando os espaços da lista. Se encontrou, ele para de procurar. if(aux->cod == x){//Se ele encontrou o item "x" no espaço de memória "aux->cod", ele entra na condicionál printf("Achou o item %d", x); flag=1; //Flag vira um para que ele não caia naquele if láááá de baixo. aux = NULL //aux = NULL para sair do while } else{ aux = aux->Prox; // Se ele não encontrou naquela posição (A que estava no if aqui em cima) ele anda uma posição e testa novamente. Se não, de novo... até o fim da lista. } } if(!flag){ //Percorreu a lista toda e não encontrou (LEMBRANDO QUE 0=VERDADEIRO E 1= FALSO) printf("Item %d, não se encontra na lista", x); } } main() { } Este é o vídeo que estava assistindo (parte1 e 2): O do cara no vídeo, compilou de boa, mas o meu deu muitos erros. Alguém tem alguma ideia de qual é o problema?