从排序比较器 function 内部访问该向量时，在向量中找到 Null 值

Question

I had a vector of some shared pointers. I was trying to sort that vector according to some criteria using sort comparator function. The problem is that if we try to access the values of the vector from inside the comparator function; at certain places I was getting null values. This is happening only in the case of shared pointers. For normal pointers, I didn't find such problem. Why are we getting null values inside the vector in such scenario?

My code-

class Tmp {
private :
    int a,b;
public :
    int getA() {
        return a;
    }
    int getB() {
        return b;
    }
    Tmp(int x, int y) : a(x), b(y) {}
};

int main() {
    std::shared_ptr<Tmp> t1 = std::make_shared<Tmp>(11,19);
    std::shared_ptr<Tmp> t2 = std::make_shared<Tmp>(2,3);
    std::shared_ptr<Tmp> t3 = std::make_shared<Tmp>(5,6);
    std::shared_ptr<Tmp> t4 = std::make_shared<Tmp>(3,5);

    vector<std::shared_ptr<Tmp>> v;
    v.push_back(t1);
    v.push_back(t2);
    v.push_back(t3);
    v.push_back(t4);

    auto fun = [&v] (std::shared_ptr<Tmp> &l, std::shared_ptr<Tmp> &r) -> bool {
      for (auto it : v) {
        if (!it) {
            cout<<"null value"<<endl;
        } else {
            cout<<it->getA()<<", "<<it->getB()<<endl;
        }  
      }
      cout<<"-------"<<endl;
      return (l->getA() < r->getA());
  };
  sort(v.begin(), v.end(), fun);
  return 0;
}

Output

11, 19
2, 3
5, 6
3, 5
-------
2, 3
11, 19
5, 6
3, 5
-------
2, 3
11, 19
null value
3, 5
-------
2, 3
null value
11, 19
3, 5
-------
2, 3
5, 6
11, 19
3, 5
-------
2, 3
5, 6
11, 19
null value
-------
2, 3
5, 6
null value
11, 19
-------
2, 3
null value
5, 6
11, 19
-------

Answer 1

You don't explain what you expected. It would be easier to answer your question usefully if it was clear why you thought this was sensible.

Imagine you're sorting some stacks of papers. You're going to be moving those papers around. Sometimes, you'll take one out of the stacks to hold aside until you decide where it will go. Anyone looking at the contents of the stacks while you are sorting them should expect to see missing papers, empty spaces, stuff where it doesn't belong, and so on because you are in the middle of sorting them .

The null values you see are slots that the sorting algorithm has not yet decided what object to fill with. When the slots contains pure values that have no special semantics, the slot will hold a garbage value while it's being worked on. When the slots contains more complex objects, the slots will tend to hold a moved-from object, which for std::shared_ptr is one that tests false.