the vector's type is inside the related <> pair.
a * pointer symbol modifies the left item, making it a pointer:
int *x; //x is of type int pointer
foo *x;//x is of type foo pointer
vector<foo> * x; //x of type vector pointer, and the vector is of type foo, or putting all
those together the type is pointer to vector of foos, is the best way to say it. The english comes off a little out of order to the C++ in that case; trying to say it left to right sounds off (vector of foo pointer is OK, but out loud, unclear if its vector of foo or vector of *foo so better to reorder the words for clarity)
or the other one
vector <*foo> x; //x is a vector of pointers to foos, or, THIS is what I think of when you say "vector of foo pointers" as above, though it remains unclear.
ttx has a bunch of pointers to the first element, because you loaded it in the loop. if you had used back instead, it would have a pointer to each element.
tt only has one valid entry, so using it after incrementing it is an error. tt is incremented by the size of ttt, but that isn't very large, since vectors store their data in a pointer (size 8 bytes typically). Try sizeof() on a vector sometime, its tiny.
*tt, *tt ... one way to print tt's contents. You can rig up all kinds of ways to print the vector under tt, though.
edit -- that may need () or something since pointer and vector both have a  operator, it could hate on it. But generally some sort of dereference tt and access that as a vector. even tt->operator(0) if you want.
Incrementing a pointer (using ++) only really makes sense if it points to an element in an array (or vector). It makes the pointer point to the next element in the array. There is no reason to increment tt because it doesn't point to an array element.
Note that vectors sometimes need to move its elements to a new location in memory. This can happen when you add a new element and the array where the vector stores its elements is too small. If that happens it will have to allocate a new larger array and copy/move the elements to the new array. So you need to be careful when storing pointers to vector elements. It's very likely that the first element of ttx (ttx) is now "dangling" (i.e. it points to memory that has now been released).
*tt, *tt ... one way to print tt's contents.
No that's not how you do it. *tt means *(tt), i.e. access the first vector and then try to dereference it. Vectors don't have a dereference operator so it will give you a compilation error.
that may need () or something since pointer and vector both have a  operator, it could hate on it. But generally some sort of dereference tt and access that as a vector. even tt->operator(0) if you want.
No need to complicate things. Just dereference the pointer inside parentheses before accessing the vector element.
1 2 3 4
for (size_t i = 0; i < tt->size(); i++)
cout << (*tt)[i] << '\n';
Note that tt->size() is a shorthand syntax for (*tt).size().