Q: How would a object add itself to a vector inside the object's class? I'm pretty new with classes.
How would the Particle add itself into a std::vector inside the class? 
My code:
std::vector<Particle> particles;

class Particle
{
    public:
        Particle(sf::Vector2f position)
        {
            particles.push_back(/*add this Particle into vector particles*/);
        }
};


A: If all you need is to push a copy of the particle to the vector, then you can de-reference the this pointer and push that into the vector like so:
particles.push_back(*this)

This creates a copy though, and does not refer to the original object it's called from but an entirely new one. If you want to push the original particle to the vector then you would need to make the vector store a Particle*. You could then push the current particle to the vector like so:
std::vector<Particle*> particles;

class Particle
{
public:
    Particle(/* Your constructor args */)
    {
        particles.push_back(this)
    }

}


A: std::vector<Particle> is storing the particles by value, so it can't add "itself" to that vector, it could add a copy, but that is maybe not what you want.
emplace_back might be used to construct the Particle into the vector itself:
particles.emplace_back(position); // Will call Particle(position)

If you do want a copy, just deference the this pointer, but that could be confusing. Do not do this in the copy/move constructor or copy/move assignment operator, as those can be called by vector itself during an insert/remove/etc.
Particle(sf::Vector2f position)
{
    particles.push_back(*this);
}

Otherwise you could store pointers in a vector. That brings extra questions like who is responsible to free them, and for things like a particle system can have a major performance impact.
std::vector<Particle*> particles;

class Particle
{
    public:
        Particle(sf::Vector2f position)
        {
            particles.push_back(this); // Dangerous
            // If an exception happens after push_back this object will be destroyed,
            // but particles will still contain that now invalid pointer.
        }
};


...

auto particle = new Particle(position); // Who deletes this?

If particles is responsible for deleting, you might use std::unique_ptr, but doing so in the constructor is potentially unsafe.
std::vector<std::unique_ptr<Particle>> particles;

class Particle
{
    public:
        Particle(sf::Vector2f position)
        {
            particles.push_back(std::unique_ptr<Particle>(this)); // Dangerous
            // If an exception happens in push_back or after this in the constructor
            // the exception will cause this Particle to be destroyed, but this unique_ptr
            // will be left with an invalid pointer, and try and delete it as well.
        }
};


...

new Particle(position);

Better to do it outside, in some other function.
std::vector<std::unique_ptr<Particle>> particles;

class Particle
{
    public:
        Particle(sf::Vector2f position)
        {}
};
...
particles.push_back(std::make_unique<Particle>(position));


A: I would suggest that you bail on all the answers so far; and create a new wrapping class; as I think fundamentally your design is weak.
class Particle {};

struct ParticleGroup {
    Particle& createParticle() {
        particles.push_back(Particle());
        return particles.back();
    }

    std::vector<Particle> particles;
};

The joy of doing this is that you can now create a particle that doesn't get rammed into your vector by force (which may be useful for testing/serialisation/other uses); but you've made it so that if you go to your particle group; you don't have to worry about how the particle is stored.  (for example when you realise that you actually want a list because of the random removes; you don't want to have to re-write everything!)
