A std::vector already does this memory management for you.
When you use an std::vector with simple classes like this, you do not need any new or delete calls.
reserve
Under the hood, reserve is just making sure that a chunk of memory is preallocated to hold the specified number of member variables.
resize
Under the hood, resize will actually create n new objects. You do not need to explictly call new.
Your example
The code *(new aa()) will create a new aa object on the heap. When you write vec[0] = *(new aa()); it will attempt to copy the contents of your new object to the object that lives in the address vec[0]. Thus there are 2 distinct objects alive at this point in time ...  one object vec[0] at one place in memory, and one object elsewhere in memory.
What's worse is that you have now called new and never deleted that object. You thus have a memory leak.
What you probably want
Almost certainly, what you will want one of these scenarios.
Create a vector, and then resize it to have n elements. Then use those elements:
int main() {
    std::vector<aa> vec;
    vec.resize(2);
    vec[0].i = ...;
    vec[1].i = ...;
    //use the vector
    return 0;
}
push_back elements when you want to add things
int main() {
    std::vector<aa> vec;
    vec.push_back(aa()); // Creates a new aa instance and copies into the vector 
    aa obj;
    vec.push_back(obj); // Copies the existing object's data into a new object in the vector. 
    //use the vector
    return 0;
}
The destructor of vector will delete all of the memory appropriately. No need to explicity clear in this example.
There are more advanced ways that you can use vector, but until you understand this code, you probably should just stick to these basics.