Vetores e funcoes

[Flames]

Implemente um programa a C que permita ao utilizador efetuar as seguintes

operações:

1. Perguntar ao utilizador o número n de elementos com que deseja trabalhar.

2. Introduzir uma sequência de n números inteiros.

3. Escrever no ecrã a sequência introduzida.

4. Permite procurar o maior número da sequência.

So fiz até a alinea três por enquanto quero eliminar erros já de raiz...

#include <stdio.h>
#include <stdlib.h>
#define MAX 200

int menu(void);
int funcaon(void);
int funcaointroduzir(int vetor[], int n);
void funcaoimprime(int v[], int tam);
int main(void){
       int opcao;
       int n;
       int vetor[MAX]={0};
   do{

       opcao=menu();
       switch (opcao) {

            case 1:
            {
                n=funcaon();
                break;
                }

            case 2:
            {
                funcaointroduzir(vetor,n);
                break;
                }
             case 3:
            {
                funcaoimprime(vetor,n);
                break;
                }
            }
        }
    while(opcao!=4);

return 0;
}

int menu (void){                    /* menu */
        int op;
        printf("\n\t <*> MENU <*>");
        printf("\n 1- Numero de elementos com que deseja trabalhar");
        printf("\n 2- Introduzir elementos");
        printf("\n 3- Escrever no ecra os elementos");
        printf("\n 4- sair\n");
        scanf("%d",&op);
        return(op);
    }

int funcaon(void){
    int n;
    printf("Numero de elementos do vetor\n");
    scanf("%d",&n);
    return n;
}

int funcaointroduzir(int v[],int tam){
     int i;
     for (i=0; i<tam; i++){
         printf("%d = ? ", i);
         scanf("%d", &v[i]);
     }
}

void funcaoimprime(int v[], int tam){
     int i;
     for (i=0; i<tam; i++)
         printf("%d = %d\n", i, v[i]);
}

A minha questão é a seguinte:

Como faço para verificar se as duas primeiras funcoes(duas primeiras alineas do enunciado) já foram chamadas de forma a que a terceira alinea possa ser visualizada pelo utilizador...

Isto é começamos o programa o utilizador insere 3 queria dizer algo como Erro tem que fazer a opcao 1 e 2... Mas mesmo que ele faca a 1 TEM que obrigatoriamente fazer a 2 senao esta-me a mostrar o vector com zeros...

Desculpem o incómodo

[HappyHippyHippo]

podes simplesmente usar uma variavel de estado ...

se a variavel tiver 1 quer dizer que deverá somente poder escolher a opcao 1, se tiver 2 quer dizer que so pode escolher a opção 2 ... (uma solução bem simplista)

[Flames]

podes simplesmente usar uma variavel de estado ...

se a variavel tiver 1 quer dizer que deverá somente poder escolher a opcao 1, se tiver 2 quer dizer que so pode escolher a opção 2 ... (uma solução bem simplista)

ohhhh pah é mais simples do que consigo alcançar...

Podes explicar melhor a variavel de estado?

[Flinger]

Qualquer coisa como:

int opcaopossivel=1;

Em cada opção (switch na main) verificas se esta variável é menor que a opção correspondente. Se fôr, o utilizador ainda não pode usar essa opção, primeiro tem de executar a opção referenciada na variavel opcaopossivel. Se for menor ou igual, executas a opção e incrementas esse valor (ou seja, se opcaopossivel ==1 e estás a executar a opcao 1, entao opcaopossivel =2).

[pmg]

E se tirasses o ciclo do e fizessses directamente o pedido no enunciado? ??? 😄

int main(void){
       int opcao;
       int n;
       int vetor[MAX]={0};
   //do{

       //opcao=menu();
       //switch (opcao) {

            //case 1:
            //{
                n=funcaon();
                //break;
                //}

            //case 2:
            //{
                funcaointroduzir(vetor,n);
                //break;
                //}
             //case 3:
            //{
                funcaoimprime(vetor,n);
                //break;
                //}
            //}
        //}
    //while(opcao!=4);

return 0;
}

