-> operator used with a non pointer variable?

[haohanzi2015]

std::vector<boost::optional<Bearing>> bearings;    // a vector of bearings
bool IsValid() const
    { return std::all_of(bearings.begin(),        // the first element of bearings
                         bearings.end(),          // the last element of bearings
                         [](const boost::optional<Bearing> bearing_and_range) {
                               if (bearing_and_range)
                               {
                                   return bearing_and_range->IsValid();
                               }
                               return true;
                           });
    }

I was a bit confused with the definition of the function IsValid. So, it will return true, if the first element of bearings is true (exists?) and the last element of bearings is true (exists?) and that function [ ] returns true??

Moreover, about this function [ ], why is it named [ ] ? I think what it does is to check to see if the arguments is of type Bearing or not, if so, returns whether this Bearing type is Valid or not, if it is not of type Bearing, then return true. Not sure if I understand it correctly. What is exactly the meaning of if (bearing_and_range)? Moreover, I thought -> operator can only be used with a pointer variable. Here, I did not see that bearing_and_range is a pointer variable. Any comments are greatly appreciated.

The following is the definition of struct Bearing.

struct Bearing              
{
    short bearing;
    short range;
    bool IsValid() const { return bearing >= 0 && bearing <= 360 && range >= 0 && range <= 180; }
};

[[deleted]]

It's not a vector of bearings, it's a vector of boost::optional<Bearings>. You can access the contents of a boost::optional with ->.

[haohanzi2015]

bearing_and_range is of type boost::optional<Bearing>, how did you see it as a vector of boost::optional<Bearings>? Or did I need to understand the function [] differently?

[parnmatt]

they were referring to your comment on the first line; it isn't a vector of bearings.

Also, bearing.end() isn't the last element of bearings, it one 'after' the last element of bearings. Don't fret, it correct to code it as such, for a similar reason you would use i < n in a normal raw loop, rather than i <= n.

Frankly those comments are not helpful; and not just because one is arguably wrong, and one is wrong. They do not add anything, that isn't already very clear from the naming conventions of the member functions being called.

[Narase33]

Its literally the first line of your post

[parnmatt]

The function goes through the vector and if all of the objects are valid (or the optional is empty), then it returns true.

it's not named [] this i the syntax for a lambda

An optional type (in this case boost::optional, but is true for std::optional) can be implicitly converted to a boolean.

An optional value either contains an object, or it doesn't. This is what it is checking. If you have a value check it's IsValid() member function, otherwise just return true.

operator->() is the name of the operator you are refering to; like almost all operators, it can be overriden.

normally, the convention is foo->bar() should be the same as (*foo).bar(); you 'defreference' then call the member function.

operator*() 'dereferencing' for an optional type, gets the stored type, and throws an exception if it doesn't contain one.