What do you mean by operator precedence in c plus plus?

Answer 1

Operator overloading is a mechanism where a C++ developer can assign a special meaning to an operator (such as + or -, for example). This is useful, because it allows developers to create classes that can interact with other classes or primitives naturally, using the same syntax as you'd expect when working with primitives. For example, using operator overloading allows cin and cout to work "magically":

cout << "Hello World" << endl;

Even though it appears that these are just "shift operations", they take on the special meaning of outputting (for cout) and inputting (for cin) without resorting to a more cumbersome:

cout.print("Hello World\n");

This short example doesn't illustrate the savings that this syntax allows; a string of 20 variables would very nicely outline how the shift operators streamline cout.

Unfortunately, this usage is considered controversial, because it allows developers to use odd syntax. Consider the following:

Vehicle car = new Vehicle();

Velocity speed = new Velocity(15);

car += speed;

This is legal syntax with operator overloading. While it might make sense to some developers, others less familiar with a library might need to dig down into the code to make sure that the effect is what the developer intended. This can slow down development and debugging. It is this controversial usage that has prompted future languages, such as Java, to specifically exclude such functionality in an attempt to keep code as legible as possible.

Answer 2

Every operator in C++ has some precedence or priority over the other and during the execution of the code the operator with higher priority will be executed first. It is similar to the BODMAS rule in mathematics

Answer 3

In truth, operator overloading is not needed per se. You can easily provide member methods and friend functions that emulate any operator.

Notable exceptions to this are the relational operators: ==, !=, <, <=, > and >=. Since comparing objects to each other is a fairly common operation these should almost always be implemented in every class. This is the downside to operator overloading since the only operator automatically provided by the compiler is the assignment operator. By rights, all seven operators should be automatically provided by the compiler, but the only implementation that would make sense for the relational operators is a member-by-member comparison, which would therefore depend upon the order the members are declared by the class.

In an ideal world, every class would be responsible for just one resource, so the point should be moot. However, this is not an ideal world; many classes simply do not adhere to the one resource rule. But C++ is nothing if not flexible, thus the programmer is given the freedom to choose which, if any, operators to provide.

The only real criteria for operator overloading is that the implementation be unambiguous and expected. The whole point of having operator overloads is to make it easier to use objects in an intuitive way. If an operator only serves to confuse your consumers, then do not provide one. In any event, all operators should either call member functions or friend functions as appropriate. Thus the operator simply serves as sugar-coating for these particular functions.

Answer 4

No. The member-of (.), pointer-to-member (.*), scope resolution (::), ternary conditional (:?), sizeof and typeid operators cannot be overloaded. The standard library as well as much of the language itself is reliant upon these operators behaving in a consistent manner regardless of the types involved, thus these operators are built-in and cannot be overloaded.

Answer 5

No. Operator precedence can only be changed by using parenthesis.