*(&vectorObj[0] + 7)

*(vectorObj.begin() + 7)

std::vector<int> arr;
...
int* ptr = &arr[0];
или
int* ptr = &arr.front();
или
int* ptr = &(*arr.begin());

ptr[i] = ...;

  std::vector<int> arr;
  
  for (int i = 0; i < 5; ++i)
  {
    arr.push_back(i);
  }

     arr: 1, 2, 3, 4 ^
          ^          |
          |          |
arr.begin()  arr.end()

  std::vector<int>::iterator it    = arr.begin();
  std::vector<int>::iterator last  = arr.end();

  for (; it != last; ++it)
  {
    std::cout << *it << std::endl;
  }

  std::vector<int>::iterator it = arr.begin();

  std::cout << *(it + 7) << std::endl;

std::vector<myobject*> vec = ...;

for(size_t i = 0; i < row_count; i++)
for(size_t j = 0; j < col_count; j++)
    vec[i][j] = ...;

std::vector<std::vector<int> > arr2d;
...
int* pRow6 = &arr2d[6][0];
или
int* pRow6 = &(*arr2d[6].begin());
или
int* pRow6 = &arr2d[6].front();

Obj *myobj = vector[6];

АШ>Obj *myobj = vector[6];
АШ>

АШ>А далее myobj + 1, + 2

std::vector<std::vector<Obj*> > vec;

Obj** ptr = &vec[6][0];

B>std::vector<std::vector<int> > arr2d;
B>...
B>int* pRow6 = &arr2d[6][0];
B>или
B>int* pRow6 = &(*arr2d[6].begin());
B>или
B>int* pRow6 = &arr2d[6].front();
B>

std::vector<std::vector<Foo*> > arr2d(10, std::vector<Foo*>(10));
//здесь как-то инициализируем указатели
Foo **p = &a[6][0];

K>*(&vectorObj[0] + 7)
K>

K>*(vectorObj.begin() + 7)
K>

Отдельные подозрительные личности утверждают, что &v[0] можно заменить на v.begin(), поскольку begin возвращает итератор, а для vector итератор в действительности представляет собой указатель. Во многих случаях это действительно так, но [...] это правило соблюдается не всегда, и полагаться на него не стоит. Функция begin возвращает итератор, а не указатель, поэтому она никогда не должна использоваться для получения указателя на данные vector. А если уже вам очень приглянулась запись v.begin(), используйте конструкцию &*v.begin() — она вернет тот же указатель, что и &v[0], хотя это увеличивает количество вводимых символов и затрудняет работу людей, пытающихся разобраться в вашей программе. Если знакомые вам советуют использовать v.begin() вместо &v[0] — лучше смените круг общения.

namespace std {
template <class T, class Allocator = allocator<T> >
class vector {
public:
// types:
typedef typename Allocator::reference reference;
typedef typename Allocator::const_reference const_reference;
typedef implementation defined iterator; // See 23.1
typedef implementation defined const_iterator; // See 23.1
typedef implementation defined size_type; // See 23.1
typedef implementation defined difference_type;// See 23.1
//...

23.2.4 Class template vector
1 A vector is a kind of sequence that supports random access iterators. In addition, it supports (amortized) constant time insert and erase operations at the end; insert and erase in the middle take linear time. Storage management is handled automatically, though hints can be given to improve efficiency. The elements of a vector are stored contiguously, meaning that if v is a vector<T, Allocator> where T is some type
other than bool, then it obeys the identity &v[n] == &v[0] + n for all 0 <= n < v.size().

Date: April 11, 2004

Replace subclause 23.2.4, paragraph 1.
Original:
1 A vector is a kind of sequence that supports random access iterators. In addition, it supports (amortized)
constant time insert and erase operations at the end; insert and erase in the middle take linear time. Storage
management is handled automatically, though hints can be given to improve efficiency.


Replacement:
1 A vector is a kind of sequence that supports random access iterators. In addition, it supports (amortized)
constant time insert and erase operations at the end; insert and erase in the middle take linear time. Storage
management is handled automatically, though hints can be given to improve efficiency. The elements of a
vector are stored contiguously, meaning that if v is a vector<T, Allocator> where T is some type
other than bool, then it obeys the identity &v[n] == &v[0] + n for all 0 <= n < v.size().