Eventos do mouse em C++ usando SFML

#include "Vector2D.h"
#include <math.h>
#define PI 3.1416

float Vector2D::size(){// função para encontrar o tamanho do vetor
    return sqrt((x*x) + (y*y));
}

Vector2D Vector2D::operator +(const Vector2D& other) const {//função para soma dos vetores
	return Vector2D(x + other.x, y + other.y);
}

Vector2D& Vector2D::operator +=(const Vector2D& other) {//função para soma dos vetores
	x += other.x;
	y += other.y;
	return *this;
}

Vector2D Vector2D::operator *(float scalar) const {//função para multiplicação de vetores
	return Vector2D(x * scalar, y * scalar);
}

Vector2D& Vector2D::operator *=(float scalar) {//função para multiplicação de vetores
	x *= scalar;
	y *= scalar;
	return *this;
}

Vector2D Vector2D::operator /(float scalar) const {
	return Vector2D(x / scalar, y / scalar);
}

Vector2D& Vector2D::operator /=(float scalar) {
	x /= scalar;
	y /= scalar;
	return *this;
}

Vector2D& Vector2D::normalize(){//função que reduz o tamanho do vetor para 1para poder ser multiplicado por um por um escalar
    return (*this /= size());
}

Vector2D Vector2D::bySizeAndAngle (float size, float angle){//função que recebe os valores de angulo e força
    return Vector2D(cos(size) * size, sin(size) * size);
}

float Vector2D::angle() const{// função que retorna o angulo
    return atan2f(y,x);
}

float Vector2D::angleBetween (const Vector2D& other) const {//função de calculo entre o angulo de dois vetores unitarios
	float dp = dot(other);

	//Força que o valor esteja na faixa esperada pelo C++
	//Se os floats fossem totalmente precisos,
	//não precisaríamos fazer esses testes
	if (dp >= 1.0) {
		dp = 1.0f;
	} else if(dp <= -1.0) {
		dp = -1.0f;
	}

	//Faz o cálculo do ângulo. O C++ sempre retorna positivo
	float angPi = (float) acos(dp);

	//teste de lado para definir o sinal
	return ((y * other.x) > (x * other.y)) ? -angPi : angPi;
}

float grad2radians(float grad) {//função que transforma graus em radianos
	return (grad / 180) * PI;
}

float radians2grad(float radians) {//função que transforma radianos em graus
	return (radians * 180) / PI;
}

Vector2D& Vector2D::rotate(float angle){//função para rotacionar o vetor
    float s = sin(angle);
    float c = cos(angle);
    float _x = (x * c) - (y * s);
    float _y = (x * s) + (y * c);
    x = _x;
    y = _y;
    return *this;
}

float Vector2D::dot(const Vector2D& other) const{//função para calculo do produto escalar
    return (x * other.x) + (y * other.y);
}

Vector2D::~Vector2D(){
}

#ifndef VECTOR2D_H
#define VECTOR2D_H

class Vector2D
{
    public:
        float x;
        float y;
        Vector2D() : x (0.0f), y (0.0f) {}
        Vector2D(float _x, float _y) : x(_x), y(_y) {}
        float size();
        Vector2D operator +(const Vector2D& other) const;
        Vector2D& operator +=(const Vector2D& other);
        Vector2D operator *(float scalar) const;
        Vector2D& operator *=(float scalar);
        Vector2D operator /(float scalar) const;
        Vector2D& operator /=(float scalar);
        Vector2D& normalize();
        Vector2D bySizeAndAngle (float size, float angle);
        float angle() const;
        Vector2D& rotate(float angle);
        Vector2D& angleBetween(const Vector2D& other) const;
        float dot(const Vector2D& other) const;
        virtual ~Vector2D();
};

#endif // VECTOR2D_H

#include <SFML/Graphics.hpp>

#include <iostream>
#include "Vector2D.h"

using namespace std;

int main(){
    sf::RenderWindow Screen(sf::VideoMode(800, 600, 32), "Triangulo 2D");
    //Vector2D vetor(3,4);
    Vector2D va(3,4);
    Vector2D vb(4,5);
    va+=vb;
    cout << va.x << "" << vb.y << endl;

    while (Screen.IsOpened())
    {
        sf::Event* event = new sf::Event();
        while (Screen.GetEvent(*event))
        {
            if (event->Type == sf::Event::Closed)
            {
                Screen.Close();
            }
        }
        if (Screen.GetInput().IsKeyDown(sf::Key::Escape))
        {
            return EXIT_SUCCESS;
        }

        Screen.Display();
    return EXIT_SUCCESS;
}
}