Odwołania do obiektów i wskazniki

Witam! Może to będzie głupie pytanie, ale chyba jestem już zmęczony, ale nie dam za wygrana....

Założmy, że mamy taką sytuację:
Mam klase
Czlowiek

w niej takie pole Cos * cos;
gdzie cos jest tablica dynamiczną...

i każde cos ma w sobie jakis rozmiar typu int...

i teraz w main tworze Czlowiek * czlowiek = new Czlowiek();

i jak odwolam się tak czlowiek->cos[6].rozmiar++;

to rozmiar powinien trwale się zwiekszyć o 1?

Tak, tylko że radzę używać przedrostkowej wersji.

tzn, (czlowiek->cos + 6) -> rozmiar?

Nie.

++czlowiek->cos[6].rozmiar;

z tym że lepiej tak zapisz: ++(czlowiek->cos[6].rozmiar);

Ale po co ci tu w ogole jakies wskazniki?

#include <iostream>
#include <vector>
using namespace std;


class Something {
  size_t _size;

public:
  Something(size_t size): _size(size) {}

  size_t& size() {
    return _size;
  }

  friend ostream& operator<<(ostream& out, const Something& sth) {
    return out << "Something{" << sth._size << "};";
  }
};

class Person {
  vector<Something> _somethings;

public:
  Person(vector<Something> somethings): _somethings(somethings) {}

  vector<Something>& somethings() {
    return _somethings;
  }

  friend ostream& operator<<(ostream& out, const Person& p) {
    for(const Something& sth : p._somethings) out << sth << "\n";
    return out;
  }
};

int main() {
  vector<Something> somethings{Something(123), Something(12)};
  Person p{somethings}; cout << p << "\n\n";
  p.somethings()[1].size() = 49999; cout << p;
}