调用vector.empty（）时为EX_BAD_ACCESS

Question

I'm getting a EX_BAD_ACCESS when calling vector.empty on an empty vector.

bool empty = elements.empty();

Its throwing the exception here;

      /**
       *  Returns a read-only (constant) iterator that points one past
       *  the last element in the %vector.  Iteration is done in
       *  ordinary element order.
       */
      const_iterator
      end() const
      { return const_iterator(this->_M_impl._M_finish); } // EXCEPTION

when calling;

  /**
   *  Returns true if the %vector is empty.  (Thus begin() would
   *  equal end().)
   */
  bool
  empty() const
  { return begin() == end(); } // EXCEPTION

Answer 1

As @microtherion stated, elements is most likely an invalid object. A simple way this this can happen:

std::vector<MyType> *theElements = nullptr;
std::vector<MyType> &elements = *theElements;
bool empty = elements.empty();

Or by returning a vector reference that is a temporary object and dies when it goes out of scope at the end of the function:

std::vector<MyType>& GetElements() {
  std::vector<MyType> temporaryElements;
  //add to vector here.
  return temporaryElements;
}

void foo() {
  std::vector<MyType> &elements = GetElements();
  bool empty = elements.empty();
}

Or by holding a reference to a member variable of another class that gets cleaned up before:

class Foo {
  private: std::vector<MyType> mElements;
  public: std::vector<MyType>& GetElements();
};

class Bar {
private:
  std::vector<MyType>& elements;
public:
  Bar(Foo& foo) : elements(foo.GetElements()) { }

  void Do(void) { bool empty = elements.empty(); }
};

//Probably much more hidden between multiple function calls, rather than this clear example.
void func(void) {
  Bar* bar = nullptr;
  {
    Foo foo;
    bar = new Bar(foo);
    //foo dies, and so does the elements vector bar.elements refers to.
  }

  bar->Do();
  delete bar;
}

Answer 2

The most likely reason for this is that elements is an invalid object at that point. You should never get this exception for a valid vector object.