[Flames]

E se tirasses o ciclo do e fizessses directamente o pedido no enunciado? ??? 😄

int main(void){
       int opcao;
       int n;
       int vetor[MAX]={0};
   //do{

       //opcao=menu();
       //switch (opcao) {

            //case 1:
            //{
                n=funcaon();
                //break;
                //}

            //case 2:
            //{
                funcaointroduzir(vetor,n);
                //break;
                //}
             //case 3:
            //{
                funcaoimprime(vetor,n);
                //break;
                //}
            //}
        //}
    //while(opcao!=4);

return 0;
}

Como assim tirar o ciclo? quero que repita tantas vezes quanto o utilizador quiser... Nao percebi muito bem xD

[Flinger]

podes sempre só dar 2 opções ao utilizador:

1- Nova lista

2 - Sair

e dentro da 1 fazes tudo sequencialmente:

  n=funcaon();

  funcaointroduzir(vetor,n);

  funcaoimprime(vetor,n);

[pmg]

Como assim tirar o ciclo? quero que repita tantas vezes quanto o utilizador quiser... Nao percebi muito bem xD

Ah! Entao faz o ciclo controlar so a repeticao. Cada repeticao é o conjunto de operacoes a efectuar, que, por exemplo, retornam 0 se é para continuar, outro valor se é para parar

