Wrap the std::vector in your own container class. Just a simple class to handle the mutex internally so the rest of your program doesn't need to worry about it.
That wrapper can provide a size() method that returns a cached value. When a insert/delete method is called on your wrapper, save a copy of the current size in an integer that is only modifiable from those methods, and return that from your size() method. Increment or decrement when appropriate while still inside the critical section.
How important is this size? Does it absolutely need to be accurate, particularly considering that the other threads can't do anything with the elements in the container until the thread doing an insert/remove is finished.
EDIT: From what you're describing, you seem to need a thread-safe queue. There are various ways of implementing these, but many programming APIs will provide you with packaged versions. I'm not sure of which windows API you're using, but check for some variant on "Queue" in your "Threading" section. In general, your internal size tracking variable becomes your semaphore.
You have two very different scenarios available here, depending on how you want to do this. If threads A, B and C are filling this vector buffer, and D is emptying the elements out one at a time, the implementation is relatively simple. This is one example I came up with by looking for 'thread safe queue windows' here on SO.
If you need to 'bunch up' the bundles of data, so that D only runs when A, B and C have accumulated some amount of data, you probably want a 2 stage solution internally. Your .add_data() method, that locks internally for safety between A, B and C, will check the size of the vector and if it's over a threshold, drop it into a seperate thread-safe queue that is the input for D, then clear itself and return.