dot operator order of evaluation in c++

Question

I am reading "C++ Primer (5th Edition)" and I've run in something I'm not sure I understand correctly.

The example is pretty much similar to one they gave in the book. Imagine we have some function that returns string (or any class that has non-static members):

string some_function(par1, par2) {
     string str;
     // some code
     return str;
}

I know that you can use the return value of any function to access its members, i.e. something like this is valid:

auto size = some_function(arg1, arg2).size(); // or whatever member of class

However, since the dot operator . and function call operator () have left to right grouping and same precedence, the above expression should be something like this:

(some_function(arg1, arg2)).size()

I suppose I am right so far? The thing I don't understand here is order of evaluation. Since order of evaluation is not specified for . operator, it means that either some_function(arg1, arg2) or size() will be evaluated first. But how can it evaluate size() first if it doesn't know on which object is it working on? This implies that order of evaluation should be fixed from left to right, but it is not. How is this possible?

Another example is something like this:

 cin.get().get();

Again, it seems like first cin.get() should be evaluated before second get() since it won't know on which object is it working, but this doesn't seem to be necessarily the case.

Answer 1

Operators of the same precedence are evaluated according to their associativity, which you correctly observe is left-to-right for the operator group containing the function call and element selection operators. Therefore, yes, given the expression

x = foo().bar();

The order of operations is

x = (((foo()).bar)());

accounting for relative precedence and associativity of all operators involved. No one writes code in that manner, though.

Likewise, given

cin.get().get()

the order of operations is

(((cin.get)()).get)()

, so yes, the precedence rules result in the cin.get() sub-expression being evaluated first, yielding the object to which the second . (and thence the rest of the expression) is applied.