for (; {
    if (!passo1()) break;
    if (!passo2()) break;
    /* ... */
    if (!passoN()) break;
    if (!repetir()) break;
}

[Flames]

podes sempre só dar 2 opções ao utilizador:

1- Nova lista

2 - Sair

e dentro da 1 fazes tudo sequencialmente:

  n=funcaon();

  funcaointroduzir(vetor,n);

  funcaoimprime(vetor,n);

Pois só que o exercicio não acaba nessas opcoes... Se fizer tudo sequencialmente vai encontrar o maior numero da lista depois encontrar o menor depois faz o somatorio blablabla

O utilizador apenas necessita impiricamente de 1 opcao...

Btw aquilo do if (opcaopossivel<opcao) verifico em cada case... e se der tipo erro faco o quê? break? :S

[Flinger]

Sim, imprimes a mensagem a avisar o erro e fazes break;

[Flames]

Fiz algo assim

switch (opcao) {
            if (opcaopossivel<opcao)
                    break;
            else
                    opcaopossivel++;
            case 1:

Não é necessario ver em cada case n, mas sim verificar logo ao principio se falha...

[Flinger]

Se calhar é mais fácil fazeres com 2 variaveis

n_introduzido e vector_introduzido:

switch (opcao) {
                               
            case 1:   n=funcaon();
                           n_introduzido=1;
                           vector_introduzido =0;
            case 2:   if (n_introduzido ==0)
                           {
                                printf("introduza o n\n");
                                break; 
                           }
                           else
                          {
                            ...
                            vector_introduzido=1;
                          }
            case 3: if (!n_introduzido || !vector_introduzido)
                           {
                                printf("introduza os dados do vector\n");
                                break; 
                           }
                         else ...
           ...

[Flames]

Se calhar é mais fácil fazeres com 2 variaveis

n_introduzido e vector_introduzido:

switch (opcao) {
                               
            case 1:   n=funcaon();
                           n_introduzido=1;
                           vector_introduzido =0;
            case 2:   if (n_introduzido ==0)
                           {
                                printf("introduza o n\n");
                                break; 
                           }
                           else
                          {
                            ...
                            vector_introduzido=1;
                          }
            case 3: if (!n_introduzido || !vector_introduzido)
                           {
                                printf("introduza os dados do vector\n");
                                break; 
                           }
                         else ...
           ...

Hmmmm segundo a primeira logica esta a criar um erro:

temos as seguintes opcoes

1

2

3

4

5

A primeira e a segunda têm que ser seleccionadas mas incrementando apenas um vai-me apenas garantir que ao selecionar a Terceira opcao seja aceite...

Mas se escolher a 1 e 2 e depois a 4?

Vai fazer 1+1 primeira iteracao pode escolher a opcao 2

vai fazer 2+1 segunda iteracao pode escolher a opcao 3

Mas nao quero a 3 opcao quero a 4 Ai que algoritmo :S

[Flinger]

Por isso te dei a opção das 2 variáveis.

Só precisas de testar para os 2 primeiros pontos. Uma variável diz-te se já passou pelo primeiro, a outra se já passou pelo segundo.

Quando passa pelo primeiro, assume que se alteras o n, tens de reeintroduzir o vector, por isso coloca sempre a variavel da segunda a 0. Tens de inicializar ambas as variáveis a 0 (ainda não passou por ambos os pontos).

Usando o outro algoritmo, pode definir os valores manualmente, isto é, no ponto 1 colocar a variavel a 2, e no ponto 2 colocas a variavel a N, em que N é a opção máxima (sair, por exemplo). Assim a partir do momento em que passas pelo 2.º ponto, todas as outras opções ficam possibilitadas (e nessas não mexes na variável).

[pmg]

Arranja um array com as opcoes possiveis e passa-o (em forma de ponteiro) de funcao em funcao, actualizando consoante a funcao executada ...

// podefazer[0] = 1 quer dizer que pode fazer opcao 1
// podefazer[1] = 0 quer dizer que nao pode fazer opcao 2
int podefazer[5] = {1, 0, 0, 0, 0};

opcao1(int *podefazer) {
  podefazer[0] = 1;
  podefazer[1] = 1;
  podefazer[2] = 0;
  podefazer[3] = 0;
}
opcao2(int *podefazer) {
  podefazer[0] = 1;
  podefazer[1] = 1;
  podefazer[2] = 1;
  podefazer[3] = 1;
}

Na funcao do menu verifica se podefazer[OPCAO ESCOLHIDA] permite a escolha

[Flames]

Arranja um array com as opcoes possiveis e passa-o (em forma de ponteiro) de funcao em funcao, actualizando consoante a funcao executada ...

// podefazer[0] = 1 quer dizer que pode fazer opcao 1
// podefazer[1] = 0 quer dizer que nao pode fazer opcao 2
int podefazer[5] = {1, 0, 0, 0, 0};

opcao1(int *podefazer) {
  podefazer[0] = 1;
  podefazer[1] = 1;
  podefazer[2] = 0;
  podefazer[3] = 0;
}
opcao2(int *podefazer) {
  podefazer[0] = 1;
  podefazer[1] = 1;
  podefazer[2] = 1;
  podefazer[3] = 1;
}

Na funcao do menu verifica se podefazer[OPCAO ESCOLHIDA] permite a escolha

Ainda nao entramos em ponteiros por isso não os podemos utilizar xD

[pmg]

int funcaointroduzir(int vetor[], int n);

Ainda nao entramos em ponteiros por isso não os podemos utilizar xD

Aquilo ali em cima, o prototipo da funcao funcaointroduzir, tem um ponteiro (com uma sintaxe que faz parecer um array).

Se ja deste arrays (ou vectores) e passagem de arrays (ou vectores) entre funcoes e nao entraste em ponteiros ... a meu ver ... alguma coisa esta muito mal.

[Flames]

Aquilo ali em cima, o prototipo da funcao funcaointroduzir, tem um ponteiro (com uma sintaxe que faz parecer um array).

Se ja deste arrays (ou vectores) e passagem de arrays (ou vectores) entre funcoes e nao entraste em ponteiros ... a meu ver ... alguma coisa esta muito mal.

A lógica que penso que está a ser seguida é tentarmos "mecanicamente" ver como tudo funciona para introduzir a fundo os ponteiros para vermos como fica tudo facilitado