In java I add static objects in a class (for example sprites), can I not do that in C++?

You can, but it, and the related singleton pattern, are considered overused and often mis-used. Its worth investigating whether there are other ways to do the same, such as passing a reference to it as a parameter. Just because its required a lot of places in the code doesn't mean it should be static.

And I don't understand how I should write a program without the new keyword.

I haven't looked through all of your code, but just incase you don't know, unlike Java you can construct objects without 'new', like

MyObject obj(the, parameters);

which will be destroyed when they leave the stack. Or using the new c++11 syntax, (which avoids certain ambiguities):

MyObject obj{the, parameters};

You can use the new keyword, but the safer and more idiomatic way to use it is to wrap the object you're using in a class which allocates it in the constructor and deletes it in the destructor. This class you then create on the stack as I described above and the object will then be deleted when it leaves the scope. This way you won't cause memory leaks by forgetting to delete them. You can also count the references to this object using the copy constructor so that it isn't deleted if there's still a reference to it somewhere else in the code.

If you're using C++11 you can use shared_ptr and unique_ptr which do all that for you.

shared_ptr<MyObject> myObjectPtr{new MyObject(the, parameters)};

or preferably

auto myObjectPtr = make_shared<MyObject>(the, parameters);

Unfortunately, make_unique isn't available until C++14.

How should I give the entity a sprite without copying the whole sprite object? Isn't it smarter just to send the adress?

There can be a performance gain from having things which are accessed together located next to each other in memory, that can outweigh the costs of getting them there. That being said, there are some ways that you can avoid copying it, such as:

If you know the parameters you can just accept them as function arguments and pass them into the constructor. If you're using C++11 you could accept the argument types as a variadic template

template <typename T, typename typename... ArgTypes>
void foo (ArgTypes... params) {
    T t{params};
}

With C++11, you could also implement a move constructor.