Ordem de execução sobrecarga de operadores

[Sr. David Almeida]

Galera, estou trabalhando em uma serie de cálculos que usam por toda parte funções, para melhor entendimento, resolvi fazer sobrecarga de operadores. porém o resultado não está saindo como antes quando utilizava as funções. De modo que se eu utilizo parenteses para especificar que a ordem das operações é da esquerda para direita, o resultado sai como o esperado, como teste resolvi colocar um 'std::cout<<"(simbolo do operador)"...', para ver a ordem de execução, até que percebi que os cálculos aparecem de forma totalmente aleatória...

Queria saber como defino que a ordem de execução da operação será da esquerda para direita.

 

SO: Win7

IDE: Code::blocks

Compilador: GNU GCC

C++11 ISO

 

 

Desde já, grato.

[vangodp]

Podia por seu código para ver o problema, assim fica difícil vei.

[Sr. David Almeida]

Para ser mais especifico, eu só preciso de um método para priorizar operações, por exemplo: a multiplicação deve ser feita antes da soma.

[vangodp]

((((a++)*2)+10))

É só você ter na cabeça que o primeiro que vai ser calculado é o parêntesis que está mais adentro.

A conta anterior tem a seguinte ordem:
1º a++, vamos supor que a vale 10, depois de incrementar passa a valer 11

2º a*2 //11*2
3º 22+10 //o resultado de 11*2 somamos a 10.

 

É a única forma de garantir a ordem. Eu nem ligo muito para a prioridade dos operadores, melhor é você saber usar os ().
 

[Sr. David Almeida]

Poise, já tinha conseguido ter a ordem certa com os parenteses, só que achei meio feio como ficou e queria um jeito de garantir a ordem sem os parenteses...

[vangodp]

Feio?

[Sr. David Almeida]

Poise, não curti a operação cheia de parenteses, queria definir algo do tipo: 1º - Operador X, 2º - Operador Y, º Operador Z...

[Ansi C]

Boa noite para todos;

Se bem entendi a dúvida a assunto nos remete a precedência de operadores aritméticos:

s1- Para operações de *(multiplicação) /(divisão)

s2- Para operações de +(Soma) -(subtração)

Em qualquer operação que envolva um ou mais operadores do s1, estes serão execultados

primeiro, e s2 por final cada um obedecendo as respectivas regras de execução da esquerda

para direita. 

 

 

o que acontece aqui?

E.i: 10 * 6 / 3 + 4 - 5

   1p: 60 / 3 + 4 - 5

   2p: 20 + 4 - 5

   3p: 24 - 5

   4p: 19

 

E.i: 10 * 6 + 4 - 10 / 2

   1p: 60 + 4 - 10 / 2

   2p: 60 + 4 - 5

   3p: 64 - 5

   4p: 59

 

[vangodp]

ficar decorando regras nunca foi meu forte. Eu sempre prefiro usar os asteriscos que me parecem mais fácil de garantir a ordem.
Mas como é feio... >_<

Queria ver se em matemáticas te ia parecer feio algo como {-5+[-8+3X(-4+9)-3]}, dai você tentar buscar "atalhos" para amenizar o bagulho kkk

[Sr. David Almeida]

KKKKKKK.  Bem..., neste caso os parenteses se fazem necessários pôs sem eles e os outros separadores o resultado sairá diferente. Na minha humilde opinião feio é algo como:((-X-Y(+2Z(-3A)/7B) *3))

[Ansi C]

Boa noite;

Poderia equacionar com uma função:

 

//"Mesma coisa que ((-X-Y(+2Z(-3A)/7B) *3))"
	float array_var[] = { 3A, 7B, 2Z, Y, X, 3 };
	result = calc( "/-+-*", array_var );

Exemplo:

/* cFile.c Calculadora
   author Mauro Britivaldo
   */
#include <stdio.h>
float cal(char *str, float *numbers)
{
  float ret = *numbers++;
  while(*str)
  {
    switch(*str)
    {
      case '+': ret = ret + *numbers; break;
      case '-': ret = ret - *numbers; break;
      case '*': ret = ret * *numbers; break;
      case '/': ret = ret / *numbers; break;
      case '%': ret = (int)ret % ((int)*numbers); break;
    }
    str++, numbers++;
  }
  return (ret);
}
int main(void)
{
  float r = cal( "+*", (float[]){1, 2, 3} );

  printf( "Resultado: %f\n", r );
  return 0;
}

fica legal também